Skip to content

Commit be5dcf7

Browse files
wusatosiwusatosi
committed
fix compare.test.cpp
1 parent 680e372 commit be5dcf7

File tree

2 files changed

+83
-83
lines changed

2 files changed

+83
-83
lines changed

‎tests/beman/inplace_vector/CMakeLists.txt‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ endfunction()
3535
# Tests for official specs
3636
add_gtest(container_requirements)
3737
add_gtest(triviality)
38-
# add_gtest(compare)
38+
add_gtest(compare)
3939
add_gtest(constructors)
4040
# add_gtest(size_n_data)
4141
# add_gtest(erasure)

‎tests/beman/inplace_vector/compare.test.cpp‎

Lines changed: 82 additions & 82 deletions
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,14 @@ template <typename T> struct vec_list {
2727
T lesser_bigger; // lesser number of elements but bigger values
2828
};
2929

30+
template <typename T>
31+
T Vec(std::initializer_list<typename T::value_type> list) {
32+
T vec;
33+
for (auto &ele : list)
34+
vec.unchecked_push_back(ele);
35+
return vec;
36+
}
37+
3038
template <typename T> static void runtests(vec_list<T> &list) {
3139

3240
static_assert(std::three_way_comparable<T> || lessthan_comparable<T>);
@@ -86,32 +94,34 @@ template <typename T> static void runtests(vec_list<T> &list) {
8694
};
8795

8896
TEST(Compare, threeway_int) {
89-
vec_list<inplace_vector<int, 4>> list{
97+
using IV = inplace_vector<int, 4>;
98+
vec_list<IV> list{
9099
.empty{},
91-
.base{1, 2, 3},
92-
.copy{1, 2, 3},
93-
.greater{4, 5, 6},
94-
.lesser{0, 0, 0},
95-
.bigger{1, 2, 3, 0},
96-
.smaller{1, 2},
97-
.greater_smaller{2, 2},
98-
.lesser_bigger{0, 2, 3, 4},
100+
.base{Vec<IV>({1, 2, 3})},
101+
.copy{Vec<IV>({1, 2, 3})},
102+
.greater{Vec<IV>({4, 5, 6})},
103+
.lesser{Vec<IV>({0, 0, 0})},
104+
.bigger{Vec<IV>({1, 2, 3, 0})},
105+
.smaller{Vec<IV>({1, 2})},
106+
.greater_smaller{Vec<IV>({2, 2})},
107+
.lesser_bigger{Vec<IV>({0, 2, 3, 4})},
99108
};
100109

101110
runtests(list);
102111
}
103112

104113
TEST(Compare, threeway_float) {
105-
vec_list<inplace_vector<float, 4>> list{
114+
using IV = inplace_vector<float, 4>;
115+
vec_list<IV> list{
106116
.empty{},
107-
.base{1.0f, 2.0f, 3.0f},
108-
.copy{1.0f, 2.0f, 3.0f},
109-
.greater{4.0f, 5.0f, 6.0f},
110-
.lesser{0.0f, 0.0f, 0.0f},
111-
.bigger{1.0f, 2.0f, 3.0f, 0.0f},
112-
.smaller{1.0f, 2.0f},
113-
.greater_smaller{2.0f, 2.0f},
114-
.lesser_bigger{0.0f, 2.0f, 3.0f, 4.0f},
117+
.base{Vec<IV>({1.0f, 2.0f, 3.0f})},
118+
.copy{Vec<IV>({1.0f, 2.0f, 3.0f})},
119+
.greater{Vec<IV>({4.0f, 5.0f, 6.0f})},
120+
.lesser{Vec<IV>({0.0f, 0.0f, 0.0f})},
121+
.bigger{Vec<IV>({1.0f, 2.0f, 3.0f, 0.0f})},
122+
.smaller{Vec<IV>({1.0f, 2.0f})},
123+
.greater_smaller{Vec<IV>({2.0f, 2.0f})},
124+
.lesser_bigger{Vec<IV>({0.0f, 2.0f, 3.0f, 4.0f})},
115125
};
116126

117127
runtests(list);
@@ -125,8 +135,8 @@ TEST(Compare, threeway_float) {
125135
EXPECT_FALSE(std::nanf("") >= std::nanf(""));
126136
EXPECT_FALSE(std::nanf("") <= std::nanf(""));
127137

128-
inplace_vector<float, 4> vnan{std::nanf("")};
129-
inplace_vector<float, 4> vnan2{std::nanf("")};
138+
auto vnan = Vec<IV>({std::nanf("")});
139+
auto vnan2 = Vec<IV>({std::nanf("")});
130140

131141
EXPECT_EQ(vnan <=> vnan2, std::partial_ordering::unordered);
132142
EXPECT_FALSE(vnan == vnan2);
@@ -148,17 +158,16 @@ TEST(Compare, threeway_comparable1) {
148158
static_assert(std::three_way_comparable<inplace_vector<comparable1, 4>>);
149159
static_assert(has_threeway<inplace_vector<comparable1, 4>>);
150160

151-
vec_list<inplace_vector<comparable1, 4>> list{
152-
.empty{},
153-
.base{{1, 2}, {3, 4}},
154-
.copy{{1, 2}, {3, 4}},
155-
.greater{{5, 6}, {7, 8}},
156-
.lesser{{0, 0}, {0, 0}},
157-
.bigger{{1, 2}, {3, 4}, {5, 6}},
158-
.smaller{{1, 2}},
159-
.greater_smaller{{2, 2}, {3, 3}},
160-
.lesser_bigger{{0, 2}, {3, 3}, {4, 4}},
161-
};
161+
using IV = inplace_vector<comparable1, 4>;
162+
vec_list<IV> list{.empty{},
163+
.base{Vec<IV>({{1, 2}, {3, 4}})},
164+
.copy{Vec<IV>({{1, 2}, {3, 4}})},
165+
.greater{Vec<IV>({{5, 6}, {7, 8}})},
166+
.lesser{Vec<IV>({{0, 0}, {0, 0}})},
167+
.bigger{Vec<IV>({{1, 2}, {3, 4}, {5, 6}})},
168+
.smaller{Vec<IV>({{1, 2}})},
169+
.greater_smaller{Vec<IV>({{2, 2}, {3, 3}})},
170+
.lesser_bigger{Vec<IV>({{0, 2}, {3, 3}, {4, 4}})}};
162171

163172
runtests(list);
164173
}
@@ -180,17 +189,16 @@ TEST(Compare, threeway_comparable2) {
180189
static_assert(std::three_way_comparable<inplace_vector<comparable2, 4>>);
181190
static_assert(has_threeway<inplace_vector<comparable2, 4>>);
182191

183-
vec_list<inplace_vector<comparable2, 4>> list{
184-
.empty{},
185-
.base{{1, 2}, {3, 4}},
186-
.copy{{1, 2}, {3, 4}},
187-
.greater{{5, 6}, {7, 8}},
188-
.lesser{{0, 0}, {0, 0}},
189-
.bigger{{1, 2}, {3, 4}, {5, 6}},
190-
.smaller{{1, 2}},
191-
.greater_smaller{{2, 2}, {3, 3}},
192-
.lesser_bigger{{0, 2}, {3, 3}, {4, 4}},
193-
};
192+
using IV = inplace_vector<comparable2, 4>;
193+
vec_list<IV> list{.empty{},
194+
.base{Vec<IV>({{1, 2}, {3, 4}})},
195+
.copy{Vec<IV>({{1, 2}, {3, 4}})},
196+
.greater{Vec<IV>({{5, 6}, {7, 8}})},
197+
.lesser{Vec<IV>({{0, 0}, {0, 0}})},
198+
.bigger{Vec<IV>({{1, 2}, {3, 4}, {5, 6}})},
199+
.smaller{Vec<IV>({{1, 2}})},
200+
.greater_smaller{Vec<IV>({{2, 2}, {3, 3}})},
201+
.lesser_bigger{Vec<IV>({{0, 2}, {3, 3}, {4, 4}})}};
194202

195203
runtests(list);
196204
}
@@ -203,19 +211,16 @@ TEST(Compare, threeway_strong_ordering) {
203211
operator<=>(const weaktype &other) const = default;
204212
};
205213

206-
using T = weaktype;
207-
208-
vec_list<inplace_vector<weaktype, 4>> list{
209-
.empty{},
210-
.base{T{1}, T{2}, T{3}},
211-
.copy{T{1}, T{2}, T{3}},
212-
.greater{T{4}, T{5}, T{6}},
213-
.lesser{T{0}, T{0}, T{0}},
214-
.bigger{T{1}, T{2}, T{3}, T{0}},
215-
.smaller{T{1}, T{2}},
216-
.greater_smaller{T{2}, T{2}},
217-
.lesser_bigger{T{0}, T{2}, T{3}, T{4}},
218-
};
214+
using IV = inplace_vector<weaktype, 4>;
215+
vec_list<IV> list{.empty{},
216+
.base{Vec<IV>({{1}, {2}, {3}})},
217+
.copy{Vec<IV>({{1}, {2}, {3}})},
218+
.greater{Vec<IV>({{4}, {5}, {6}})},
219+
.lesser{Vec<IV>({{0}, {0}, {0}})},
220+
.bigger{Vec<IV>({{1}, {2}, {3}, {0}})},
221+
.smaller{Vec<IV>({{1}, {2}})},
222+
.greater_smaller{Vec<IV>({{2}, {2}})},
223+
.lesser_bigger{Vec<IV>({{0}, {2}, {3}, {4}})}};
219224

220225
runtests(list);
221226
}
@@ -228,19 +233,16 @@ TEST(Compare, threeway_weak_ordering) {
228233
operator<=>(const weaktype &other) const = default;
229234
};
230235

231-
using T = weaktype;
232-
233-
vec_list<inplace_vector<weaktype, 4>> list{
234-
.empty{},
235-
.base{T{1}, T{2}, T{3}},
236-
.copy{T{1}, T{2}, T{3}},
237-
.greater{T{4}, T{5}, T{6}},
238-
.lesser{T{0}, T{0}, T{0}},
239-
.bigger{T{1}, T{2}, T{3}, T{0}},
240-
.smaller{T{1}, T{2}},
241-
.greater_smaller{T{2}, T{2}},
242-
.lesser_bigger{T{0}, T{2}, T{3}, T{4}},
243-
};
236+
using IV = inplace_vector<weaktype, 4>;
237+
vec_list<IV> list{.empty{},
238+
.base{Vec<IV>({{1}, {2}, {3}})},
239+
.copy{Vec<IV>({{1}, {2}, {3}})},
240+
.greater{Vec<IV>({{4}, {5}, {6}})},
241+
.lesser{Vec<IV>({{0}, {0}, {0}})},
242+
.bigger{Vec<IV>({{1}, {2}, {3}, {0}})},
243+
.smaller{Vec<IV>({{1}, {2}})},
244+
.greater_smaller{Vec<IV>({{2}, {2}})},
245+
.lesser_bigger{Vec<IV>({{0}, {2}, {3}, {4}})}};
244246

245247
runtests(list);
246248
}
@@ -263,27 +265,25 @@ TEST(Compare, threeway_partial_ordering) {
263265
};
264266

265267
using T = custom;
266-
267-
vec_list<inplace_vector<custom, 4>> list{
268-
.empty{},
269-
.base{T{1}, T{2}, T{3}},
270-
.copy{T{1}, T{2}, T{3}},
271-
.greater{T{4}, T{5}, T{6}},
272-
.lesser{T{0}, T{0}, T{0}},
273-
.bigger{T{1}, T{2}, T{3}, T{0}},
274-
.smaller{T{1}, T{2}},
275-
.greater_smaller{T{2}, T{2}},
276-
.lesser_bigger{T{0}, T{2}, T{3}, T{4}},
277-
};
268+
using IV = inplace_vector<T, 4>;
269+
vec_list<IV> list{.empty{},
270+
.base{Vec<IV>({{1}, {2}, {3}})},
271+
.copy{Vec<IV>({{1}, {2}, {3}})},
272+
.greater{Vec<IV>({{4}, {5}, {6}})},
273+
.lesser{Vec<IV>({{0}, {0}, {0}})},
274+
.bigger{Vec<IV>({{1}, {2}, {3}, {0}})},
275+
.smaller{Vec<IV>({{1}, {2}})},
276+
.greater_smaller{Vec<IV>({{2}, {2}})},
277+
.lesser_bigger{Vec<IV>({{0}, {2}, {3}, {4}})}};
278278

279279
runtests(list);
280280

281281
T t1{-1};
282282
T t2 = t1;
283283
EXPECT_EQ(t1 <=> t2, std::partial_ordering::unordered);
284284

285-
inplace_vector<T, 4> v1{t1};
286-
inplace_vector<T, 4> v2{t2};
285+
auto v1 = Vec<IV>({t1});
286+
auto v2 = Vec<IV>({t2});
287287

288288
EXPECT_EQ(v1 <=> v2, std::partial_ordering::unordered);
289289
EXPECT_FALSE(v1 == v2);

0 commit comments

Comments
 (0)