sandbox
Loading...
Searching...
No Matches
vector4_tests.hpp
1#ifndef LIBSBX_MATH_TESTS_VECTOR4_TESTS_HPP_
2#define LIBSBX_MATH_TESTS_VECTOR4_TESTS_HPP_
3
4#include <sstream>
5
6#include <gtest/gtest.h>
7
8#include <libsbx/math/vector4.hpp>
9
10TEST(libsbx_math_vector4, zero) {
11 const auto vector = sbx::math::vector4::zero;
12
13 EXPECT_FLOAT_EQ(vector.x(), 0.0f);
14 EXPECT_FLOAT_EQ(vector.y(), 0.0f);
15 EXPECT_FLOAT_EQ(vector.z(), 0.0f);
16 EXPECT_FLOAT_EQ(vector.w(), 0.0f);
17}
18
19TEST(libsbx_math_vector4, one) {
20 const auto vector = sbx::math::vector4::one;
21
22 EXPECT_FLOAT_EQ(vector.x(), 1.0f);
23 EXPECT_FLOAT_EQ(vector.y(), 1.0f);
24 EXPECT_FLOAT_EQ(vector.z(), 1.0f);
25 EXPECT_FLOAT_EQ(vector.w(), 1.0f);
26}
27
28TEST(libsbx_math_vector4, default_constructor) {
29 const auto vector = sbx::math::vector4{};
30
31 EXPECT_FLOAT_EQ(vector.x(), 0.0f);
32 EXPECT_FLOAT_EQ(vector.y(), 0.0f);
33 EXPECT_FLOAT_EQ(vector.z(), 0.0f);
34 EXPECT_FLOAT_EQ(vector.w(), 0.0f);
35}
36
37TEST(libsbx_math_vector4, base_constructor) {
38 const auto base = sbx::math::basic_vector<4u, std::float_t>{1};
39 const auto vector = sbx::math::vector4{base};
40
41 EXPECT_FLOAT_EQ(vector.x(), 1.0f);
42 EXPECT_FLOAT_EQ(vector.y(), 1.0f);
43 EXPECT_FLOAT_EQ(vector.z(), 1.0f);
44 EXPECT_FLOAT_EQ(vector.w(), 1.0f);
45}
46
47TEST(libsbx_math_vector4, single_value_constructor) {
48 const auto vector = sbx::math::vector4{1};
49
50 EXPECT_FLOAT_EQ(vector.x(), 1.0f);
51 EXPECT_FLOAT_EQ(vector.y(), 1.0f);
52 EXPECT_FLOAT_EQ(vector.z(), 1.0f);
53 EXPECT_FLOAT_EQ(vector.w(), 1.0f);
54}
55
56TEST(libsbx_math_vector4, multi_value_constructor) {
57 const auto vector = sbx::math::vector4{1, 2, 3, 4};
58
59 EXPECT_FLOAT_EQ(vector.x(), 1.0f);
60 EXPECT_FLOAT_EQ(vector.y(), 2.0f);
61 EXPECT_FLOAT_EQ(vector.z(), 3.0f);
62 EXPECT_FLOAT_EQ(vector.w(), 4.0f);
63}
64
65TEST(libsbx_math_vector4, vector3_constructor) {
66 const auto vector = sbx::math::vector4{sbx::math::vector3{1, 2, 3}};
67
68 EXPECT_FLOAT_EQ(vector.x(), 1.0f);
69 EXPECT_FLOAT_EQ(vector.y(), 2.0f);
70 EXPECT_FLOAT_EQ(vector.z(), 3.0f);
71 EXPECT_FLOAT_EQ(vector.w(), 0.0f);
72
73 const auto other = sbx::math::vector4{sbx::math::vector3{1, 2, 3}, 4};
74
75 EXPECT_FLOAT_EQ(other.x(), 1.0f);
76 EXPECT_FLOAT_EQ(other.y(), 2.0f);
77 EXPECT_FLOAT_EQ(other.z(), 3.0f);
78 EXPECT_FLOAT_EQ(other.w(), 4.0f);
79}
80
81TEST(libsbx_math_vector4, dot_product) {
82 const auto lhs = sbx::math::vector4{1, 2, 3, 4};
83 const auto rhs = sbx::math::vector4{4, 3, 2, 1};
84
85 const auto result = sbx::math::vector4::dot(lhs, rhs);
86
87 EXPECT_FLOAT_EQ(result, 20.0f);
88}
89
90TEST(libsbx_math_vector4, normalized) {
91 const auto vector = sbx::math::vector4{1, 2, 3, 4};
92 const auto result = sbx::math::vector4::normalized(vector);
93
94 EXPECT_FLOAT_EQ(result.x(), 0.1825741858350553711523232609336f);
95 EXPECT_FLOAT_EQ(result.y(), 0.3651483716701107423046465218672f);
96 EXPECT_FLOAT_EQ(result.z(), 0.5477225575051661134569697828008f);
97 EXPECT_FLOAT_EQ(result.w(), 0.7302967433402214846092930437344f);
98 EXPECT_FLOAT_EQ(result.length(), 1.0f);
99}
100
101TEST(libsbx_math_vector4, conversion) {
102 const auto vector = sbx::math::vector4{1, 2, 3, 4};
103
104 const auto result = sbx::math::vector3{vector};
105
106 EXPECT_FLOAT_EQ(result.x(), 1.0f);
107 EXPECT_FLOAT_EQ(result.y(), 2.0f);
108 EXPECT_FLOAT_EQ(result.z(), 3.0f);
109}
110
111TEST(libsbx_math_vector4, copy_constructor) {
112 const auto vector = sbx::math::vector4{1, 2, 3, 4};
113 const auto other = vector;
114
115 EXPECT_FLOAT_EQ(other.x(), 1.0f);
116 EXPECT_FLOAT_EQ(other.y(), 2.0f);
117 EXPECT_FLOAT_EQ(other.z(), 3.0f);
118 EXPECT_FLOAT_EQ(other.w(), 4.0f);
119}
120
121TEST(libsbx_math_vector4, move_constructor) {
122 auto vector = sbx::math::vector4{1, 2, 3, 4};
123 const auto other = std::move(vector);
124
125 EXPECT_FLOAT_EQ(other.x(), 1.0f);
126 EXPECT_FLOAT_EQ(other.y(), 2.0f);
127 EXPECT_FLOAT_EQ(other.z(), 3.0f);
128 EXPECT_FLOAT_EQ(other.w(), 4.0f);
129}
130
131TEST(libsbx_math_vector4, copy_assignment) {
132 const auto vector = sbx::math::vector4{1, 2, 3, 4};
133 auto other = sbx::math::vector4{};
134 other = vector;
135
136 EXPECT_FLOAT_EQ(other.x(), 1.0f);
137 EXPECT_FLOAT_EQ(other.y(), 2.0f);
138 EXPECT_FLOAT_EQ(other.z(), 3.0f);
139 EXPECT_FLOAT_EQ(other.w(), 4.0f);
140}
141
142TEST(libsbx_math_vector4, move_assignment) {
143 auto vector = sbx::math::vector4{1, 2, 3, 4};
144 auto other = sbx::math::vector4{};
145 other = std::move(vector);
146
147 EXPECT_FLOAT_EQ(other.x(), 1.0f);
148 EXPECT_FLOAT_EQ(other.y(), 2.0f);
149 EXPECT_FLOAT_EQ(other.z(), 3.0f);
150 EXPECT_FLOAT_EQ(other.w(), 4.0f);
151}
152
153TEST(libsbx_math_vector4, addition_assignment) {
154 auto vector = sbx::math::vector4{1, 2, 3, 4};
155 const auto other = sbx::math::vector4{1, 2, 3, 4};
156
157 vector += other;
158
159 EXPECT_FLOAT_EQ(vector.x(), 2.0f);
160 EXPECT_FLOAT_EQ(vector.y(), 4.0f);
161 EXPECT_FLOAT_EQ(vector.z(), 6.0f);
162 EXPECT_FLOAT_EQ(vector.w(), 8.0f);
163}
164
165TEST(libsbx_math_vector4, subtraction_assignment) {
166 auto vector = sbx::math::vector4{1, 2, 3, 4};
167 const auto other = sbx::math::vector4{1, 2, 3, 4};
168
169 vector -= other;
170
171 EXPECT_FLOAT_EQ(vector.x(), 0.0f);
172 EXPECT_FLOAT_EQ(vector.y(), 0.0f);
173 EXPECT_FLOAT_EQ(vector.z(), 0.0f);
174 EXPECT_FLOAT_EQ(vector.w(), 0.0f);
175}
176
177TEST(libsbx_math_vector4, multiplication_assignment) {
178 auto vector = sbx::math::vector4{1, 2, 3, 4};
179
180 vector *= 2;
181
182 EXPECT_FLOAT_EQ(vector.x(), 2.0f);
183 EXPECT_FLOAT_EQ(vector.y(), 4.0f);
184 EXPECT_FLOAT_EQ(vector.z(), 6.0f);
185 EXPECT_FLOAT_EQ(vector.w(), 8.0f);
186}
187
188TEST(libsbx_math_vector4, division_assignment) {
189 auto vector = sbx::math::vector4{2, 4, 6, 8};
190
191 vector /= 2;
192
193 EXPECT_FLOAT_EQ(vector.x(), 1.0f);
194 EXPECT_FLOAT_EQ(vector.y(), 2.0f);
195 EXPECT_FLOAT_EQ(vector.z(), 3.0f);
196 EXPECT_FLOAT_EQ(vector.w(), 4.0f);
197}
198
199TEST(libsbx_math_vector4, equality) {
200 const auto lhs = sbx::math::vector4{1, 2, 3, 4};
201 const auto rhs = sbx::math::vector4{1, 2, 3, 4};
202
203 EXPECT_TRUE(lhs == rhs);
204 EXPECT_FALSE(lhs != rhs);
205}
206
207TEST(libsbx_math_vector4, inequality) {
208 const auto lhs = sbx::math::vector4{1, 2, 3, 4};
209 const auto rhs = sbx::math::vector4{4, 3, 2, 1};
210
211 EXPECT_TRUE(lhs != rhs);
212 EXPECT_FALSE(lhs == rhs);
213}
214
215TEST(libsbx_math_vector4, addition) {
216 const auto lhs = sbx::math::vector4{1, 2, 3, 4};
217 const auto rhs = sbx::math::vector4{4, 3, 2, 1};
218 const auto result = lhs + rhs;
219
220 EXPECT_FLOAT_EQ(result.x(), 5.0f);
221 EXPECT_FLOAT_EQ(result.y(), 5.0f);
222 EXPECT_FLOAT_EQ(result.z(), 5.0f);
223 EXPECT_FLOAT_EQ(result.w(), 5.0f);
224}
225
226TEST(libsbx_math_vector4, subtraction) {
227 const auto lhs = sbx::math::vector4{1, 2, 3, 4};
228 const auto rhs = sbx::math::vector4{4, 3, 2, 1};
229 const auto result = lhs - rhs;
230
231 EXPECT_FLOAT_EQ(result.x(), -3.0f);
232 EXPECT_FLOAT_EQ(result.y(), -1.0f);
233 EXPECT_FLOAT_EQ(result.z(), 1.0f);
234 EXPECT_FLOAT_EQ(result.w(), 3.0f);
235}
236
237TEST(libsbx_math_vector4, negation) {
238 const auto vector = sbx::math::vector4{1, 2, 3, 4};
239 const auto result = -vector;
240
241 EXPECT_FLOAT_EQ(result.x(), -1.0f);
242 EXPECT_FLOAT_EQ(result.y(), -2.0f);
243 EXPECT_FLOAT_EQ(result.z(), -3.0f);
244 EXPECT_FLOAT_EQ(result.w(), -4.0f);
245}
246
247TEST(libsbx_math_vector4, multiplication) {
248 const auto lhs = sbx::math::vector4{1, 2, 3, 4};
249
250 const auto result = lhs * 2.0f;
251
252 EXPECT_FLOAT_EQ(result.x(), 2.0f);
253 EXPECT_FLOAT_EQ(result.y(), 4.0f);
254 EXPECT_FLOAT_EQ(result.z(), 6.0f);
255 EXPECT_FLOAT_EQ(result.w(), 8.0f);
256}
257
258TEST(libsbx_math_vector4, division) {
259 const auto lhs = sbx::math::vector4{4, 6, 6, 4};
260
261 const auto result = lhs / 2.0f;
262
263 EXPECT_FLOAT_EQ(result.x(), 2.0f);
264 EXPECT_FLOAT_EQ(result.y(), 3.0f);
265 EXPECT_FLOAT_EQ(result.z(), 3.0f);
266 EXPECT_FLOAT_EQ(result.w(), 2.0f);
267}
268
269TEST(libsbx_math_vector4, length_squared) {
270 const auto vector = sbx::math::vector4{2, 4, 6, 8};
271
272 const auto result = vector.length_squared();
273
274 EXPECT_FLOAT_EQ(result, 120.0f);
275}
276
277TEST(libsbx_math_vector4, length) {
278 const auto vector = sbx::math::vector4{2, 4, 6, 8};
279
280 const auto result = vector.length();
281
282 EXPECT_FLOAT_EQ(result, 10.954451150103322f);
283}
284
285TEST(libsbx_math_vector4, normalize) {
286 auto vector = sbx::math::vector4{2, 4, 6, 8};
287
288 vector.normalize();
289
290 EXPECT_FLOAT_EQ(vector.x(), 0.1825741858350553711523232609336f);
291 EXPECT_FLOAT_EQ(vector.y(), 0.3651483716701107423046465218672f);
292 EXPECT_FLOAT_EQ(vector.z(), 0.5477225575051661134569697828008f);
293 EXPECT_FLOAT_EQ(vector.w(), 0.7302967433402214846092930437344f);
294 EXPECT_FLOAT_EQ(vector.length(), 1.0f);
295}
296
297TEST(libsbx_math_vector4, get_x) {
298 const auto vector = sbx::math::vector4{1, 2, 3, 4};
299
300 const auto result = vector.x();
301
302 EXPECT_FLOAT_EQ(result, 1.0f);
303}
304
305TEST(libsbx_math_vector4, set_x) {
306 auto vector = sbx::math::vector4{1, 2, 3, 4};
307
308 vector.x() = 2;
309
310 EXPECT_FLOAT_EQ(vector.x(), 2.0f);
311}
312
313TEST(libsbx_math_vector4, get_y) {
314 const auto vector = sbx::math::vector4{1, 2, 3, 4};
315
316 const auto result = vector.y();
317
318 EXPECT_FLOAT_EQ(result, 2.0f);
319}
320
321TEST(libsbx_math_vector4, set_y) {
322 auto vector = sbx::math::vector4{1, 2, 3, 4};
323
324 vector.y() = 3;
325
326 EXPECT_FLOAT_EQ(vector.y(), 3.0f);
327}
328
329TEST(libsbx_math_vector4, get_z) {
330 const auto vector = sbx::math::vector4{1, 2, 3, 4};
331
332 const auto result = vector.z();
333
334 EXPECT_FLOAT_EQ(result, 3.0f);
335}
336
337TEST(libsbx_math_vector4, set_z) {
338 auto vector = sbx::math::vector4{1, 2, 3, 4};
339
340 vector.z() = 4;
341
342 EXPECT_FLOAT_EQ(vector.z(), 4.0f);
343}
344
345TEST(libsbx_math_vector4, get_w) {
346 const auto vector = sbx::math::vector4{1, 2, 3, 4};
347
348 const auto result = vector.w();
349
350 EXPECT_FLOAT_EQ(result, 4.0f);
351}
352
353TEST(libsbx_math_vector4, set_w) {
354 auto vector = sbx::math::vector4{1, 2, 3, 4};
355
356 vector.w() = 5;
357
358 EXPECT_FLOAT_EQ(vector.w(), 5.0f);
359}
360
361TEST(libsbx_math_vector4, hash) {
362 const auto first = sbx::math::vector4{1, 2, 3, 4};
363 const auto second = sbx::math::vector4{1, 2, 3, 4};
364
365 EXPECT_EQ(std::hash<sbx::math::vector4>{}(first), std::hash<sbx::math::vector4>{}(second));
366}
367
368TEST(libsbx_math_vector4, formatting) {
369 const auto float_vector = sbx::math::vector4f{1, 2, 3, 4};
370
371 auto formatted = fmt::format("{}", float_vector);
372
373 EXPECT_STREQ(formatted.c_str(), "{x: 1.00, y: 2.00, z: 3.00, w: 4.00}");
374
375 const auto int_vector = sbx::math::vector4i{1, 2, 3, 4};
376
377 formatted = fmt::format("{}", int_vector);
378
379 EXPECT_STREQ(formatted.c_str(), "{x: 1, y: 2, z: 3, w: 4}");
380}
381
382TEST(libsbx_math_vector4, serialize) {
383 const auto vector = sbx::math::vector4{1, 2, 3, 4};
384
385 const auto serialized = YAML::Node{vector};
386
387 EXPECT_FLOAT_EQ(serialized["x"].as<std::float_t>(), 1.0f);
388 EXPECT_FLOAT_EQ(serialized["y"].as<std::float_t>(), 2.0f);
389 EXPECT_FLOAT_EQ(serialized["z"].as<std::float_t>(), 3.0f);
390 EXPECT_FLOAT_EQ(serialized["w"].as<std::float_t>(), 4.0f);
391
392 auto steam = std::stringstream{};
393
394 steam << serialized;
395
396 EXPECT_STREQ(steam.str().c_str(), "{x: 1, y: 2, z: 3, w: 4}");
397}
398
399TEST(libsbx_math_vector4, deserialize) {
400 const auto node = YAML::Load("{x: 1, y: 2, z: 3, w: 4}");
401
402 const auto vector = node.as<sbx::math::vector4>();
403
404 EXPECT_FLOAT_EQ(vector.x(), 1.0f);
405 EXPECT_FLOAT_EQ(vector.y(), 2.0f);
406 EXPECT_FLOAT_EQ(vector.z(), 3.0f);
407 EXPECT_FLOAT_EQ(vector.w(), 4.0f);
408}
409
410#endif // LIBSBX_MATH_TESTS_VECTOR4_TESTS_HPP_
sbx::math::basic_vector3
Definition: vector3.hpp:22
sbx::math::basic_vector4
Definition: vector4.hpp:22
sbx::math::basic_vector
Definition: vector.hpp:19