Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / libcxx / 73d21a4f0774d3fadab98e690619a359cfb160a3 / . / test / containers / unord / unord.set / unord.set.cnstr / assign_move.pass.cpp
blob: 7db4359dda4757340656b2967d6db2ef93883d40 [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//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
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_set
15
16// unordered_set& operator=(unordered_set&& u);
17
18#include <unordered_set>
19#include <cassert>
20
21#include "../../../test_compare.h"
22#include "../../../test_hash.h"
23#include "../../../test_allocator.h"
24
25int main()
26{
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]27#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]28 {
29 typedef test_allocator<int> A;
30 typedef std::unordered_set<int,
31 test_hash<std::hash<int> >,
32 test_compare<std::equal_to<int> >,
33 A
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 A(10)
50 );
51 C c(a, a + 2,
52 7,
53 test_hash<std::hash<int> >(2),
54 test_compare<std::equal_to<int> >(3),
55 A(4)
56 );
57 c = std::move(c0);
58 assert(c.bucket_count() == 7);
59 assert(c.size() == 4);
60 assert(c.count(1) == 1);
61 assert(c.count(2) == 1);
62 assert(c.count(3) == 1);
63 assert(c.count(4) == 1);
64 assert(c.hash_function() == test_hash<std::hash<int> >(8));
65 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
66 assert(c.get_allocator() == A(4));
67 assert(!c.empty());
68 assert(std::distance(c.begin(), c.end()) == c.size());
69 assert(std::distance(c.cbegin(), c.cend()) == c.size());
70 assert(c.load_factor() == (float)c.size()/c.bucket_count());
71 assert(c.max_load_factor() == 1);
72 }
73 {
74 typedef test_allocator<int> A;
75 typedef std::unordered_set<int,
76 test_hash<std::hash<int> >,
77 test_compare<std::equal_to<int> >,
78 A
79 > C;
80 typedef int P;
81 P a[] =
82 {
83 P(1),
84 P(2),
85 P(3),
86 P(4),
87 P(1),
88 P(2)
89 };
90 C c0(a, a + sizeof(a)/sizeof(a[0]),
91 7,
92 test_hash<std::hash<int> >(8),
93 test_compare<std::equal_to<int> >(9),
94 A(10)
95 );
96 C c(a, a + 2,
97 7,
98 test_hash<std::hash<int> >(2),
99 test_compare<std::equal_to<int> >(3),
100 A(10)
101 );
102 c = std::move(c0);
103 assert(c.bucket_count() == 7);
104 assert(c.size() == 4);
105 assert(c.count(1) == 1);
106 assert(c.count(2) == 1);
107 assert(c.count(3) == 1);
108 assert(c.count(4) == 1);
109 assert(c.hash_function() == test_hash<std::hash<int> >(8));
110 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
111 assert(c.get_allocator() == A(10));
112 assert(!c.empty());
113 assert(std::distance(c.begin(), c.end()) == c.size());
114 assert(std::distance(c.cbegin(), c.cend()) == c.size());
115 assert(c.load_factor() == (float)c.size()/c.bucket_count());
116 assert(c.max_load_factor() == 1);
117 }
118 {
119 typedef other_allocator<int> A;
120 typedef std::unordered_set<int,
121 test_hash<std::hash<int> >,
122 test_compare<std::equal_to<int> >,
123 A
124 > C;
125 typedef int P;
126 P a[] =
127 {
128 P(1),
129 P(2),
130 P(3),
131 P(4),
132 P(1),
133 P(2)
134 };
135 C c0(a, a + sizeof(a)/sizeof(a[0]),
136 7,
137 test_hash<std::hash<int> >(8),
138 test_compare<std::equal_to<int> >(9),
139 A(10)
140 );
141 C c(a, a + 2,
142 7,
143 test_hash<std::hash<int> >(2),
144 test_compare<std::equal_to<int> >(3),
145 A(4)
146 );
147 c = std::move(c0);
148 assert(c.bucket_count() == 7);
149 assert(c.size() == 4);
150 assert(c.count(1) == 1);
151 assert(c.count(2) == 1);
152 assert(c.count(3) == 1);
153 assert(c.count(4) == 1);
154 assert(c.hash_function() == test_hash<std::hash<int> >(8));
155 assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
156 assert(c.get_allocator() == A(10));
157 assert(!c.empty());
158 assert(std::distance(c.begin(), c.end()) == c.size());
159 assert(std::distance(c.cbegin(), c.cend()) == c.size());
160 assert(c.load_factor() == (float)c.size()/c.bucket_count());
161 assert(c.max_load_factor() == 1);
162 }
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]163#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]164}