This is an archive of the discontinued LLVM Phabricator instance.

Differential D104166

[libc++] [test] No longer rely on std::hash<T>::argument_type.
ClosedPublic

Authored by • Quuxplusone on Jun 11 2021, 6:03 PM.

Details

Reviewers
ldionne
Group Reviewers
Restricted Project
Commits
rGbbd717b9a3b2: [libc++] [test] No longer rely on std::hash<T>::argument_type.
Summary

std::hash<T>::argument_type is gone in C++20. De-complicate this code so that it doesn't need to mess around with argument_type (or type traits) anymore.

Diff Detail

Event Timeline

• Quuxplusone requested review of this revision.Jun 11 2021, 6:03 PM
• Quuxplusone created this revision.
Herald added 1 blocking reviewer(s): Restricted Project. · View Herald TranscriptJun 11 2021, 6:03 PM
Herald added a subscriber: libcxx-commits. · View Herald Transcript
• Quuxplusone added inline comments.Jun 11 2021, 6:04 PM
libcxx/test/std/containers/test_hash.h
13

This is the only file with manual changes. Every other file's changes are simply
s/test_hash<std::hash<.*>>/test_hash<\1>/g.

Harbormaster completed remote builds in B108929: Diff 351612.Jun 11 2021, 7:54 PM
ldionne accepted this revision.Jun 14 2021, 5:46 AM

Did we have any uses of test_hash with a hash that's not std::hash?

This revision is now accepted and ready to land.Jun 14 2021, 5:46 AM
• Quuxplusone added a comment.Jun 14 2021, 7:15 AM

Did we have any uses of test_hash with a hash that's not std::hash?

No, we did not.

Closed by commit rGbbd717b9a3b2: [libc++] [test] No longer rely on std::hash<T>::argument_type. (authored by • arthur.j.odwyer). · Explain WhyJun 14 2021, 7:15 AM
This revision was automatically updated to reflect the committed changes.
• arthur.j.odwyer added a commit: rGbbd717b9a3b2: [libc++] [test] No longer rely on std::hash<T>::argument_type..

Revision Contents

PathSize
libcxx/
test/
std/
containers/
10 lines
unord/
unord.map/
24 lines
unord.map.cnstr/
16 lines
24 lines
4 lines
32 lines
18 lines
18 lines
14 lines
16 lines
8 lines
12 lines
12 lines
18 lines
24 lines
24 lines
12 lines
8 lines
12 lines
12 lines
18 lines
8 lines
8 lines
12 lines
12 lines
18 lines
unord.map.swap/
24 lines
unord.multimap/
24 lines
unord.multimap.cnstr/
16 lines
24 lines
4 lines
24 lines
18 lines
18 lines
14 lines
12 lines
8 lines
12 lines
12 lines
18 lines
24 lines
24 lines
12 lines
8 lines
12 lines
12 lines
18 lines
8 lines
8 lines
12 lines
12 lines
18 lines
unord.multimap.swap/
24 lines
unord.multiset/
24 lines
unord.multiset.cnstr/
12 lines
24 lines
4 lines
40 lines
18 lines
12 lines
14 lines
12 lines
8 lines
12 lines
12 lines
12 lines
24 lines
24 lines
12 lines
8 lines
12 lines
12 lines
12 lines
8 lines
8 lines
12 lines
12 lines
12 lines
unord.multiset.swap/
24 lines
unord.set/
24 lines
unord.set.cnstr/
12 lines
24 lines
4 lines
32 lines
18 lines
12 lines
14 lines
12 lines
8 lines
12 lines
12 lines
12 lines
24 lines
18 lines
12 lines
8 lines
12 lines
12 lines
12 lines
4 lines
8 lines
12 lines
12 lines
12 lines
unord.set.swap/
24 lines

Diff 351863

libcxx/test/std/containers/test_hash.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef TEST_HASH_H #ifndef TEST_HASH_H
#define TEST_HASH_H #define TEST_HASH_H
#include <cstddef> #include <cstddef>
#include <type_traits> #include <utility>
QuuxplusoneAuthorUnsubmitted
Done
ReplyInline Actions

This is the only file with manual changes. Every other file's changes are simply
s/test_hash<std::hash<.*>>/test_hash<\1>/g.

Quuxplusone: This is the only file with manual changes. Every other file's changes are simply…
template <class C> template <class T>
class test_hash class test_hash
: private C
{ {
int data_; int data_;
public: public:
explicit test_hash(int data = 0) : data_(data) {} explicit test_hash(int data = 0) : data_(data) {}
std::size_t std::size_t operator()(const T& x) const
operator()(typename std::add_lvalue_reference<const typename C::argument_type>::type x) const {return std::hash<T>()(x);}
{return C::operator()(x);}
bool operator==(const test_hash& c) const bool operator==(const test_hash& c) const
{return data_ == c.data_;} {return data_ == c.data_;}
}; };
#endif // TEST_HASH_H #endif // TEST_HASH_H

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

Show All 22 Lines
#include "../../test_hash.h" #include "../../test_hash.h"
#include "test_macros.h" #include "test_macros.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
Show All 11 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
Show All 31 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
Show All 25 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
Show All 11 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
Show All 31 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
Show All 25 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
Show All 11 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
Show All 31 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
Show All 25 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Show All 22 Lines
#include "../../../test_hash.h" #include "../../../test_hash.h"
#include "test_macros.h" #include "test_macros.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
Show All 11 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
Show All 33 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
Show All 27 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
Show All 11 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
Show All 31 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
Show All 25 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
Show All 11 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
Show All 31 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
Show All 25 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_map<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

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

Show All 24 Lines
#include "../../test_hash.h" #include "../../test_hash.h"
#include "test_allocator.h" #include "test_allocator.h"
#include "min_allocator.h" #include "min_allocator.h"
int main(int, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
Show All 11 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
Show All 31 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
Show All 39 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
Show All 11 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
Show All 31 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
Show All 39 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
Show All 11 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
Show All 31 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
Show All 39 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Show All 24 Lines
#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, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
Show All 11 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
Show All 33 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
Show All 32 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<std::pair<const int, std::string> > Alloc; typedef test_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
Show All 11 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
Show All 31 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
Show All 30 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<std::pair<const int, std::string> > Alloc; typedef other_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
Show All 11 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a2[] = P a2[] =
{ {
P(10, "ten"), P(10, "ten"),
P(20, "twenty"), P(20, "twenty"),
Show All 31 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
Show All 30 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<std::pair<const int, std::string> > Alloc; typedef min_allocator<std::pair<const int, std::string> > Alloc;
typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C; typedef std::unordered_multimap<int, std::string, Hash, Compare, Alloc> C;
typedef std::pair<int, std::string> P; typedef std::pair<int, std::string> P;
P a1[] = P a1[] =
{ {
P(1, "one"), P(1, "one"),
P(2, "two"), P(2, "two"),
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

Show All 21 Lines
#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, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
Show All 11 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
Show All 31 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
Show All 25 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
Show All 11 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
Show All 31 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
Show All 25 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
Show All 11 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
Show All 31 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
Show All 25 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Show All 21 Lines
#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, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
Show All 11 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
Show All 33 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
Show All 27 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
Show All 11 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
Show All 31 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
Show All 25 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
Show All 11 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
Show All 31 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
Show All 25 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_multiset<int, Hash, Compare, Alloc> C; typedef std::unordered_multiset<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

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

Show All 21 Lines
#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, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
Show All 11 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
Show All 31 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
Show All 25 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
Show All 11 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
Show All 31 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
Show All 25 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
c2.max_load_factor(2); c2.max_load_factor(2);
c1.swap(c2); c1.swap(c2);
Show All 11 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
Show All 31 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
Show All 25 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Show All 21 Lines
#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, char**) int main(int, char**)
{ {
{ {
typedef std::unordered_set<NotConstructible, typedef std::unordered_set<NotConstructible,
test_hash<std::hash<NotConstructible> >, test_hash<NotConstructible>,
test_equal_to<NotConstructible>, test_equal_to<NotConstructible>,
test_allocator<NotConstructible> test_allocator<NotConstructible>
> C; > C;
C c = 7; C c = 7;
LIBCPP_ASSERT(c.bucket_count() == 7); LIBCPP_ASSERT(c.bucket_count() == 7);
assert(c.hash_function() == test_hash<std::hash<NotConstructible> >()); assert(c.hash_function() == test_hash<NotConstructible>());
assert(c.key_eq() == test_equal_to<NotConstructible>()); assert(c.key_eq() == test_equal_to<NotConstructible>());
assert(c.get_allocator() == (test_allocator<NotConstructible>())); assert(c.get_allocator() == (test_allocator<NotConstructible>()));
assert(c.size() == 0); assert(c.size() == 0);
assert(c.empty()); assert(c.empty());
assert(std::distance(c.begin(), c.end()) == 0); assert(std::distance(c.begin(), c.end()) == 0);
assert(c.load_factor() == 0); assert(c.load_factor() == 0);
assert(c.max_load_factor() == 1); assert(c.max_load_factor() == 1);
} }
return 0; return 0;
} }

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

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

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

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

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

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

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

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

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

Show All 21 Lines
#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, char**) int main(int, char**)
{ {
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1, 1)); C c1(0, Hash(1), Compare(1), Alloc(1, 1));
C c2(0, Hash(2), Compare(2), Alloc(1, 2)); C c2(0, Hash(2), Compare(2), Alloc(1, 2));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
Show All 11 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
Show All 33 Linesint main(int, char**)
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().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
Show All 27 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef test_allocator<int> Alloc; typedef test_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.get_allocator().get_id() == 2); assert(c2.get_allocator().get_id() == 2);
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
assert(it1 == c2.begin()); // Iterators are not invalidated assert(it1 == c2.begin()); // Iterators are not invalidated
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc(1)); C c1(0, Hash(1), Compare(1), Alloc(1));
C c2(0, Hash(2), Compare(2), Alloc(2)); C c2(0, Hash(2), Compare(2), Alloc(2));
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
Show All 11 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
Show All 31 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
Show All 25 Linesint main(int, char**)
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef other_allocator<int> Alloc; typedef other_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesint main(int, char**)
assert(c2.key_eq() == Compare(1)); assert(c2.key_eq() == Compare(1));
assert(c2.get_allocator() == Alloc(1)); assert(c2.get_allocator() == Alloc(1));
assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
C c1(0, Hash(1), Compare(1), Alloc()); C c1(0, Hash(1), Compare(1), Alloc());
C c2(0, Hash(2), Compare(2), Alloc()); C c2(0, Hash(2), Compare(2), Alloc());
c2.max_load_factor(2); c2.max_load_factor(2);
swap(c1, c2); swap(c1, c2);
Show All 11 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a2[] = P a2[] =
{ {
P(10), P(10),
P(20), P(20),
Show All 31 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
Show All 25 Lines#if TEST_STD_VER >= 11
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(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.begin(), c2.end())) == c2.size());
assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size()); assert(static_cast<std::size_t>(std::distance(c2.cbegin(), c2.cend())) == c2.size());
assert(c2.max_load_factor() == 1); assert(c2.max_load_factor() == 1);
} }
{ {
typedef test_hash<std::hash<int> > Hash; typedef test_hash<int> Hash;
typedef test_equal_to<int> Compare; typedef test_equal_to<int> Compare;
typedef min_allocator<int> Alloc; typedef min_allocator<int> Alloc;
typedef std::unordered_set<int, Hash, Compare, Alloc> C; typedef std::unordered_set<int, Hash, Compare, Alloc> C;
typedef int P; typedef int P;
P a1[] = P a1[] =
{ {
P(1), P(1),
P(2), P(2),
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines