source: mainline/uspace/lib/cpp/src/__bits/test/set.cpp@ c6f23a7

Last change on this file since c6f23a7 was b57ba05, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 3 years ago

Update headers in C++ files
  • Property mode set to 100644
File size: 8.3 KB
Line 
1/*
2 * SPDX-FileCopyrightText: 2018 Jaroslav Jindrak
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7#include <__bits/test/tests.hpp>
8#include <initializer_list>
9#include <set>
10#include <string>
11#include <utility>
12
13namespace std::test
14{
15 bool set_test::run(bool report)
16 {
17 report_ = report;
18 start();
19
20 test_constructors_and_assignment();
21 test_emplace_insert();
22 test_bounds_and_ranges();
23 test_multi();
24 test_reverse_iterators();
25 test_multi_bounds_and_ranges();
26
27 return end();
28 }
29
30 const char* set_test::name()
31 {
32 return "set";
33 }
34
35 void set_test::test_constructors_and_assignment()
36 {
37 auto check1 = {1, 2, 3, 4, 5, 6, 7};
38 auto src1 = {3, 1, 5, 2, 7, 6, 4};
39
40 std::set<int> s1{src1};
41 test_eq(
42 "initializer list initialization",
43 check1.begin(), check1.end(),
44 s1.begin(), s1.end()
45 );
46 test_eq("size", s1.size(), 7U);
47
48 std::set<int> s2{src1.begin(), src1.end()};
49 test_eq(
50 "iterator range initialization",
51 check1.begin(), check1.end(),
52 s2.begin(), s2.end()
53 );
54
55 std::set<int> s3{s1};
56 test_eq(
57 "copy initialization",
58 check1.begin(), check1.end(),
59 s3.begin(), s3.end()
60 );
61
62 std::set<int> s4{std::move(s1)};
63 test_eq(
64 "move initialization",
65 check1.begin(), check1.end(),
66 s4.begin(), s4.end()
67 );
68 test_eq("move initialization - origin empty", s1.size(), 0U);
69 test_eq("empty", s1.empty(), true);
70
71 s1 = s4;
72 test_eq(
73 "copy assignment",
74 check1.begin(), check1.end(),
75 s1.begin(), s1.end()
76 );
77
78 s4 = std::move(s1);
79 test_eq(
80 "move assignment",
81 check1.begin(), check1.end(),
82 s4.begin(), s4.end()
83 );
84 test_eq("move assignment - origin empty", s1.size(), 0U);
85
86 s1 = src1;
87 test_eq(
88 "initializer list assignment",
89 check1.begin(), check1.end(),
90 s1.begin(), s1.end()
91 );
92 }
93
94 void set_test::test_emplace_insert()
95 {
96 std::set<int> set1{};
97
98 auto res1 = set1.emplace(1);
99 test_eq("first emplace succession", res1.second, true);
100 test_eq("first emplace equivalence", *res1.first, 1);
101
102 auto res2 = set1.emplace(1);
103 test_eq("second emplace failure", res2.second, false);
104 test_eq("second emplace equivalence", *res2.first, 1);
105
106 auto res3 = set1.emplace_hint(set1.begin(), 2);
107 test_eq("first emplace_hint succession", (res3 != set1.end()), true);
108 test_eq("first emplace_hint equivalence", *res3, 2);
109
110 auto res4 = set1.emplace_hint(set1.begin(), 2);
111 test_eq("second emplace_hint failure", (res4 != set1.end()), true);
112 test_eq("second emplace_hint equivalence", *res4, 2);
113
114 std::set<std::string> set2{};
115 auto res5 = set2.insert("A");
116 test_eq("conversion insert succession", res5.second, true);
117 test_eq("conversion insert equivalence", *res5.first, std::string{"A"});
118
119 auto res6 = set2.insert(std::string{"B"});
120 test_eq("first insert succession", res6.second, true);
121 test_eq("first insert equivalence", *res6.first, std::string{"B"});
122
123 auto res7 = set2.insert(std::string{"B"});
124 test_eq("second insert failure", res7.second, false);
125 test_eq("second insert equivalence", *res7.first, std::string{"B"});
126
127 auto res10 = set1.erase(set1.find(2));
128 test_eq("erase", set1.find(2), set1.end());
129 test_eq("highest erased", res10, set1.end());
130
131 set2.insert(std::string{"G"});
132 set2.insert(std::string{"H"});
133 set2.insert(std::string{"K"});
134 auto res11 = set2.erase(std::string{"G"});
135 test_eq("erase by key pt1", res11, 1U);
136 auto res12 = set2.erase(std::string{"M"});
137 test_eq("erase by key pt2", res12, 0U);
138
139 std::set<int> set3{};
140 set3.insert(1);
141 auto res13 = set3.erase(1);
142 test_eq("erase root by key pt1", res13, 1U);
143 test_eq("erase root by key pt2", set3.empty(), true);
144
145 set3.insert(3);
146 auto res14 = set3.erase(set3.begin());
147 test_eq("erase root by iterator pt1", res14, set3.end());
148 test_eq("erase root by iterator pt2", set3.empty(), true);
149
150 set2.clear();
151 test_eq("clear", set2.empty(), true);
152
153 set3.insert(1);
154 auto res15 = set3.count(1);
155 test_eq("count", res15, 1U);
156 }
157
158 void set_test::test_bounds_and_ranges()
159 {
160 std::set<int> set{};
161 for (int i = 0; i < 10; ++i)
162 set.insert(i);
163 for (int i = 15; i < 20; ++i)
164 set.insert(i);
165
166 auto res1 = set.lower_bound(5);
167 test_eq("lower_bound of present key", *res1, 5);
168
169 auto res2 = set.lower_bound(13);
170 test_eq("lower_bound of absent key", *res2, 9);
171
172 auto res3 = set.upper_bound(7);
173 test_eq("upper_bound of present key", *res3, 8);
174
175 auto res4 = set.upper_bound(12);
176 test_eq("upper_bound of absent key", *res4, 15);
177
178 auto res5 = set.equal_range(4);
179 test_eq("equal_range of present key pt1", *res5.first, 4);
180 test_eq("equal_range of present key pt2", *res5.second, 5);
181
182 auto res6 = set.equal_range(14);
183 test_eq("equal_range of absent key pt1", *res6.first, 9);
184 test_eq("equal_range of absent key pt2", *res6.second, 15);
185 }
186
187 void set_test::test_multi()
188 {
189 auto check1 = {1, 2, 3, 3, 4, 5, 6, 6, 6, 7};
190 auto src1 = {3, 6, 1, 5, 6, 3, 2, 7, 6, 4};
191
192 std::multiset<int> mset{src1};
193 test_eq(
194 "multi construction",
195 check1.begin(), check1.end(),
196 mset.begin(), mset.end()
197 );
198
199 auto res1 = mset.count(6);
200 test_eq("multi count", res1, 3U);
201
202 auto res2 = mset.emplace(7);
203 test_eq("multi duplicit emplace pt1", *res2, 7);
204 test_eq("multi duplicit emplace pt2", mset.count(7), 2U);
205
206 auto res3 = mset.emplace(8);
207 test_eq("multi unique emplace pt1", *res3, 8);
208 test_eq("multi unique emplace pt2", mset.count(8), 1U);
209
210 auto res4 = mset.insert(8);
211 test_eq("multi duplicit insert pt1", *res4, 8);
212 test_eq("multi duplicit insert pt2", mset.count(8), 2U);
213
214 auto res5 = mset.insert(9);
215 test_eq("multi unique insert pt1", *res5, 9);
216 test_eq("multi unique insert pt2", mset.count(9), 1U);
217
218 auto res6 = mset.erase(8);
219 test_eq("multi erase by key pt1", res6, 2U);
220 test_eq("multi erase by key pt2", mset.count(8), 0U);
221
222 auto res7 = mset.erase(mset.find(7));
223 test_eq("multi erase by iterator pt1", *res7, 7);
224 test_eq("multi erase by iterator pt2", mset.count(7), 1U);
225 }
226
227 void set_test::test_reverse_iterators()
228 {
229 auto check1 = {7, 6, 6, 6, 5, 4, 3, 3, 2, 1};
230 auto src1 = {3, 6, 1, 5, 6, 3, 2, 7, 6, 4};
231
232 std::multiset<int> mset{src1};
233 test_eq(
234 "multi reverse iterators",
235 check1.begin(), check1.end(),
236 mset.rbegin(), mset.rend()
237 );
238
239 auto check2 = {7, 6, 5, 4, 3, 2, 1};
240 auto src2 = {3, 1, 5, 2, 7, 6, 4};
241
242 std::set<int> set{src2};
243 test_eq(
244 "reverse iterators",
245 check2.begin(), check2.end(),
246 set.rbegin(), set.rend()
247 );
248 }
249
250 void set_test::test_multi_bounds_and_ranges()
251 {
252 auto check1 = {1, 1};
253 auto check2 = {5, 5, 5};
254 auto check3 = {6};
255 auto src = {1, 1, 2, 3, 5, 5, 5, 6};
256
257 std::multiset<int> mset{src};
258 auto res1 = mset.equal_range(1);
259 test_eq(
260 "multi equal_range at the start",
261 check1.begin(), check1.end(),
262 res1.first, res1.second
263 );
264
265 auto res2 = mset.equal_range(5);
266 test_eq(
267 "multi equal_range in the middle",
268 check2.begin(), check2.end(),
269 res2.first, res2.second
270 );
271
272 auto res3 = mset.equal_range(6);
273 test_eq(
274 "multi equal_range at the end + single element range",
275 check3.begin(), check3.end(),
276 res3.first, res3.second
277 );
278 }
279}
Note: See TracBrowser for help on using the repository browser.