Skip to content

Commit 30d54a3

Browse files
author
Julian LALU
committed
Trigger pipeline
1 parent b824b35 commit 30d54a3

File tree

2 files changed

+259
-257
lines changed

2 files changed

+259
-257
lines changed

‎test/hashmap/add/add_by_copy_construct_non_bitwise_copy_constructible_same_type.cpp‎

Lines changed: 259 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,259 @@
1+
#include <core/containers/hashmap.h>
2+
#include "../misc/allocator_watcher.h"
3+
4+
GTEST_TEST(hashmap, add_by_copy_construct_non_bitwise_copy_constructible_same_type)
5+
{
6+
using key_type = hud_test::non_bitwise_copy_constructible_type;
7+
using value_type = hud_test::non_bitwise_copy_constructible_type;
8+
using hashmap_type = hud::hashmap<key_type, value_type, hud::hash_64<key_type>, hud::equal<key_type>, hud_test::allocator_watcher<1>>;
9+
10+
static_assert(!hud::is_bitwise_copy_constructible_v<key_type>);
11+
static_assert(!hud::is_bitwise_copy_constructible_v<value_type>);
12+
13+
// With reallocation
14+
{
15+
static const auto test = []() {
16+
hashmap_type map;
17+
const key_type key_to_copy(1);
18+
const value_type value_to_copy(11);
19+
const auto it_1st = map.add(key_to_copy, value_to_copy);
20+
21+
const auto first_element_result = std::tuple {
22+
it_1st->key() == 1 && it_1st->value() == 11, // 0
23+
map.count() == 1, // 1
24+
map.max_count() >= map.count(), // 2
25+
it_1st->key().copy_constructor_count() == 1, // 3
26+
it_1st->value().copy_constructor_count() == 1, // 4
27+
map.allocator().allocation_count() == (hud::is_constant_evaluated() ? 2 : 1), // 5
28+
map.allocator().free_count() == 0, // 6
29+
};
30+
const key_type key_to_copy_1(1);
31+
const value_type value_to_copy_1(00);
32+
const auto it_same = map.add(key_to_copy_1, value_to_copy_1);
33+
34+
// Add same element
35+
const auto same_element_result = std::tuple {
36+
it_same->key() == 1 && it_same->value() == 11, // 0
37+
map.count() == 1, // 1
38+
map.max_count() >= map.count(), // 2
39+
it_same->key().copy_constructor_count() == 1, // 3
40+
it_same->value().copy_constructor_count() == 1, // 4
41+
map.allocator().allocation_count() == (hud::is_constant_evaluated() ? 2 : 1), // 5
42+
map.allocator().free_count() == 0, // 6
43+
};
44+
const key_type key_to_copy_2(2);
45+
const value_type value_to_copy_2(22);
46+
const auto it_2nd = map.add(key_to_copy_2, value_to_copy_2);
47+
// Add 2nd element
48+
const auto second_element_result = std::tuple {
49+
it_2nd->key() == 2 && it_2nd->value() == 22, // 0
50+
map.count() == 2, // 1
51+
map.max_count() >= map.count(), // 2
52+
it_2nd->key().copy_constructor_count() == 1, // 3
53+
it_2nd->value().copy_constructor_count() == 1, // 4
54+
map.allocator().allocation_count() == (hud::is_constant_evaluated() ? 4 : 2), // 5
55+
map.allocator().free_count() == (hud::is_constant_evaluated() ? 2 : 1), // 6
56+
};
57+
58+
return std::tuple {
59+
first_element_result,
60+
same_element_result,
61+
second_element_result
62+
};
63+
};
64+
65+
// Non Constant
66+
{
67+
const auto result = runtime_test(test);
68+
69+
// First element is correctly added
70+
const auto first_element_result = std::get<0>(result);
71+
hud_assert_true(std::get<0>(first_element_result));
72+
hud_assert_true(std::get<1>(first_element_result));
73+
hud_assert_true(std::get<2>(first_element_result));
74+
hud_assert_true(std::get<3>(first_element_result));
75+
hud_assert_true(std::get<4>(first_element_result));
76+
hud_assert_true(std::get<5>(first_element_result));
77+
hud_assert_true(std::get<6>(first_element_result));
78+
79+
// Same element
80+
const auto same_element_result = std::get<1>(result);
81+
hud_assert_true(std::get<0>(same_element_result));
82+
hud_assert_true(std::get<1>(same_element_result));
83+
hud_assert_true(std::get<2>(same_element_result));
84+
hud_assert_true(std::get<3>(same_element_result));
85+
hud_assert_true(std::get<4>(same_element_result));
86+
hud_assert_true(std::get<5>(same_element_result));
87+
hud_assert_true(std::get<6>(same_element_result));
88+
89+
// 2nd element
90+
const auto second_element_result = std::get<2>(result);
91+
hud_assert_true(std::get<0>(second_element_result));
92+
hud_assert_true(std::get<1>(second_element_result));
93+
hud_assert_true(std::get<2>(second_element_result));
94+
hud_assert_true(std::get<3>(second_element_result));
95+
hud_assert_true(std::get<4>(second_element_result));
96+
hud_assert_true(std::get<5>(second_element_result));
97+
hud_assert_true(std::get<6>(second_element_result));
98+
}
99+
// Constant
100+
{
101+
constexpr auto result = test();
102+
103+
// First element is correctly added
104+
const auto first_element_result = std::get<0>(result);
105+
hud_assert_true(std::get<0>(first_element_result));
106+
hud_assert_true(std::get<1>(first_element_result));
107+
hud_assert_true(std::get<2>(first_element_result));
108+
hud_assert_true(std::get<3>(first_element_result));
109+
hud_assert_true(std::get<4>(first_element_result));
110+
hud_assert_true(std::get<5>(first_element_result));
111+
hud_assert_true(std::get<6>(first_element_result));
112+
113+
// Same element
114+
const auto same_element_result = std::get<1>(result);
115+
hud_assert_true(std::get<0>(same_element_result));
116+
hud_assert_true(std::get<1>(same_element_result));
117+
hud_assert_true(std::get<2>(same_element_result));
118+
hud_assert_true(std::get<3>(same_element_result));
119+
hud_assert_true(std::get<4>(same_element_result));
120+
hud_assert_true(std::get<5>(same_element_result));
121+
hud_assert_true(std::get<6>(same_element_result));
122+
123+
// 2nd element
124+
const auto second_element_result = std::get<2>(result);
125+
hud_assert_true(std::get<0>(second_element_result));
126+
hud_assert_true(std::get<1>(second_element_result));
127+
hud_assert_true(std::get<2>(second_element_result));
128+
hud_assert_true(std::get<3>(second_element_result));
129+
hud_assert_true(std::get<4>(second_element_result));
130+
hud_assert_true(std::get<5>(second_element_result));
131+
hud_assert_true(std::get<6>(second_element_result));
132+
}
133+
}
134+
135+
// Without reallocation
136+
{
137+
static const auto test = []() {
138+
constexpr usize reserved_size = 2;
139+
hashmap_type map;
140+
map.reserve(reserved_size);
141+
const key_type key_to_copy(1);
142+
const value_type value_to_copy(11);
143+
const auto it_1st = map.add(key_to_copy, value_to_copy);
144+
145+
const auto first_element_result = std::tuple {
146+
it_1st->key() == 1 && it_1st->value() == 11, // 0
147+
map.count() == 1, // 1
148+
map.max_count() >= reserved_size, // 2
149+
it_1st->key().copy_constructor_count() == 1, // 3
150+
it_1st->value().copy_constructor_count() == 1, // 4
151+
map.allocator().allocation_count() == (hud::is_constant_evaluated() ? 2 : 1), // 5
152+
map.allocator().free_count() == 0, // 6
153+
};
154+
const key_type key_to_copy_1(1);
155+
const value_type value_to_copy_1(00);
156+
const auto it_same = map.add(key_to_copy_1, value_to_copy_1);
157+
158+
// Add same element
159+
const auto same_element_result = std::tuple {
160+
it_same->key() == 1 && it_same->value() == 11, // 0
161+
map.count() == 1, // 1
162+
map.max_count() >= reserved_size, // 2
163+
it_same->key().copy_constructor_count() == 1, // 3
164+
it_same->value().copy_constructor_count() == 1, // 4
165+
map.allocator().allocation_count() == (hud::is_constant_evaluated() ? 2 : 1), // 5
166+
map.allocator().free_count() == 0, // 6
167+
};
168+
const key_type key_to_copy_2(2);
169+
const value_type value_to_copy_2(22);
170+
const auto it_2nd = map.add(key_to_copy_2, value_to_copy_2);
171+
// Add 2nd element
172+
const auto second_element_result = std::tuple {
173+
it_2nd->key() == 2 && it_2nd->value() == 22, // 0
174+
map.count() == 2, // 1
175+
map.max_count() >= reserved_size, // 2
176+
it_2nd->key().copy_constructor_count() == 1, // 3
177+
it_2nd->value().copy_constructor_count() == 1, // 4
178+
map.allocator().allocation_count() == (hud::is_constant_evaluated() ? 2 : 1), // 5
179+
map.allocator().free_count() == 0, // 6
180+
};
181+
182+
return std::tuple {
183+
first_element_result,
184+
same_element_result,
185+
second_element_result
186+
};
187+
};
188+
189+
// Non Constant
190+
{
191+
const auto result = runtime_test(test);
192+
193+
// First element is correctly added
194+
const auto first_element_result = std::get<0>(result);
195+
hud_assert_true(std::get<0>(first_element_result));
196+
hud_assert_true(std::get<1>(first_element_result));
197+
hud_assert_true(std::get<2>(first_element_result));
198+
hud_assert_true(std::get<3>(first_element_result));
199+
hud_assert_true(std::get<4>(first_element_result));
200+
hud_assert_true(std::get<5>(first_element_result));
201+
hud_assert_true(std::get<6>(first_element_result));
202+
203+
// Same element
204+
const auto same_element_result = std::get<1>(result);
205+
hud_assert_true(std::get<0>(same_element_result));
206+
hud_assert_true(std::get<1>(same_element_result));
207+
hud_assert_true(std::get<2>(same_element_result));
208+
hud_assert_true(std::get<3>(same_element_result));
209+
hud_assert_true(std::get<4>(same_element_result));
210+
hud_assert_true(std::get<5>(same_element_result));
211+
hud_assert_true(std::get<6>(same_element_result));
212+
213+
// 2nd element
214+
const auto second_element_result = std::get<2>(result);
215+
hud_assert_true(std::get<0>(second_element_result));
216+
hud_assert_true(std::get<1>(second_element_result));
217+
hud_assert_true(std::get<2>(second_element_result));
218+
hud_assert_true(std::get<3>(second_element_result));
219+
hud_assert_true(std::get<4>(second_element_result));
220+
hud_assert_true(std::get<5>(second_element_result));
221+
hud_assert_true(std::get<6>(second_element_result));
222+
}
223+
224+
// Constant
225+
{
226+
constexpr auto result = test();
227+
228+
// First element is correctly added
229+
const auto first_element_result = std::get<0>(result);
230+
hud_assert_true(std::get<0>(first_element_result));
231+
hud_assert_true(std::get<1>(first_element_result));
232+
hud_assert_true(std::get<2>(first_element_result));
233+
hud_assert_true(std::get<3>(first_element_result));
234+
hud_assert_true(std::get<4>(first_element_result));
235+
hud_assert_true(std::get<5>(first_element_result));
236+
hud_assert_true(std::get<6>(first_element_result));
237+
238+
// Same element
239+
const auto same_element_result = std::get<1>(result);
240+
hud_assert_true(std::get<0>(same_element_result));
241+
hud_assert_true(std::get<1>(same_element_result));
242+
hud_assert_true(std::get<2>(same_element_result));
243+
hud_assert_true(std::get<3>(same_element_result));
244+
hud_assert_true(std::get<4>(same_element_result));
245+
hud_assert_true(std::get<5>(same_element_result));
246+
hud_assert_true(std::get<6>(same_element_result));
247+
248+
// 2nd element
249+
const auto second_element_result = std::get<2>(result);
250+
hud_assert_true(std::get<0>(second_element_result));
251+
hud_assert_true(std::get<1>(second_element_result));
252+
hud_assert_true(std::get<2>(second_element_result));
253+
hud_assert_true(std::get<3>(second_element_result));
254+
hud_assert_true(std::get<4>(second_element_result));
255+
hud_assert_true(std::get<5>(second_element_result));
256+
hud_assert_true(std::get<6>(second_element_result));
257+
}
258+
}
259+
}

0 commit comments

Comments
 (0)