This is an archive of the discontinued LLVM Phabricator instance.

Differential D22162

[libcxx] [test] Mark bucket_count() equality assertions as nonportable.
ClosedPublic

Authored by STL_MSFT on Jul 8 2016, 12:28 PM.

Details

Reviewers
mclow.lists
EricWF
Summary

Mark bucket_count() equality assertions as nonportable.

There's nothing in the Standard preventing an unordered container from always having a bucket count of at least 1000, or whatever. Any assertions for exact equality are nonportable and should be marked as such.

Diff Detail

Event Timeline

STL_MSFT updated this revision to Diff 63292.Jul 8 2016, 12:28 PM
STL_MSFT retitled this revision from to [libcxx] [test] Mark bucket_count() equality assertions as nonportable..
STL_MSFT updated this object.
STL_MSFT added reviewers: EricWF, mclow.lists.
STL_MSFT added a subscriber: cfe-commits.
EricWF accepted this revision.Jul 24 2016, 5:32 PM
EricWF edited edge metadata.

It's not great that our tests have so many non-portable assertions. Normally we want to avoid writing non-standard assertions at all, but there doesn't seem to be a way around it here.
However there's no easy way to fix that here, so thank you for making all these tests portable.

I wish there weren't so many changes though :-(

This revision is now accepted and ready to land.Jul 24 2016, 5:32 PM
EricWF closed this revision.Jul 24 2016, 5:34 PM

r276593.

Revision Contents

PathSize
test/
std/
containers/
unord/
unord.map/
4 lines
13 lines
5 lines
24 lines
unord.map.cnstr/
9 lines
5 lines
9 lines
7 lines
5 lines
7 lines
5 lines
5 lines
5 lines
5 lines
9 lines
5 lines
5 lines
5 lines
5 lines
5 lines
5 lines
5 lines
5 lines
5 lines
5 lines
unord.map.swap/
24 lines
unord.multimap/
4 lines
6 lines
10 lines
13 lines
9 lines
25 lines
unord.multimap.cnstr/
9 lines
5 lines
9 lines
7 lines
5 lines
7 lines
5 lines
5 lines
5 lines
5 lines
9 lines
5 lines
5 lines
5 lines
5 lines
5 lines
5 lines
5 lines
5 lines
5 lines
5 lines
unord.multimap.swap/
25 lines
unord.multiset/
5 lines
6 lines
10 lines
13 lines
9 lines
25 lines
unord.multiset.cnstr/
9 lines
5 lines
11 lines
7 lines
5 lines
7 lines
5 lines
5 lines
5 lines
5 lines
9 lines
5 lines
5 lines
5 lines
5 lines
5 lines
5 lines
5 lines
5 lines
5 lines
5 lines
unord.multiset.swap/
25 lines
unord.set/
5 lines
13 lines
5 lines
25 lines
unord.set.cnstr/
9 lines
5 lines
9 lines
7 lines
5 lines
7 lines
5 lines
5 lines
5 lines
5 lines
9 lines
5 lines
5 lines
5 lines
5 lines
3 lines
5 lines
5 lines
5 lines
5 lines
unord.set.swap/
25 lines

Diff 63292

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

Show All 21 Lines
#include "test_macros.h" #include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::unordered_map<int, std::string> C; typedef std::unordered_map<int, std::string> C;
const C c; const C c;
assert(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
} }
{ {
typedef std::unordered_map<int, std::string> C; typedef std::unordered_map<int, std::string> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
P(30, "thirty"), P(30, "thirty"),
P(40, "forty"), P(40, "forty"),
P(50, "fifty"), P(50, "fifty"),
P(60, "sixty"), P(60, "sixty"),
P(70, "seventy"), P(70, "seventy"),
P(80, "eighty"), P(80, "eighty"),
}; };
const C c(std::begin(a), std::end(a)); const C c(std::begin(a), std::end(a));
assert(c.bucket_count() >= 11); assert(c.bucket_count() >= 11);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C; min_allocator<std::pair<const int, std::string>>> C;
const C c; const C c;
assert(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
} }
{ {
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C; min_allocator<std::pair<const int, std::string>>> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
P(10, "ten"), P(10, "ten"),
Show All 13 Lines

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

Show All 13 Lines
// class unordered_map // class unordered_map
// void rehash(size_type n); // void rehash(size_type n);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class C> template <class C>
void rehash_postcondition(const C& c, size_t n) void rehash_postcondition(const C& c, size_t n)
{ {
assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n); assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
} }
Show All 21 Linesint main()
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 5); LIBCPP_ASSERT(c.bucket_count() == 5);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 3); LIBCPP_ASSERT(c.bucket_count() == 3);
test(c); test(c);
c.rehash(31); c.rehash(31);
rehash_postcondition(c, 31); rehash_postcondition(c, 31);
assert(c.bucket_count() == 31); LIBCPP_ASSERT(c.bucket_count() == 31);
test(c); test(c);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>, typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C; min_allocator<std::pair<const int, std::string>>> 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(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 5); LIBCPP_ASSERT(c.bucket_count() == 5);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 3); LIBCPP_ASSERT(c.bucket_count() == 3);
test(c); test(c);
c.rehash(31); c.rehash(31);
rehash_postcondition(c, 31); rehash_postcondition(c, 31);
assert(c.bucket_count() == 31); LIBCPP_ASSERT(c.bucket_count() == 31);
test(c); test(c);
} }
#endif #endif
} }

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

Show All 13 Lines
// class unordered_map // class unordered_map
// void reserve(size_type n); // void reserve(size_type n);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class C> template <class C>
void test(const C& c) void test(const C& c)
{ {
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");
Show All 29 Linesint main()
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() == 5); LIBCPP_ASSERT(c.bucket_count() == 5);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() >= 2); assert(c.bucket_count() >= 2);
test(c); test(c);
c.reserve(31); c.reserve(31);
assert(c.bucket_count() >= 16); assert(c.bucket_count() >= 16);
test(c); test(c);
Show All 11 Lines#if TEST_STD_VER >= 11
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() == 5); LIBCPP_ASSERT(c.bucket_count() == 5);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() >= 2); assert(c.bucket_count() >= 2);
test(c); test(c);
c.reserve(31); c.reserve(31);
assert(c.bucket_count() >= 16); assert(c.bucket_count() >= 16);
test(c); test(c);
} }
#endif #endif
reserve_invariant(20); reserve_invariant(20);
} }

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

Show All 31 Linesint main()
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(c1.at(80) == "eighty"); assert(c1.at(80) == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Linesint main()
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(c1.at(80) == "eighty"); assert(c1.at(80) == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Lines#if TEST_STD_VER >= 11
assert(c1.at(80) == "eighty"); assert(c1.at(80) == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Lines#if TEST_STD_VER >= 11
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); C c1(std::begin(a1), std::end(a1), 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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

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

Show All 12 Lines
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_map // class unordered_map
// explicit unordered_map(const allocator_type& __a); // explicit unordered_map(const allocator_type& __a);
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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));
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_compare<std::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_compare<std::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> >{});
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_compare<std::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);
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_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_compare<std::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);
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_compare<std::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);
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()));
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);
} }
#endif #endif
#endif #endif
} }

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

Show All 14 Lines
// unordered_map& operator=(const unordered_map& u); // unordered_map& operator=(const unordered_map& u);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
Show All 21 Linesint main()
); );
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_compare<std::equal_to<int> >(3),
A(4) A(4)
); );
c = c0; c = c0;
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(4)); assert(c.get_allocator() == A(4));
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
); );
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_compare<std::equal_to<int> >(3),
A() A()
); );
c = c0; c = c0;
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(!c.empty()); assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(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
} }

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

Show All 14 Lines
// unordered_map& operator=(unordered_map&& u); // unordered_map& operator=(unordered_map&& u);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Show All 22 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
); );
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_compare<std::equal_to<int> >(3),
A(4) A(4)
); );
c = std::move(c0); c = std::move(c0);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(4)); assert(c.get_allocator() == A(4));
Show All 28 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
); );
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_compare<std::equal_to<int> >(3),
A(10) A(10)
); );
c = std::move(c0); c = std::move(c0);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
Show All 29 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
); );
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_compare<std::equal_to<int> >(3),
A(4) A(4)
); );
c = std::move(c0); c = std::move(c0);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
Show All 30 Lines#if TEST_STD_VER >= 11
); );
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_compare<std::equal_to<int> >(3),
A() A()
); );
c = std::move(c0); c = std::move(c0);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
Show All 22 Lines

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

Show All 15 Lines
// unordered_map(const unordered_map& u); // unordered_map(const unordered_map& u);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
Show All 14 Linesint main()
}; };
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_compare<std::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;
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 23 Lines#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
}; };
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_compare<std::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;
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 24 Lines#if TEST_STD_VER >= 11
}; };
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_compare<std::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;
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 9 Lines

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

Show All 15 Lines
// unordered_map(const unordered_map& u, const allocator_type& a); // unordered_map(const unordered_map& u, const allocator_type& a);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
Show All 14 Linesint main()
}; };
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_compare<std::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));
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 23 Lines#if TEST_STD_VER >= 11
}; };
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_compare<std::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> >());
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 9 Lines

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

Show All 12 Lines
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_map // class unordered_map
// unordered_map(); // unordered_map();
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::equal_to<NotConstructible> >,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c; C c;
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_compare<std::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_compare<std::equal_to<NotConstructible> >,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c; C c;
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_compare<std::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);
} }
{ {
std::unordered_map<int, int> c = {}; std::unordered_map<int, int> c = {};
assert(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
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
} }

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

Show All 15 Lines
// unordered_map(initializer_list<value_type> il, size_type n); // unordered_map(initializer_list<value_type> il, size_type n);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 9 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
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
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 17 Lines#if TEST_STD_VER >= 11
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
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 10 Lines

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

Show All 15 Lines
// unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf); // unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 10 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
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)
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 18 Lines#if TEST_STD_VER >= 11
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)
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 10 Lines

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

Show All 16 Lines
// const hasher& hf, const key_equal& eql); // const hasher& hf, const key_equal& eql);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 11 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
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_compare<std::equal_to<int> >(9)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 19 Lines#if TEST_STD_VER >= 11
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_compare<std::equal_to<int> >(9)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 10 Lines

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

Show All 16 Lines
// const hasher& hf, const key_equal& eql, const allocator_type& a); // const hasher& hf, const key_equal& eql, const allocator_type& a);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 12 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
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_compare<std::equal_to<int> >(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 20 Lines#if TEST_STD_VER >= 11
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_compare<std::equal_to<int> >(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 10 Lines

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

Show All 17 Lines
// UNSUPPORTED: c++98, c++03 // UNSUPPORTED: c++98, c++03
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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_compare<std::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);
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_compare<std::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(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
Show All 20 Linesint main()
}; };
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_compare<std::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);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 13 Linesint main()
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_compare<std::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);
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_compare<std::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(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
Show All 20 Linesint main()
}; };
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_compare<std::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);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 21 Lines

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

Show All 15 Lines
// unordered_map(unordered_map&& u, const allocator_type& a); // unordered_map(unordered_map&& u, const allocator_type& a);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
}; };
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_compare<std::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() == 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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
Show All 25 Lines#if TEST_STD_VER >= 11
}; };
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_compare<std::equal_to<int> >(9),
A() A()
); );
C c(std::move(c0), A()); C c(std::move(c0), A());
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
Show All 11 Lines

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

Show All 16 Lines
// unordered_map(InputIterator first, InputIterator last, size_type n); // unordered_map(InputIterator first, InputIterator last, size_type n);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
Show All 12 Linesint main()
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(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
10 10
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 19 Lines#if TEST_STD_VER >= 11
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(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
10 10
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 9 Lines

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

Show All 17 Lines
// const hasher& hf); // const hasher& hf);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
Show All 13 Linesint main()
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 20 Lines#if TEST_STD_VER >= 11
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 9 Lines

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

Show All 17 Lines
// const hasher& hf, const key_equal& eql); // const hasher& hf, const key_equal& eql);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
Show All 14 Linesint main()
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 21 Lines#if TEST_STD_VER >= 11
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 9 Lines

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

Show All 18 Lines
// const allocator_type& a); // const allocator_type& a);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
Show All 15 Linesint main()
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 22 Lines#if TEST_STD_VER >= 11
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == assert(c.get_allocator() ==
Show All 9 Lines

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

Show All 12 Lines
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_map // class unordered_map
// unordered_map(size_type n); // unordered_map(size_type n);
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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;
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_compare<std::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_compare<std::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;
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_map // class unordered_map
// unordered_map(size_type n); // unordered_map(size_type n);
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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);
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_compare<std::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_compare<std::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);
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_map // class unordered_map
// unordered_map(size_type n, const hasher& hf); // unordered_map(size_type n, const hasher& hf);
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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)
); );
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_compare<std::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_compare<std::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)
); );
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_map // class unordered_map
// unordered_map(size_type n, const hasher& hf, const key_equal& eql); // unordered_map(size_type n, const hasher& hf, const key_equal& eql);
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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_compare<std::equal_to<NotConstructible> >(9)
); );
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_compare<std::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_compare<std::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_compare<std::equal_to<NotConstructible> >(9)
); );
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_map // class unordered_map
// unordered_map(size_type n, const hasher& hf, const key_equal& eql, const allocator_type& a); // unordered_map(size_type n, const hasher& hf, const key_equal& eql, const allocator_type& a);
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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_compare<std::equal_to<NotConstructible> >(9),
test_allocator<std::pair<const NotConstructible, NotConstructible> >(10) test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)
); );
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_compare<std::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_compare<std::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_compare<std::equal_to<NotConstructible> >(9),
min_allocator<std::pair<const NotConstructible, NotConstructible> >() min_allocator<std::pair<const NotConstructible, NotConstructible> >()
); );
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_compare<std::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
} }

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

Show All 31 Linesint main()
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(c1.at(80) == "eighty"); assert(c1.at(80) == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Linesint main()
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(c1.at(80) == "eighty"); assert(c1.at(80) == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Lines#if TEST_STD_VER >= 11
assert(c1.at(80) == "eighty"); assert(c1.at(80) == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Lines#if TEST_STD_VER >= 11
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); C c1(std::begin(a1), std::end(a1), 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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

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

Show All 13 Lines
// class unordered_multimap // class unordered_multimap
// size_type bucket_count() const; // size_type bucket_count() const;
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
{ {
typedef std::unordered_multimap<int, std::string> C; typedef std::unordered_multimap<int, std::string> C;
typedef C::const_iterator I; typedef C::const_iterator I;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
const C c; const C c;
assert(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
} }
{ {
typedef std::unordered_multimap<int, std::string> C; typedef std::unordered_multimap<int, std::string> C;
typedef C::const_iterator I; typedef C::const_iterator I;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a[] = P a[] =
{ {
P(10, "ten"), P(10, "ten"),
Show All 12 Lines

test/std/containers/unord/unord.multimap/iterators.fail.cpp

Show All 18 Lines
// const_iterator end() const {return __table_.end();} // const_iterator end() const {return __table_.end();}
// const_iterator cbegin() const {return __table_.begin();} // const_iterator cbegin() const {return __table_.begin();}
// const_iterator cend() const {return __table_.end();} // const_iterator cend() const {return __table_.end();}
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
{ {
typedef std::unordered_multimap<int, std::string> C; typedef std::unordered_multimap<int, std::string> 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(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
C::iterator i = c.begin(); C::iterator i = c.begin();
i->second = "ONE"; i->second = "ONE";
assert(i->second == "ONE"); assert(i->second == "ONE");
i->first = 2; i->first = 2;
} }
{ {
typedef std::unordered_multimap<int, std::string> C; typedef std::unordered_multimap<int, std::string> 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"),
}; };
const C c(a, a + sizeof(a)/sizeof(a[0])); const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
} }
} }

test/std/containers/unord/unord.multimap/local_iterators.fail.cpp

Show All 18 Lines
// const_local_iterator end (size_type n) const; // const_local_iterator end (size_type n) const;
// const_local_iterator cbegin(size_type n) const; // const_local_iterator cbegin(size_type n) const;
// const_local_iterator cend (size_type n) const; // const_local_iterator cend (size_type n) const;
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
{ {
typedef std::unordered_multimap<int, std::string> C; typedef std::unordered_multimap<int, std::string> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
typedef C::local_iterator I; typedef C::local_iterator I;
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(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
C::size_type b = c.bucket(0); C::size_type b = c.bucket(0);
I i = c.begin(b); I i = c.begin(b);
I j = c.end(b); I j = c.end(b);
assert(std::distance(i, j) == 0); assert(std::distance(i, j) == 0);
b = c.bucket(1); b = c.bucket(1);
i = c.begin(b); i = c.begin(b);
j = c.end(b); j = c.end(b);
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Linesint main()
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"),
}; };
const C c(a, a + sizeof(a)/sizeof(a[0])); const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
C::size_type b = c.bucket(0); C::size_type b = c.bucket(0);
I i = c.begin(b); I i = c.begin(b);
I j = c.end(b); I j = c.end(b);
assert(std::distance(i, j) == 0); assert(std::distance(i, j) == 0);
b = c.bucket(1); b = c.bucket(1);
i = c.begin(b); i = c.begin(b);
j = c.end(b); j = c.end(b);
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Linesint main()
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(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
C::size_type b = c.bucket(0); C::size_type b = c.bucket(0);
I i = c.cbegin(b); I i = c.cbegin(b);
I j = c.cend(b); I j = c.cend(b);
assert(std::distance(i, j) == 0); assert(std::distance(i, j) == 0);
b = c.bucket(1); b = c.bucket(1);
i = c.cbegin(b); i = c.cbegin(b);
j = c.cend(b); j = c.cend(b);
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Linesint main()
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"),
}; };
const C c(a, a + sizeof(a)/sizeof(a[0])); const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
C::size_type b = c.bucket(0); C::size_type b = c.bucket(0);
I i = c.cbegin(b); I i = c.cbegin(b);
I j = c.cend(b); I j = c.cend(b);
assert(std::distance(i, j) == 0); assert(std::distance(i, j) == 0);
b = c.bucket(1); b = c.bucket(1);
i = c.cbegin(b); i = c.cbegin(b);
j = c.cend(b); j = c.cend(b);
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

Show All 15 Lines
// void rehash(size_type n); // void rehash(size_type n);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class C> template <class C>
void rehash_postcondition(const C& c, size_t n) void rehash_postcondition(const C& c, size_t n)
{ {
assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n); assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
} }
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Linesint main()
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 3); LIBCPP_ASSERT(c.bucket_count() == 3);
test(c); test(c);
c.rehash(31); c.rehash(31);
rehash_postcondition(c, 31); rehash_postcondition(c, 31);
assert(c.bucket_count() == 31); LIBCPP_ASSERT(c.bucket_count() == 31);
test(c); test(c);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>, typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C; min_allocator<std::pair<const int, std::string>>> 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(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 3); LIBCPP_ASSERT(c.bucket_count() == 3);
test(c); test(c);
c.rehash(31); c.rehash(31);
rehash_postcondition(c, 31); rehash_postcondition(c, 31);
assert(c.bucket_count() == 31); LIBCPP_ASSERT(c.bucket_count() == 31);
test(c); test(c);
} }
#endif #endif
} }

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

Show All 13 Lines
// class unordered_multimap // class unordered_multimap
// void rehash(size_type n); // void rehash(size_type n);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class C> template <class C>
void test(const C& c) void test(const C& c)
{ {
assert(c.size() == 6); assert(c.size() == 6);
assert(c.find(1)->second == "one"); assert(c.find(1)->second == "one");
assert(next(c.find(1))->second == "four"); assert(next(c.find(1))->second == "four");
Show All 31 Linesint main()
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() == 3); LIBCPP_ASSERT(c.bucket_count() == 3);
test(c); test(c);
c.reserve(31); c.reserve(31);
assert(c.bucket_count() >= 16); assert(c.bucket_count() >= 16);
test(c); test(c);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>, typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
min_allocator<std::pair<const int, std::string>>> C; min_allocator<std::pair<const int, std::string>>> 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(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() == 3); LIBCPP_ASSERT(c.bucket_count() == 3);
test(c); test(c);
c.reserve(31); c.reserve(31);
assert(c.bucket_count() >= 16); assert(c.bucket_count() >= 16);
test(c); test(c);
} }
#endif #endif
reserve_invariant(20); reserve_invariant(20);
} }

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

Show All 13 Lines
// class unordered_multimap // class unordered_multimap
// void swap(unordered_multimap& __u); // void swap(unordered_multimap& __u);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../test_compare.h" #include "../../test_compare.h"
#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 main()
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(c1.find(80)->second == "eighty"); assert(c1.find(80)->second == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Linesint main()
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;
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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(c1.find(80)->second == "eighty"); assert(c1.find(80)->second == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
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;
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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Lines#if TEST_STD_VER >= 11
assert(c1.find(80)->second == "eighty"); assert(c1.find(80)->second == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Lines#if TEST_STD_VER >= 11
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); C c1(std::begin(a1), std::end(a1), 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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

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

Show All 12 Lines
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_multimap // class unordered_multimap
// explicit unordered_multimap(const allocator_type& __a); // explicit unordered_multimap(const allocator_type& __a);
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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));
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_compare<std::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_compare<std::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> >{});
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_compare<std::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);
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_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_compare<std::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);
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_compare<std::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);
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()));
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);
} }
#endif #endif
#endif #endif
} }

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

Show All 14 Lines
// unordered_multimap& operator=(const unordered_multimap& u); // unordered_multimap& operator=(const unordered_multimap& u);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
Show All 21 Linesint main()
); );
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_compare<std::equal_to<int> >(3),
A(4) A(4)
); );
c = c0; c = c0;
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "four"); assert(i->second == "four");
++i; ++i;
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
); );
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_compare<std::equal_to<int> >(3),
A() A()
); );
c = c0; c = c0;
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "four"); assert(i->second == "four");
++i; ++i;
Show All 22 Lines

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

Show All 14 Lines
// unordered_multimap& operator=(unordered_multimap&& u); // unordered_multimap& operator=(unordered_multimap&& u);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Show All 22 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
); );
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_compare<std::equal_to<int> >(3),
A(4) A(4)
); );
c = std::move(c0); c = std::move(c0);
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
); );
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_compare<std::equal_to<int> >(3),
A(10) A(10)
); );
c = std::move(c0); c = std::move(c0);
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
); );
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_compare<std::equal_to<int> >(3),
A(4) A(4)
); );
c = std::move(c0); c = std::move(c0);
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
); );
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_compare<std::equal_to<int> >(3),
A() A()
); );
c = std::move(c0); c = std::move(c0);
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

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

Show All 15 Lines
// unordered_multimap(const unordered_multimap& u); // unordered_multimap(const unordered_multimap& u);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
Show All 14 Linesint main()
}; };
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_compare<std::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;
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "four"); assert(i->second == "four");
++i; ++i;
Show All 37 Lines#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
}; };
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_compare<std::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;
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "four"); assert(i->second == "four");
++i; ++i;
Show All 38 Lines#if TEST_STD_VER >= 11
}; };
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_compare<std::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;
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "four"); assert(i->second == "four");
++i; ++i;
Show All 23 Lines

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

Show All 15 Lines
// unordered_multimap(const unordered_multimap& u, const allocator_type& a); // unordered_multimap(const unordered_multimap& u, const allocator_type& a);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
Show All 14 Linesint main()
}; };
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_compare<std::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));
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "four"); assert(i->second == "four");
++i; ++i;
Show All 37 Lines#if TEST_STD_VER >= 11
}; };
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_compare<std::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> >());
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "four"); assert(i->second == "four");
++i; ++i;
Show All 23 Lines

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

Show All 12 Lines
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_multimap // class unordered_multimap
// unordered_multimap(); // unordered_multimap();
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::equal_to<NotConstructible> >,
test_allocator<std::pair<const NotConstructible, test_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c; C c;
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_compare<std::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_compare<std::equal_to<NotConstructible> >,
min_allocator<std::pair<const NotConstructible, min_allocator<std::pair<const NotConstructible,
NotConstructible> > NotConstructible> >
> C; > C;
C c; C c;
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_compare<std::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);
} }
{ {
std::unordered_multimap<int, int> c = {}; std::unordered_multimap<int, int> c = {};
assert(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
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
} }

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

Show All 15 Lines
// unordered_multimap(initializer_list<value_type> il, size_type n); // unordered_multimap(initializer_list<value_type> il, size_type n);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 9 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
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
); );
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
Show All 39 Lines#if TEST_STD_VER >= 11
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
); );
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
Show All 32 Lines

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

Show All 15 Lines
// unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf); // unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 10 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
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)
); );
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
Show All 40 Lines#if TEST_STD_VER >= 11
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)
); );
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
Show All 32 Lines

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

Show All 16 Lines
// const hasher& hf, const key_equal& eql); // const hasher& hf, const key_equal& eql);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 11 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
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_compare<std::equal_to<int> >(9)
); );
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
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_compare<std::equal_to<int> >(9)
); );
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
Show All 32 Lines

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

Show All 16 Lines
// const hasher& hf, const key_equal& eql, const allocator_type& a); // const hasher& hf, const key_equal& eql, const allocator_type& a);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 12 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
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_compare<std::equal_to<int> >(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
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_compare<std::equal_to<int> >(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
Show All 32 Lines

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

Show All 15 Lines
// unordered_multimap(unordered_multimap&& u); // unordered_multimap(unordered_multimap&& u);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Show All 14 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
P(2, "four"), P(2, "four"),
}; };
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_compare<std::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);
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_compare<std::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(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
Show All 20 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
}; };
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_compare<std::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);
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
P(2, "four"), P(2, "four"),
}; };
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_compare<std::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);
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_compare<std::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(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
Show All 20 Lines#if TEST_STD_VER >= 11
}; };
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_compare<std::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);
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

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

Show All 17 Lines
#include <iostream> #include <iostream>
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
}; };
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_compare<std::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() == 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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
}; };
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_compare<std::equal_to<int> >(9),
A() A()
); );
C c(std::move(c0), A()); C c(std::move(c0), A());
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
Show All 34 Lines

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

Show All 16 Lines
// unordered_multimap(InputIterator first, InputIterator last, size_type n); // unordered_multimap(InputIterator first, InputIterator last, size_type n);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
Show All 12 Linesint main()
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(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
10 10
); );
assert(c.bucket_count() == 11); LIBCPP_ASSERT(c.bucket_count() == 11);
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
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(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
10 10
); );
assert(c.bucket_count() == 11); LIBCPP_ASSERT(c.bucket_count() == 11);
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
Show All 31 Lines

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

Show All 17 Lines
// const hasher& hf); // const hasher& hf);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
Show All 13 Linesint main()
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
P(4, "four"), P(4, "four"),
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
Show All 31 Lines

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

Show All 17 Lines
// const hasher& hf, const key_equal& eql); // const hasher& hf, const key_equal& eql);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
Show All 14 Linesint main()
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9)
); );
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9)
); );
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
Show All 31 Lines

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

Show All 18 Lines
// const allocator_type& a); // const allocator_type& a);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
Show All 15 Linesint main()
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9),
test_allocator<std::pair<const int, std::string> >(10) test_allocator<std::pair<const int, std::string> >(10)
); );
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
P(2, "four"), P(2, "four"),
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9),
min_allocator<std::pair<const int, std::string> >() min_allocator<std::pair<const int, std::string> >()
); );
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);
C::const_iterator i = eq.first; C::const_iterator i = eq.first;
assert(i->first == 1); assert(i->first == 1);
assert(i->second == "one"); assert(i->second == "one");
++i; ++i;
Show All 31 Lines

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

Show All 12 Lines
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_multimap // class unordered_multimap
// unordered_multimap(size_type n); // unordered_multimap(size_type n);
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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;
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_compare<std::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_compare<std::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;
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_multimap // class unordered_multimap
// unordered_multimap(size_type n); // unordered_multimap(size_type n);
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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);
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_compare<std::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_compare<std::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);
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_multimap // class unordered_multimap
// unordered_multimap(size_type n, const hasher& hf); // unordered_multimap(size_type n, const hasher& hf);
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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)
); );
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_compare<std::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_compare<std::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)
); );
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_multimap // class unordered_multimap
// unordered_multimap(size_type n, const hasher& hf, const key_equal& eql); // unordered_multimap(size_type n, const hasher& hf, const key_equal& eql);
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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_compare<std::equal_to<NotConstructible> >(9)
); );
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_compare<std::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_compare<std::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_compare<std::equal_to<NotConstructible> >(9)
); );
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<pair<const Key, T>>> // class Alloc = allocator<pair<const Key, T>>>
// class unordered_multimap // class unordered_multimap
// unordered_multimap(size_type n, const hasher& hf, const key_equal& eql, const allocator_type& a); // unordered_multimap(size_type n, const hasher& hf, const key_equal& eql, const allocator_type& a);
#include <unordered_map> #include <unordered_map>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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_compare<std::equal_to<NotConstructible> >(9),
test_allocator<std::pair<const NotConstructible, NotConstructible> >(10) test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)
); );
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_compare<std::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_compare<std::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_compare<std::equal_to<NotConstructible> >(9),
min_allocator<std::pair<const NotConstructible, NotConstructible> >() min_allocator<std::pair<const NotConstructible, NotConstructible> >()
); );
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_compare<std::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
} }

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

Show All 13 Lines
// class unordered_multimap // class unordered_multimap
// void swap(unordered_multimap& __u); // void swap(unordered_multimap& __u);
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(c1.find(80)->second == "eighty"); assert(c1.find(80)->second == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Linesint main()
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;
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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(c1.find(80)->second == "eighty"); assert(c1.find(80)->second == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
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;
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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Lines#if TEST_STD_VER >= 11
assert(c1.find(80)->second == "eighty"); assert(c1.find(80)->second == "eighty");
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Lines#if TEST_STD_VER >= 11
P(1, "four"), P(1, "four"),
P(2, "four"), P(2, "four"),
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); C c1(std::begin(a1), std::end(a1), 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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// size_type bucket_count() const; // size_type bucket_count() const;
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::unordered_multiset<int> C; typedef std::unordered_multiset<int> C;
typedef C::const_iterator I; typedef C::const_iterator I;
typedef int P; typedef int P;
const C c; const C c;
assert(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
} }
{ {
typedef std::unordered_multiset<int> C; typedef std::unordered_multiset<int> C;
typedef C::const_iterator I; typedef C::const_iterator I;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
P(10), P(10),
Show All 10 Linesint main()
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<int, std::hash<int>, typedef std::unordered_multiset<int, std::hash<int>,
std::equal_to<int>, min_allocator<int>> C; std::equal_to<int>, min_allocator<int>> C;
typedef C::const_iterator I; typedef C::const_iterator I;
typedef int P; typedef int P;
const C c; const C c;
assert(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
} }
{ {
typedef std::unordered_multiset<int, std::hash<int>, typedef std::unordered_multiset<int, std::hash<int>,
std::equal_to<int>, min_allocator<int>> C; std::equal_to<int>, min_allocator<int>> C;
typedef C::const_iterator I; typedef C::const_iterator I;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
Show All 14 Lines

test/std/containers/unord/unord.multiset/iterators.fail.cpp

Show All 17 Lines
// const_iterator begin() const {return __table_.begin();} // const_iterator begin() const {return __table_.begin();}
// const_iterator end() const {return __table_.end();} // const_iterator end() const {return __table_.end();}
// const_iterator cbegin() const {return __table_.begin();} // const_iterator cbegin() const {return __table_.begin();}
// const_iterator cend() const {return __table_.end();} // const_iterator cend() const {return __table_.end();}
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
{ {
typedef std::unordered_multiset<int> C; typedef std::unordered_multiset<int> 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(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
C::iterator i = c.begin(); C::iterator i = c.begin();
assert(*i == 1); assert(*i == 1);
*i = 2; *i = 2;
} }
{ {
typedef std::unordered_multiset<int> C; typedef std::unordered_multiset<int> 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)
}; };
const C c(a, a + sizeof(a)/sizeof(a[0])); const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
} }
} }

test/std/containers/unord/unord.multiset/local_iterators.fail.cpp

Show All 17 Lines
// const_local_iterator begin (size_type n) const; // const_local_iterator begin (size_type n) const;
// const_local_iterator end (size_type n) const; // const_local_iterator end (size_type n) const;
// const_local_iterator cbegin(size_type n) const; // const_local_iterator cbegin(size_type n) const;
// const_local_iterator cend (size_type n) const; // const_local_iterator cend (size_type n) const;
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
int main() int main()
{ {
{ {
typedef std::unordered_multiset<int> C; typedef std::unordered_multiset<int> C;
typedef int P; typedef int P;
typedef C::local_iterator I; typedef C::local_iterator I;
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(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
C::size_type b = c.bucket(0); C::size_type b = c.bucket(0);
I i = c.begin(b); I i = c.begin(b);
I j = c.end(b); I j = c.end(b);
assert(std::distance(i, j) == 0); assert(std::distance(i, j) == 0);
b = c.bucket(1); b = c.bucket(1);
i = c.begin(b); i = c.begin(b);
j = c.end(b); j = c.end(b);
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Linesint main()
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
const C c(a, a + sizeof(a)/sizeof(a[0])); const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
C::size_type b = c.bucket(0); C::size_type b = c.bucket(0);
I i = c.begin(b); I i = c.begin(b);
I j = c.end(b); I j = c.end(b);
assert(std::distance(i, j) == 0); assert(std::distance(i, j) == 0);
b = c.bucket(1); b = c.bucket(1);
i = c.begin(b); i = c.begin(b);
j = c.end(b); j = c.end(b);
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linesint main()
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(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
C::size_type b = c.bucket(0); C::size_type b = c.bucket(0);
I i = c.cbegin(b); I i = c.cbegin(b);
I j = c.cend(b); I j = c.cend(b);
assert(std::distance(i, j) == 0); assert(std::distance(i, j) == 0);
b = c.bucket(1); b = c.bucket(1);
i = c.cbegin(b); i = c.cbegin(b);
j = c.cend(b); j = c.cend(b);
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linesint main()
P(1), P(1),
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
const C c(a, a + sizeof(a)/sizeof(a[0])); const C c(a, a + sizeof(a)/sizeof(a[0]));
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
C::size_type b = c.bucket(0); C::size_type b = c.bucket(0);
I i = c.cbegin(b); I i = c.cbegin(b);
I j = c.cend(b); I j = c.cend(b);
assert(std::distance(i, j) == 0); assert(std::distance(i, j) == 0);
b = c.bucket(1); b = c.bucket(1);
i = c.cbegin(b); i = c.cbegin(b);
j = c.cend(b); j = c.cend(b);
Show All 36 Lines

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// void rehash(size_type n); // void rehash(size_type n);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class C> template <class C>
void rehash_postcondition(const C& c, size_t n) void rehash_postcondition(const C& c, size_t n)
{ {
assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n); assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
} }
Show All 21 Linesint main()
P(1), P(1),
P(2) P(2)
}; };
C c(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 3); LIBCPP_ASSERT(c.bucket_count() == 3);
test(c); test(c);
c.rehash(31); c.rehash(31);
rehash_postcondition(c, 31); rehash_postcondition(c, 31);
assert(c.bucket_count() == 31); LIBCPP_ASSERT(c.bucket_count() == 31);
test(c); test(c);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<int, std::hash<int>, typedef std::unordered_multiset<int, std::hash<int>,
std::equal_to<int>, min_allocator<int>> C; std::equal_to<int>, min_allocator<int>> 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(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 3); LIBCPP_ASSERT(c.bucket_count() == 3);
test(c); test(c);
c.rehash(31); c.rehash(31);
rehash_postcondition(c, 31); rehash_postcondition(c, 31);
assert(c.bucket_count() == 31); LIBCPP_ASSERT(c.bucket_count() == 31);
test(c); test(c);
} }
#endif #endif
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// void reserve(size_type n); // void reserve(size_type n);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class C> template <class C>
void test(const C& c) void test(const C& c)
{ {
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);
Show All 29 Linesint main()
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() == 3); LIBCPP_ASSERT(c.bucket_count() == 3);
test(c); test(c);
c.reserve(31); c.reserve(31);
assert(c.bucket_count() >= 16); assert(c.bucket_count() >= 16);
test(c); test(c);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_multiset<int, std::hash<int>, typedef std::unordered_multiset<int, std::hash<int>,
std::equal_to<int>, min_allocator<int>> C; std::equal_to<int>, min_allocator<int>> 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(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 7); assert(c.bucket_count() >= 7);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() == 3); LIBCPP_ASSERT(c.bucket_count() == 3);
test(c); test(c);
c.reserve(31); c.reserve(31);
assert(c.bucket_count() >= 16); assert(c.bucket_count() >= 16);
test(c); test(c);
} }
#endif #endif
reserve_invariant(20); reserve_invariant(20);
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// void swap(unordered_multiset& __u); // void swap(unordered_multiset& __u);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../test_compare.h" #include "../../test_compare.h"
#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 main()
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Linesint main()
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;
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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
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;
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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Lines#if TEST_STD_VER >= 11
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Lines#if TEST_STD_VER >= 11
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); C c1(std::begin(a1), std::end(a1), 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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// explicit unordered_multiset(const allocator_type& __a); // explicit unordered_multiset(const allocator_type& __a);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::equal_to<NotConstructible> >,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c(test_allocator<NotConstructible>(10)); C c(test_allocator<NotConstructible>(10));
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_compare<std::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_compare<std::equal_to<NotConstructible> >,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c(min_allocator<NotConstructible>{}); C c(min_allocator<NotConstructible>{});
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_compare<std::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 _LIBCPP_STD_VER > 11 #if _LIBCPP_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_compare<std::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);
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_compare<std::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);
assert(c.bucket_count() == 4); LIBCPP_ASSERT(c.bucket_count() == 4);
assert(c.hash_function() == hf); assert(c.hash_function() == hf);
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);
} }
#endif #endif
#endif #endif
} }

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

Show All 13 Lines
// class unordered_multiset // class unordered_multiset
// unordered_multiset& operator=(const unordered_multiset& u); // unordered_multiset& operator=(const unordered_multiset& u);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
Show All 21 Linesint main()
); );
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_compare<std::equal_to<int> >(3),
A(4) A(4)
); );
c = c0; c = c0;
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 2); assert(*i == 2);
++i; ++i;
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
); );
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_compare<std::equal_to<int> >(3),
A() A()
); );
c = c0; c = c0;
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 2); assert(*i == 2);
++i; ++i;
Show All 16 Lines

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

Show All 13 Lines
// class unordered_multiset // class unordered_multiset
// unordered_multiset& operator=(unordered_multiset&& u); // unordered_multiset& operator=(unordered_multiset&& u);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Show All 22 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
); );
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_compare<std::equal_to<int> >(3),
A(4) A(4)
); );
c = std::move(c0); c = std::move(c0);
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 2); assert(*i == 2);
++i; ++i;
Show All 36 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
); );
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_compare<std::equal_to<int> >(3),
A(10) A(10)
); );
c = std::move(c0); c = std::move(c0);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
Show All 28 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
); );
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_compare<std::equal_to<int> >(3),
A(4) A(4)
); );
c = std::move(c0); c = std::move(c0);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
Show All 29 Lines#if TEST_STD_VER >= 11
); );
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_compare<std::equal_to<int> >(3),
A() A()
); );
c = std::move(c0); c = std::move(c0);
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(*i == 4); assert(*i == 4);
++i; ++i;
assert(*i == 3); assert(*i == 3);
++i; ++i;
assert(*i == 2); assert(*i == 2);
++i; ++i;
Show All 36 Lines#if TEST_STD_VER >= 11
); );
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_compare<std::equal_to<int> >(3),
A() A()
); );
c = std::move(c0); c = std::move(c0);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
Show All 21 Lines

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

Show All 14 Lines
// unordered_multiset(const unordered_multiset& u); // unordered_multiset(const unordered_multiset& u);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
Show All 14 Linesint main()
}; };
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_compare<std::equal_to<int> >(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
C c = c0; C c = c0;
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 2); assert(*i == 2);
++i; ++i;
Show All 30 Lines#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
}; };
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_compare<std::equal_to<int> >(9),
other_allocator<int>(10) other_allocator<int>(10)
); );
C c = c0; C c = c0;
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 2); assert(*i == 2);
++i; ++i;
Show All 31 Lines#if TEST_STD_VER >= 11
}; };
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_compare<std::equal_to<int> >(9),
min_allocator<int>() min_allocator<int>()
); );
C c = c0; C c = c0;
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 2); assert(*i == 2);
++i; ++i;
Show All 16 Lines

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

Show All 14 Lines
// unordered_multiset(const unordered_multiset& u, const allocator_type& a); // unordered_multiset(const unordered_multiset& u, const allocator_type& a);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
Show All 14 Linesint main()
}; };
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_compare<std::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));
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 2); assert(*i == 2);
++i; ++i;
Show All 30 Lines#if TEST_STD_VER >= 11
}; };
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_compare<std::equal_to<int> >(9),
min_allocator<int>() min_allocator<int>()
); );
C c(c0, min_allocator<int>()); C c(c0, min_allocator<int>());
assert(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.size() == 6); assert(c.size() == 6);
C::const_iterator i = c.cbegin(); C::const_iterator i = c.cbegin();
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 1); assert(*i == 1);
++i; ++i;
assert(*i == 2); assert(*i == 2);
++i; ++i;
Show All 16 Lines

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// unordered_multiset(); // unordered_multiset();
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::equal_to<NotConstructible> >,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c; C c;
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_compare<std::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_compare<std::equal_to<NotConstructible> >,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c; C c;
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_compare<std::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);
} }
{ {
std::unordered_multiset<int> c = {}; std::unordered_multiset<int> c = {};
assert(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
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
} }

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

Show All 14 Lines
// unordered_multiset(initializer_list<value_type> il, size_type n); // unordered_multiset(initializer_list<value_type> il, size_type n);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 9 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7 7
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
Show All 16 Lines#if TEST_STD_VER >= 11
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7 7
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
Show All 9 Lines

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

Show All 15 Lines
// unordered_multiset(initializer_list<value_type> il, size_type n, // unordered_multiset(initializer_list<value_type> il, size_type n,
// const hasher& hf); // const hasher& hf);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 10 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
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)
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
Show All 17 Lines#if TEST_STD_VER >= 11
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)
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
Show All 9 Lines

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

Show All 15 Lines
// unordered_multiset(initializer_list<value_type> il, size_type n, // unordered_multiset(initializer_list<value_type> il, size_type n,
// const hasher& hf, const key_equal& eql); // const hasher& hf, const key_equal& eql);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 11 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
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_compare<std::equal_to<int> >(9)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
Show All 18 Lines#if TEST_STD_VER >= 11
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_compare<std::equal_to<int> >(9)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
Show All 9 Lines

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

Show All 15 Lines
// unordered_multiset(initializer_list<value_type> il, size_type n, // unordered_multiset(initializer_list<value_type> il, size_type n,
// const hasher& hf, const key_equal& eql, const allocator_type& a); // const hasher& hf, const key_equal& eql, const allocator_type& a);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 12 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
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_compare<std::equal_to<int> >(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
Show All 19 Lines#if TEST_STD_VER >= 11
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_compare<std::equal_to<int> >(9),
min_allocator<int>() min_allocator<int>()
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
Show All 9 Lines

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

Show All 14 Lines
// unordered_multiset(unordered_multiset&& u); // unordered_multiset(unordered_multiset&& u);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Show All 14 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
P(2) P(2)
}; };
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_compare<std::equal_to<int> >(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
C c = std::move(c0); C c = std::move(c0);
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_compare<std::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(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
Show All 19 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
}; };
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_compare<std::equal_to<int> >(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
C c = std::move(c0); C c = std::move(c0);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
Show All 23 Lines#if TEST_STD_VER >= 11
P(2) P(2)
}; };
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_compare<std::equal_to<int> >(9),
min_allocator<int>() min_allocator<int>()
); );
C c = std::move(c0); C c = std::move(c0);
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_compare<std::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(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
Show All 19 Lines#if TEST_STD_VER >= 11
}; };
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_compare<std::equal_to<int> >(9),
min_allocator<int>() min_allocator<int>()
); );
C c = std::move(c0); C c = std::move(c0);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
Show All 22 Lines

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

Show All 14 Lines
// unordered_multiset(unordered_multiset&& u, const allocator_type& a); // unordered_multiset(unordered_multiset&& u, const allocator_type& a);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
}; };
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_compare<std::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() == 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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
}; };
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_compare<std::equal_to<int> >(9),
A() A()
); );
C c(std::move(c0), A()); C c(std::move(c0), A());
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
Show All 11 Lines

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

Show All 15 Lines
// template <class InputIterator> // template <class InputIterator>
// unordered_multiset(InputIterator first, InputIterator last, size_type n); // unordered_multiset(InputIterator first, InputIterator last, size_type n);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
Show All 11 Linesint main()
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7 7
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
Show All 18 Lines#if TEST_STD_VER >= 11
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7 7
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(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
} }

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

Show All 16 Lines
// unordered_multiset(InputIterator first, InputIterator last, size_type n, // unordered_multiset(InputIterator first, InputIterator last, size_type n,
// const hasher& hf); // const hasher& hf);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
Show All 12 Linesint main()
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
Show All 19 Lines#if TEST_STD_VER >= 11
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(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
} }

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

Show All 16 Lines
// unordered_multiset(InputIterator first, InputIterator last, size_type n, // unordered_multiset(InputIterator first, InputIterator last, size_type n,
// const hasher& hf, const key_equal& eql); // const hasher& hf, const key_equal& eql);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
Show All 13 Linesint main()
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
Show All 20 Lines#if TEST_STD_VER >= 11
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9)
); );
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_compare<std::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(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(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
} }

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

Show All 17 Lines
// const hasher& hf, const key_equal& eql, // const hasher& hf, const key_equal& eql,
// const allocator_type& a); // const allocator_type& a);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
Show All 14 Linesint main()
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
Show All 21 Lines#if TEST_STD_VER >= 11
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9),
min_allocator<int>() min_allocator<int>()
); );
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_compare<std::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(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(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
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// explicit unordered_multiset(size_type n); // explicit unordered_multiset(size_type n);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::equal_to<NotConstructible> >,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c = 7; C c = 7;
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_compare<std::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_compare<std::equal_to<NotConstructible> >,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c = 7; C c = 7;
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// explicit unordered_multiset(size_type n); // explicit unordered_multiset(size_type n);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::equal_to<NotConstructible> >,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c(7); C c(7);
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_compare<std::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_compare<std::equal_to<NotConstructible> >,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c(7); C c(7);
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// unordered_multiset(size_type n, const hasher& hf); // unordered_multiset(size_type n, const hasher& hf);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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)
); );
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_compare<std::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_compare<std::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)
); );
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// unordered_multiset(size_type n, const hasher& hf, const key_equal& eql); // unordered_multiset(size_type n, const hasher& hf, const key_equal& eql);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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_compare<std::equal_to<NotConstructible> >(9)
); );
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_compare<std::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_compare<std::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_compare<std::equal_to<NotConstructible> >(9)
); );
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// unordered_multiset(size_type n, const hasher& hf, const key_equal& eql, const allocator_type& a); // unordered_multiset(size_type n, const hasher& hf, const key_equal& eql, const allocator_type& a);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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_compare<std::equal_to<NotConstructible> >(9),
test_allocator<std::pair<const NotConstructible, NotConstructible> >(10) test_allocator<std::pair<const NotConstructible, NotConstructible> >(10)
); );
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_compare<std::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_compare<std::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_compare<std::equal_to<NotConstructible> >(9),
min_allocator<std::pair<const NotConstructible, NotConstructible> >() min_allocator<std::pair<const NotConstructible, NotConstructible> >()
); );
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_multiset // class unordered_multiset
// void swap(unordered_multiset& x, unordered_multiset& y); // void swap(unordered_multiset& x, unordered_multiset& y);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Linesint main()
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;
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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
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;
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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Lines#if TEST_STD_VER >= 11
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Lines#if TEST_STD_VER >= 11
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); C c1(std::begin(a1), std::end(a1), 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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// size_type bucket_count() const; // size_type bucket_count() const;
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
int main() int main()
{ {
{ {
typedef std::unordered_set<int> C; typedef std::unordered_set<int> C;
typedef C::const_iterator I; typedef C::const_iterator I;
typedef int P; typedef int P;
const C c; const C c;
assert(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
} }
{ {
typedef std::unordered_set<int> C; typedef std::unordered_set<int> C;
typedef C::const_iterator I; typedef C::const_iterator I;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
P(10), P(10),
Show All 9 Linesint main()
assert(c.bucket_count() >= 11); assert(c.bucket_count() >= 11);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
typedef C::const_iterator I; typedef C::const_iterator I;
typedef int P; typedef int P;
const C c; const C c;
assert(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
} }
{ {
typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C; typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> C;
typedef C::const_iterator I; typedef C::const_iterator I;
typedef int P; typedef int P;
P a[] = P a[] =
{ {
P(10), P(10),
Show All 13 Lines

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// void rehash(size_type n); // void rehash(size_type n);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class C> template <class C>
void rehash_postcondition(const C& c, size_t n) void rehash_postcondition(const C& c, size_t n)
{ {
assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n); assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
} }
Show All 21 Linesint main()
P(1), P(1),
P(2) P(2)
}; };
C c(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 5); LIBCPP_ASSERT(c.bucket_count() == 5);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 3); LIBCPP_ASSERT(c.bucket_count() == 3);
test(c); test(c);
c.rehash(31); c.rehash(31);
rehash_postcondition(c, 31); rehash_postcondition(c, 31);
assert(c.bucket_count() == 31); LIBCPP_ASSERT(c.bucket_count() == 31);
test(c); test(c);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef std::unordered_set<int, std::hash<int>, typedef std::unordered_set<int, std::hash<int>,
std::equal_to<int>, min_allocator<int>> C; std::equal_to<int>, min_allocator<int>> 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(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 5); LIBCPP_ASSERT(c.bucket_count() == 5);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.rehash(3); c.rehash(3);
rehash_postcondition(c, 3); rehash_postcondition(c, 3);
assert(c.bucket_count() == 3); LIBCPP_ASSERT(c.bucket_count() == 3);
test(c); test(c);
c.rehash(31); c.rehash(31);
rehash_postcondition(c, 31); rehash_postcondition(c, 31);
assert(c.bucket_count() == 31); LIBCPP_ASSERT(c.bucket_count() == 31);
test(c); test(c);
} }
#endif #endif
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// void reserve(size_type n); // void reserve(size_type n);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "min_allocator.h" #include "min_allocator.h"
template <class C> template <class C>
void test(const C& c) void test(const C& c)
{ {
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);
Show All 29 Linesint main()
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() == 5); LIBCPP_ASSERT(c.bucket_count() == 5);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() >= 2); assert(c.bucket_count() >= 2);
test(c); test(c);
c.reserve(31); c.reserve(31);
assert(c.bucket_count() >= 16); assert(c.bucket_count() >= 16);
test(c); test(c);
Show All 11 Lines#if TEST_STD_VER >= 11
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(a, a + sizeof(a)/sizeof(a[0])); C c(a, a + sizeof(a)/sizeof(a[0]));
test(c); test(c);
assert(c.bucket_count() >= 5); assert(c.bucket_count() >= 5);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() == 5); LIBCPP_ASSERT(c.bucket_count() == 5);
test(c); test(c);
c.max_load_factor(2); c.max_load_factor(2);
c.reserve(3); c.reserve(3);
assert(c.bucket_count() >= 2); assert(c.bucket_count() >= 2);
test(c); test(c);
c.reserve(31); c.reserve(31);
assert(c.bucket_count() >= 16); assert(c.bucket_count() >= 16);
test(c); test(c);
} }
#endif #endif
reserve_invariant(20); reserve_invariant(20);
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// void swap(unordered_set& u); // void swap(unordered_set& u);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../test_compare.h" #include "../../test_compare.h"
#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 main()
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Linesint main()
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;
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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
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;
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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Lines#if TEST_STD_VER >= 11
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Lines#if TEST_STD_VER >= 11
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); C c1(std::begin(a1), std::end(a1), 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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// explicit unordered_set(const allocator_type& __a); // explicit unordered_set(const allocator_type& __a);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::equal_to<NotConstructible> >,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c(test_allocator<NotConstructible>(10)); C c(test_allocator<NotConstructible>(10));
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_compare<std::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_compare<std::equal_to<NotConstructible> >,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c(min_allocator<NotConstructible>{}); C c(min_allocator<NotConstructible>{});
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_compare<std::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 _LIBCPP_STD_VER > 11 #if _LIBCPP_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_compare<std::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);
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_compare<std::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);
assert(c.bucket_count() == 4); LIBCPP_ASSERT(c.bucket_count() == 4);
assert(c.hash_function() == hf); assert(c.hash_function() == hf);
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);
} }
#endif #endif
#endif #endif
} }

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

Show All 13 Lines
// class unordered_set // class unordered_set
// unordered_set& operator=(const unordered_set& u); // unordered_set& operator=(const unordered_set& u);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
Show All 21 Linesint main()
); );
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_compare<std::equal_to<int> >(3),
A(4) A(4)
); );
c = c0; c = c0;
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(4)); assert(c.get_allocator() == A(4));
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
); );
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_compare<std::equal_to<int> >(3),
A() A()
); );
c = c0; c = c0;
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
assert(!c.empty()); assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(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
} }

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

Show All 13 Lines
// class unordered_set // class unordered_set
// unordered_set& operator=(unordered_set&& u); // unordered_set& operator=(unordered_set&& u);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Show All 22 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
); );
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_compare<std::equal_to<int> >(3),
A(4) A(4)
); );
c = std::move(c0); c = std::move(c0);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(4)); assert(c.get_allocator() == A(4));
Show All 28 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
); );
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_compare<std::equal_to<int> >(3),
A(10) A(10)
); );
c = std::move(c0); c = std::move(c0);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
Show All 28 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
); );
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_compare<std::equal_to<int> >(3),
A(4) A(4)
); );
c = std::move(c0); c = std::move(c0);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A(10)); assert(c.get_allocator() == A(10));
Show All 29 Lines#if TEST_STD_VER >= 11
); );
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_compare<std::equal_to<int> >(3),
A() A()
); );
c = std::move(c0); c = std::move(c0);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == A()); assert(c.get_allocator() == A());
Show All 21 Lines

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

Show All 14 Lines
// unordered_set(const unordered_set& u); // unordered_set(const unordered_set& u);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
Show All 14 Linesint main()
}; };
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_compare<std::equal_to<int> >(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
C c = c0; C c = c0;
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
Show All 22 Lines#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
}; };
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_compare<std::equal_to<int> >(9),
other_allocator<int>(10) other_allocator<int>(10)
); );
C c = c0; C c = c0;
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == other_allocator<int>(-2)); assert(c.get_allocator() == other_allocator<int>(-2));
Show All 23 Lines#if TEST_STD_VER >= 11
}; };
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_compare<std::equal_to<int> >(9),
min_allocator<int>() min_allocator<int>()
); );
C c = c0; C c = c0;
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_compare<std::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(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(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
} }

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

Show All 14 Lines
// unordered_set(const unordered_set& u, const allocator_type& a); // unordered_set(const unordered_set& u, const allocator_type& a);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
Show All 14 Linesint main()
}; };
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_compare<std::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));
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(5)); assert(c.get_allocator() == test_allocator<int>(5));
Show All 22 Lines#if TEST_STD_VER >= 11
}; };
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_compare<std::equal_to<int> >(9),
min_allocator<int>() min_allocator<int>()
); );
C c(c0, min_allocator<int>()); C c(c0, min_allocator<int>());
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_compare<std::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(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(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
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// unordered_set(); // unordered_set();
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::equal_to<NotConstructible> >,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c; C c;
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_compare<std::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_compare<std::equal_to<NotConstructible> >,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c; C c;
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_compare<std::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);
} }
{ {
std::unordered_set<int> c = {}; std::unordered_set<int> c = {};
assert(c.bucket_count() == 0); LIBCPP_ASSERT(c.bucket_count() == 0);
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
} }

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

Show All 14 Lines
// unordered_set(initializer_list<value_type> il, size_type n); // unordered_set(initializer_list<value_type> il, size_type n);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 9 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7 7
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
Show All 16 Lines#if TEST_STD_VER >= 11
P(2), P(2),
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}, },
7 7
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
Show All 9 Lines

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

Show All 15 Lines
// unordered_set(initializer_list<value_type> il, size_type n, // unordered_set(initializer_list<value_type> il, size_type n,
// const hasher& hf); // const hasher& hf);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 10 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
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)
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
Show All 17 Lines#if TEST_STD_VER >= 11
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)
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
Show All 9 Lines

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

Show All 15 Lines
// unordered_set(initializer_list<value_type> il, size_type n, // unordered_set(initializer_list<value_type> il, size_type n,
// const hasher& hf, const key_equal& eql); // const hasher& hf, const key_equal& eql);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 11 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
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_compare<std::equal_to<int> >(9)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
Show All 18 Lines#if TEST_STD_VER >= 11
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_compare<std::equal_to<int> >(9)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
Show All 9 Lines

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

Show All 15 Lines
// unordered_set(initializer_list<value_type> il, size_type n, // unordered_set(initializer_list<value_type> il, size_type n,
// const hasher& hf, const key_equal& eql, const allocator_type& a); // const hasher& hf, const key_equal& eql, const allocator_type& a);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
Show All 12 Lines#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
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_compare<std::equal_to<int> >(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
Show All 19 Lines#if TEST_STD_VER >= 11
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_compare<std::equal_to<int> >(9),
min_allocator<int>() min_allocator<int>()
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
Show All 9 Lines

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

Show All 14 Lines
// unordered_set(unordered_set&& u); // unordered_set(unordered_set&& u);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Show All 14 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
P(2) P(2)
}; };
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_compare<std::equal_to<int> >(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
C c = std::move(c0); C c = std::move(c0);
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_compare<std::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(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
Show All 19 Lines#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
}; };
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_compare<std::equal_to<int> >(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
C c = std::move(c0); C c = std::move(c0);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
Show All 23 Lines#if TEST_STD_VER >= 11
P(2) P(2)
}; };
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_compare<std::equal_to<int> >(9),
min_allocator<int>() min_allocator<int>()
); );
C c = std::move(c0); C c = std::move(c0);
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_compare<std::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(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
Show All 19 Lines#if TEST_STD_VER >= 11
}; };
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_compare<std::equal_to<int> >(9),
min_allocator<int>() min_allocator<int>()
); );
C c = std::move(c0); C c = std::move(c0);
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
Show All 22 Lines

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

Show All 15 Lines
// template <class InputIterator> // template <class InputIterator>
// unordered_set(InputIterator first, InputIterator last, size_type n); // unordered_set(InputIterator first, InputIterator last, size_type n);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
Show All 11 Linesint main()
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7 7
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
Show All 18 Lines#if TEST_STD_VER >= 11
P(3), P(3),
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7 7
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(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
} }

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

Show All 16 Lines
// unordered_set(InputIterator first, InputIterator last, size_type n, // unordered_set(InputIterator first, InputIterator last, size_type n,
// const hasher& hf); // const hasher& hf);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
Show All 12 Linesint main()
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
Show All 19 Lines#if TEST_STD_VER >= 11
P(4), P(4),
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])),
7, 7,
test_hash<std::hash<int> >(8) test_hash<std::hash<int> >(8)
); );
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_compare<std::equal_to<int> >());
assert(c.get_allocator() == min_allocator<int>()); assert(c.get_allocator() == min_allocator<int>());
assert(!c.empty()); assert(!c.empty());
assert(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(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
} }

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

Show All 16 Lines
// unordered_set(InputIterator first, InputIterator last, size_type n, // unordered_set(InputIterator first, InputIterator last, size_type n,
// const hasher& hf, const key_equal& eql); // const hasher& hf, const key_equal& eql);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
Show All 13 Linesint main()
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>()); assert(c.get_allocator() == test_allocator<int>());
Show All 20 Lines#if TEST_STD_VER >= 11
P(1), P(1),
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9)
); );
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_compare<std::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(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(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
} }

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

Show All 17 Lines
// const hasher& hf, const key_equal& eql, // const hasher& hf, const key_equal& eql,
// const allocator_type& a); // const allocator_type& a);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include <cfloat> #include <cfloat>
#include <cmath> #include <cmath>
#include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
Show All 14 Linesint main()
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9),
test_allocator<int>(10) test_allocator<int>(10)
); );
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_compare<std::equal_to<int> >(9));
assert(c.get_allocator() == test_allocator<int>(10)); assert(c.get_allocator() == test_allocator<int>(10));
Show All 21 Lines#if TEST_STD_VER >= 11
P(2) P(2)
}; };
C c(input_iterator<P*>(a), input_iterator<P*>(a + sizeof(a)/sizeof(a[0])), C c(input_iterator<P*>(a), 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_compare<std::equal_to<int> >(9),
min_allocator<int>() min_allocator<int>()
); );
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_compare<std::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(std::distance(c.begin(), c.end()) == c.size()); assert(std::distance(c.begin(), c.end()) == c.size());
assert(std::distance(c.cbegin(), c.cend()) == c.size()); assert(std::distance(c.cbegin(), c.cend()) == c.size());
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON); assert(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
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// explicit unordered_set(size_type n); // explicit unordered_set(size_type n);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#include "../../../test_hash.h" #include "../../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
int main() int main()
{ {
{ {
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_compare<std::equal_to<NotConstructible> >,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c = 7; C c = 7;
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_compare<std::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);
} }
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// explicit unordered_set(size_type n); // explicit unordered_set(size_type n);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::equal_to<NotConstructible> >,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c(7); C c(7);
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_compare<std::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_compare<std::equal_to<NotConstructible> >,
min_allocator<NotConstructible> min_allocator<NotConstructible>
> C; > C;
C c(7); C c(7);
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// unordered_set(size_type n, const hasher& hf); // unordered_set(size_type n, const hasher& hf);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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)
); );
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_compare<std::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_compare<std::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)
); );
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// unordered_set(size_type n, const hasher& hf, const key_equal& eql); // unordered_set(size_type n, const hasher& hf, const key_equal& eql);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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_compare<std::equal_to<NotConstructible> >(9)
); );
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_compare<std::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_compare<std::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_compare<std::equal_to<NotConstructible> >(9)
); );
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// unordered_set(size_type n, const hasher& hf, const key_equal& eql, const allocator_type& a); // unordered_set(size_type n, const hasher& hf, const key_equal& eql, const allocator_type& a);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../NotConstructible.h" #include "../../../NotConstructible.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
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_compare<std::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_compare<std::equal_to<NotConstructible> >(9),
test_allocator<NotConstructible>(10) test_allocator<NotConstructible>(10)
); );
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_compare<std::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_compare<std::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_compare<std::equal_to<NotConstructible> >(9),
min_allocator<NotConstructible>() min_allocator<NotConstructible>()
); );
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_compare<std::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
} }

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

Show All 12 Lines
// class Alloc = allocator<Value>> // class Alloc = allocator<Value>>
// class unordered_set // class unordered_set
// void swap(unordered_set& x, unordered_set& y); // void swap(unordered_set& x, unordered_set& y);
#include <unordered_set> #include <unordered_set>
#include <cassert> #include <cassert>
#include "test_macros.h"
#include "../../../test_compare.h" #include "../../../test_compare.h"
#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 main()
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<std::hash<int> > Hash;
typedef test_compare<std::equal_to<int> > Compare; typedef test_compare<std::equal_to<int> > Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(2)); assert(c2.get_allocator() == Alloc(2));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(1)); assert(c1.get_allocator() == Alloc(1));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Linesint main()
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;
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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Linesint main()
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Linesint main()
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(1)); C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc(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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc(2)); assert(c1.get_allocator() == Alloc(2));
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
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;
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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 31 Lines#if TEST_STD_VER >= 11
assert(*c1.find(80) == 80); assert(*c1.find(80) == 80);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
assert(c2.bucket_count() == 0); LIBCPP_ASSERT(c2.bucket_count() == 0);
assert(c2.size() == 0); assert(c2.size() == 0);
assert(c2.hash_function() == Hash(1)); assert(c2.hash_function() == Hash(1));
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc()); assert(c2.get_allocator() == Alloc());
assert(std::distance(c2.begin(), c2.end()) == c2.size()); assert(std::distance(c2.begin(), c2.end()) == c2.size());
assert(std::distance(c2.cbegin(), c2.cend()) == c2.size()); assert(std::distance(c2.cbegin(), c2.cend()) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
Show All 12 Lines#if TEST_STD_VER >= 11
P(1), P(1),
P(2) P(2)
}; };
C c1(std::begin(a1), std::end(a1), 0, Hash(1), Compare(1), Alloc()); C c1(std::begin(a1), std::end(a1), 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);
assert(c1.bucket_count() == 0); LIBCPP_ASSERT(c1.bucket_count() == 0);
assert(c1.size() == 0); assert(c1.size() == 0);
assert(c1.hash_function() == Hash(2)); assert(c1.hash_function() == Hash(2));
assert(c1.key_eq() == Compare(2)); assert(c1.key_eq() == Compare(2));
assert(c1.get_allocator() == Alloc()); assert(c1.get_allocator() == Alloc());
assert(std::distance(c1.begin(), c1.end()) == c1.size()); assert(std::distance(c1.begin(), c1.end()) == c1.size());
assert(std::distance(c1.cbegin(), c1.cend()) == c1.size()); assert(std::distance(c1.cbegin(), c1.cend()) == c1.size());
assert(c1.max_load_factor() == 2); assert(c1.max_load_factor() == 2);
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines