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