Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / libcxx / 1d4a1edbc7e4461b59239e1b8297e9dd395a6322 / . / test / std / containers / unord / unord.multiset / unord.multiset.cnstr / copy.pass.cpp
blob: 94241830a06c99937d505cff51466d68ca91ff03 [file] [log] [blame]
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]1//===----------------------------------------------------------------------===//
2//
Howard Hinnantf5256e12010-05-11 21:36:01 +0000[diff] [blame]3// The LLVM Compiler Infrastructure
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]4//
Howard Hinnantb64f8b02010-11-16 22:09:02 +0000[diff] [blame]5// This file is dual licensed under the MIT and the University of Illinois Open
6// Source Licenses. See LICENSE.TXT for details.
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]7//
8//===----------------------------------------------------------------------===//
9
10// <unordered_set>
11
12// template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
13// class Alloc = allocator<Value>>
14// class unordered_multiset
15
16// unordered_multiset(const unordered_multiset& u);
17
18#include <unordered_set>
19#include <cassert>
Howard Hinnantf836d532011-12-02 21:23:14 +0000[diff] [blame]20#include <cfloat>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]21
22#include "../../../test_compare.h"
23#include "../../../test_hash.h"
Marshall Clow1b921882013-12-03 00:18:10 +0000[diff] [blame]24#include "test_allocator.h"
Marshall Clow061d0cc2013-11-26 20:58:02 +0000[diff] [blame]25#include "min_allocator.h"
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]26
27int main()
28{
29 {
30 typedef std::unordered_multiset<int,
31 test_hash<std::hash<int> >,
32 test_compare<std::equal_to<int> >,
33 test_allocator<int>
34 > C;
35 typedef int P;
36 P a[] =
37 {
38 P(1),
39 P(2),
40 P(3),
41 P(4),
42 P(1),
43 P(2)
44 };
45 C c0(a, a + sizeof(a)/sizeof(a[0]),
46 7,
47 test_hash<std::hash<int> >(8),
48 test_compare<std::equal_to<int> >(9),
49 test_allocator<int>(10)
50 );
51 C c = c0;
52 assert(c.bucket_count() == 7);
53 assert(c.size() == 6);
54 C::const_iterator i = c.cbegin();
55 assert(*i == 1);
56 ++i;
57 assert(*i == 1);
58 ++i;
59 assert(*i == 2);
60 ++i;
61 assert(*i == 2);
62 ++i;
63 assert(*i == 3);
64 ++i;
65 assert(*i == 4);
66 assert(c.hash_function() == test_hash<std::hash<int> >(8));
67 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
68 assert(c.get_allocator() == test_allocator<int>(10));
69 assert(!c.empty());
70 assert(std::distance(c.begin(), c.end()) == c.size());
71 assert(std::distance(c.cbegin(), c.cend()) == c.size());
Dan Albert1d4a1ed2016-05-25 22:36:09 -0700[diff] [blame^]72 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]73 assert(c.max_load_factor() == 1);
74 }
75#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
76 {
77 typedef std::unordered_multiset<int,
78 test_hash<std::hash<int> >,
79 test_compare<std::equal_to<int> >,
80 other_allocator<int>
81 > C;
82 typedef int P;
83 P a[] =
84 {
85 P(1),
86 P(2),
87 P(3),
88 P(4),
89 P(1),
90 P(2)
91 };
92 C c0(a, a + sizeof(a)/sizeof(a[0]),
93 7,
94 test_hash<std::hash<int> >(8),
95 test_compare<std::equal_to<int> >(9),
96 other_allocator<int>(10)
97 );
98 C c = c0;
99 assert(c.bucket_count() == 7);
100 assert(c.size() == 6);
101 C::const_iterator i = c.cbegin();
102 assert(*i == 1);
103 ++i;
104 assert(*i == 1);
105 ++i;
106 assert(*i == 2);
107 ++i;
108 assert(*i == 2);
109 ++i;
110 assert(*i == 3);
111 ++i;
112 assert(*i == 4);
113 assert(c.hash_function() == test_hash<std::hash<int> >(8));
114 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
115 assert(c.get_allocator() == other_allocator<int>(-2));
116 assert(!c.empty());
117 assert(std::distance(c.begin(), c.end()) == c.size());
118 assert(std::distance(c.cbegin(), c.cend()) == c.size());
Dan Albert1d4a1ed2016-05-25 22:36:09 -0700[diff] [blame^]119 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]120 assert(c.max_load_factor() == 1);
121 }
Howard Hinnant6046ace2010-08-22 00:15:28 +0000[diff] [blame]122#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE
Howard Hinnant7a6b7ce2013-06-22 15:21:29 +0000[diff] [blame]123#if __cplusplus >= 201103L
124 {
125 typedef std::unordered_multiset<int,
126 test_hash<std::hash<int> >,
127 test_compare<std::equal_to<int> >,
128 min_allocator<int>
129 > C;
130 typedef int P;
131 P a[] =
132 {
133 P(1),
134 P(2),
135 P(3),
136 P(4),
137 P(1),
138 P(2)
139 };
140 C c0(a, a + sizeof(a)/sizeof(a[0]),
141 7,
142 test_hash<std::hash<int> >(8),
143 test_compare<std::equal_to<int> >(9),
144 min_allocator<int>()
145 );
146 C c = c0;
147 assert(c.bucket_count() == 7);
148 assert(c.size() == 6);
149 C::const_iterator i = c.cbegin();
150 assert(*i == 1);
151 ++i;
152 assert(*i == 1);
153 ++i;
154 assert(*i == 2);
155 ++i;
156 assert(*i == 2);
157 ++i;
158 assert(*i == 3);
159 ++i;
160 assert(*i == 4);
161 assert(c.hash_function() == test_hash<std::hash<int> >(8));
162 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
163 assert(c.get_allocator() == min_allocator<int>());
164 assert(!c.empty());
165 assert(std::distance(c.begin(), c.end()) == c.size());
166 assert(std::distance(c.cbegin(), c.cend()) == c.size());
Dan Albert1d4a1ed2016-05-25 22:36:09 -0700[diff] [blame^]167 assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
Howard Hinnant7a6b7ce2013-06-22 15:21:29 +0000[diff] [blame]168 assert(c.max_load_factor() == 1);
169 }
170#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]171}