1 | #include <gtest/gtest.h> |
---|
2 | #include "util/Math.h" |
---|
3 | #include <cmath> |
---|
4 | |
---|
5 | namespace orxonox |
---|
6 | { |
---|
7 | /////////// |
---|
8 | // sgn() // |
---|
9 | /////////// |
---|
10 | TEST(sgn, PositiveInt) |
---|
11 | { |
---|
12 | EXPECT_EQ(1, sgn( 1)); |
---|
13 | EXPECT_EQ(1, sgn(10)); |
---|
14 | } |
---|
15 | |
---|
16 | TEST(sgn, PositiveDouble) |
---|
17 | { |
---|
18 | EXPECT_DOUBLE_EQ(1.0, sgn( 0.1)); |
---|
19 | EXPECT_DOUBLE_EQ(1.0, sgn( 1.0)); |
---|
20 | EXPECT_DOUBLE_EQ(1.0, sgn(10.0)); |
---|
21 | } |
---|
22 | |
---|
23 | TEST(sgn, NegativeInt) |
---|
24 | { |
---|
25 | EXPECT_EQ(-1, sgn( -1)); |
---|
26 | EXPECT_EQ(-1, sgn(-10)); |
---|
27 | } |
---|
28 | |
---|
29 | TEST(sgn, NegativeDouble) |
---|
30 | { |
---|
31 | EXPECT_DOUBLE_EQ(-1.0, sgn( -0.1)); |
---|
32 | EXPECT_DOUBLE_EQ(-1.0, sgn( -1.0)); |
---|
33 | EXPECT_DOUBLE_EQ(-1.0, sgn(-10.0)); |
---|
34 | } |
---|
35 | |
---|
36 | TEST(sgn, ZeroInt) |
---|
37 | { |
---|
38 | EXPECT_EQ(1, sgn(0)); |
---|
39 | } |
---|
40 | |
---|
41 | TEST(sgn, ZeroDouble) |
---|
42 | { |
---|
43 | EXPECT_DOUBLE_EQ(1.0, sgn(0.0)); |
---|
44 | } |
---|
45 | |
---|
46 | ///////////// |
---|
47 | // clamp() // |
---|
48 | ///////////// |
---|
49 | TEST(clamp, InRange) |
---|
50 | { |
---|
51 | // positive |
---|
52 | EXPECT_EQ(10, clamp(10, 10, 20)); |
---|
53 | EXPECT_EQ(15, clamp(15, 10, 20)); |
---|
54 | EXPECT_EQ(20, clamp(20, 10, 20)); |
---|
55 | |
---|
56 | // netagive |
---|
57 | EXPECT_EQ(-10, clamp(-10, -20, -10)); |
---|
58 | EXPECT_EQ(-15, clamp(-15, -20, -10)); |
---|
59 | EXPECT_EQ(-20, clamp(-20, -20, -10)); |
---|
60 | |
---|
61 | // mixed |
---|
62 | EXPECT_EQ(-10, clamp(-10, -10, 10)); |
---|
63 | EXPECT_EQ( 0, clamp( 0, -10, 10)); |
---|
64 | EXPECT_EQ( 10, clamp( 10, -10, 10)); |
---|
65 | } |
---|
66 | |
---|
67 | TEST(clamp, OutOfRange) |
---|
68 | { |
---|
69 | // positive |
---|
70 | EXPECT_EQ(10, clamp( 5, 10, 20)); |
---|
71 | EXPECT_EQ(20, clamp(25, 10, 20)); |
---|
72 | |
---|
73 | // netagive |
---|
74 | EXPECT_EQ(-10, clamp( -5, -20, -10)); |
---|
75 | EXPECT_EQ(-20, clamp(-25, -20, -10)); |
---|
76 | |
---|
77 | // mixed |
---|
78 | EXPECT_EQ(-10, clamp(-15, -10, 10)); |
---|
79 | EXPECT_EQ( 10, clamp( 15, -10, 10)); |
---|
80 | } |
---|
81 | |
---|
82 | ////////////// |
---|
83 | // square() // |
---|
84 | ////////////// |
---|
85 | TEST(square, Int) |
---|
86 | { |
---|
87 | // zero |
---|
88 | EXPECT_EQ( 0, square(0)); |
---|
89 | |
---|
90 | // positive |
---|
91 | EXPECT_EQ(1, square(1)); |
---|
92 | EXPECT_EQ(4, square(2)); |
---|
93 | EXPECT_EQ(9, square(3)); |
---|
94 | |
---|
95 | // negative |
---|
96 | EXPECT_EQ(1, square(-1)); |
---|
97 | EXPECT_EQ(4, square(-2)); |
---|
98 | EXPECT_EQ(9, square(-3)); |
---|
99 | } |
---|
100 | |
---|
101 | TEST(square, Double) |
---|
102 | { |
---|
103 | // zero |
---|
104 | EXPECT_DOUBLE_EQ( 0.0, square(0.0)); |
---|
105 | |
---|
106 | // positive |
---|
107 | EXPECT_DOUBLE_EQ( 1.00, square(1.0)); |
---|
108 | EXPECT_DOUBLE_EQ( 2.25, square(1.5)); |
---|
109 | EXPECT_DOUBLE_EQ( 4.00, square(2.0)); |
---|
110 | |
---|
111 | // negative |
---|
112 | EXPECT_DOUBLE_EQ( 1.00, square(-1.0)); |
---|
113 | EXPECT_DOUBLE_EQ( 2.25, square(-1.5)); |
---|
114 | EXPECT_DOUBLE_EQ( 4.00, square(-2.0)); |
---|
115 | } |
---|
116 | |
---|
117 | //////////// |
---|
118 | // cube() // |
---|
119 | //////////// |
---|
120 | TEST(cube, Int) |
---|
121 | { |
---|
122 | // zero |
---|
123 | EXPECT_EQ( 0, cube(0)); |
---|
124 | |
---|
125 | // positive |
---|
126 | EXPECT_EQ( 1, cube(1)); |
---|
127 | EXPECT_EQ( 8, cube(2)); |
---|
128 | EXPECT_EQ(27, cube(3)); |
---|
129 | |
---|
130 | // negative |
---|
131 | EXPECT_EQ( -1, cube(-1)); |
---|
132 | EXPECT_EQ( -8, cube(-2)); |
---|
133 | EXPECT_EQ(-27, cube(-3)); |
---|
134 | } |
---|
135 | |
---|
136 | TEST(cube, Double) |
---|
137 | { |
---|
138 | // zero |
---|
139 | EXPECT_DOUBLE_EQ( 0.0, cube(0.0)); |
---|
140 | |
---|
141 | // positive |
---|
142 | EXPECT_DOUBLE_EQ( 1.000, cube(1.0)); |
---|
143 | EXPECT_DOUBLE_EQ( 3.375, cube(1.5)); |
---|
144 | EXPECT_DOUBLE_EQ( 8.000, cube(2.0)); |
---|
145 | |
---|
146 | // negative |
---|
147 | EXPECT_DOUBLE_EQ( -1.000, cube(-1.0)); |
---|
148 | EXPECT_DOUBLE_EQ( -3.375, cube(-1.5)); |
---|
149 | EXPECT_DOUBLE_EQ( -8.000, cube(-2.0)); |
---|
150 | } |
---|
151 | |
---|
152 | ///////////// |
---|
153 | // round() // |
---|
154 | ///////////// |
---|
155 | TEST(round, Positive) |
---|
156 | { |
---|
157 | // int |
---|
158 | EXPECT_EQ( 5, round(5)); |
---|
159 | EXPECT_EQ(10, round(10)); |
---|
160 | |
---|
161 | // double |
---|
162 | EXPECT_EQ(4, round(4.499)); |
---|
163 | EXPECT_EQ(5, round(4.500)); |
---|
164 | EXPECT_EQ(5, round(4.999)); |
---|
165 | EXPECT_EQ(5, round(5.000)); |
---|
166 | EXPECT_EQ(5, round(5.001)); |
---|
167 | EXPECT_EQ(5, round(5.499)); |
---|
168 | EXPECT_EQ(6, round(5.500)); |
---|
169 | } |
---|
170 | |
---|
171 | ///////////// |
---|
172 | // round() // |
---|
173 | ///////////// |
---|
174 | TEST(round, Negative) |
---|
175 | { |
---|
176 | // int |
---|
177 | EXPECT_EQ( -5, round(-5)); |
---|
178 | EXPECT_EQ(-10, round(-10)); |
---|
179 | |
---|
180 | // double |
---|
181 | EXPECT_EQ(-4, round(-4.499)); |
---|
182 | EXPECT_EQ(-5, round(-4.500)); |
---|
183 | EXPECT_EQ(-5, round(-4.999)); |
---|
184 | EXPECT_EQ(-5, round(-5.000)); |
---|
185 | EXPECT_EQ(-5, round(-5.001)); |
---|
186 | EXPECT_EQ(-5, round(-5.499)); |
---|
187 | EXPECT_EQ(-6, round(-5.500)); |
---|
188 | } |
---|
189 | |
---|
190 | /////////// |
---|
191 | // mod() // |
---|
192 | /////////// |
---|
193 | TEST(mod, ModOperator) |
---|
194 | { |
---|
195 | // zero |
---|
196 | EXPECT_EQ(0, 0 % 10); |
---|
197 | |
---|
198 | // positive |
---|
199 | EXPECT_EQ(1, 1 % 10); |
---|
200 | EXPECT_EQ(5, 5 % 10); |
---|
201 | EXPECT_EQ(9, 9 % 10); |
---|
202 | EXPECT_EQ(0, 10 % 10); |
---|
203 | EXPECT_EQ(5, 15 % 10); |
---|
204 | |
---|
205 | // negative |
---|
206 | EXPECT_EQ(-1, -1 % 10); |
---|
207 | EXPECT_EQ(-5, -5 % 10); |
---|
208 | EXPECT_EQ(-9, -9 % 10); |
---|
209 | EXPECT_EQ( 0, -10 % 10); |
---|
210 | EXPECT_EQ(-5, -15 % 10); |
---|
211 | } |
---|
212 | |
---|
213 | TEST(mod, ModFunction) |
---|
214 | { |
---|
215 | // zero |
---|
216 | EXPECT_EQ(0, mod(0, 10)); |
---|
217 | |
---|
218 | // positive |
---|
219 | EXPECT_EQ(1, mod( 1, 10)); |
---|
220 | EXPECT_EQ(5, mod( 5, 10)); |
---|
221 | EXPECT_EQ(9, mod( 9, 10)); |
---|
222 | EXPECT_EQ(0, mod(10, 10)); |
---|
223 | EXPECT_EQ(5, mod(15, 10)); |
---|
224 | |
---|
225 | // negative |
---|
226 | EXPECT_EQ(9, mod( -1, 10)); |
---|
227 | EXPECT_EQ(5, mod( -5, 10)); |
---|
228 | EXPECT_EQ(1, mod( -9, 10)); |
---|
229 | EXPECT_EQ(0, mod(-10, 10)); |
---|
230 | EXPECT_EQ(5, mod(-15, 10)); |
---|
231 | } |
---|
232 | |
---|
233 | /////////////// |
---|
234 | // zeroise() // |
---|
235 | /////////////// |
---|
236 | TEST(zeroise, Test) |
---|
237 | { |
---|
238 | EXPECT_EQ(0, zeroise<int>()); |
---|
239 | EXPECT_EQ((unsigned int)0, zeroise<unsigned int>()); |
---|
240 | EXPECT_DOUBLE_EQ(0.0, zeroise<double>()); |
---|
241 | EXPECT_EQ("", zeroise<std::string>()); |
---|
242 | // EXPECT_EQ(Vector3::ZERO, zeroise<Vector3>()); |
---|
243 | } |
---|
244 | |
---|
245 | /////////////////// |
---|
246 | // interpolate() // |
---|
247 | /////////////////// |
---|
248 | TEST(interpolate, Linear) |
---|
249 | { |
---|
250 | EXPECT_EQ( 0, interpolate(0.00f, 0, 20)); |
---|
251 | EXPECT_EQ( 5, interpolate(0.25f, 0, 20)); |
---|
252 | EXPECT_EQ(10, interpolate(0.50f, 0, 20)); |
---|
253 | EXPECT_EQ(15, interpolate(0.75f, 0, 20)); |
---|
254 | EXPECT_EQ(20, interpolate(1.00f, 0, 20)); |
---|
255 | } |
---|
256 | |
---|
257 | TEST(interpolate, Smooth) |
---|
258 | { |
---|
259 | EXPECT_EQ( 0, interpolateSmooth(0.00f, 0, 20)); |
---|
260 | EXPECT_GT( 5, interpolateSmooth(0.25f, 0, 20)); |
---|
261 | EXPECT_EQ(10, interpolateSmooth(0.50f, 0, 20)); |
---|
262 | EXPECT_LT(15, interpolateSmooth(0.75f, 0, 20)); |
---|
263 | EXPECT_EQ(20, interpolateSmooth(1.00f, 0, 20)); |
---|
264 | } |
---|
265 | |
---|
266 | /////////// |
---|
267 | // rnd() // |
---|
268 | /////////// |
---|
269 | TEST(rnd, Default) |
---|
270 | { |
---|
271 | // how to test randomness? |
---|
272 | std::set<float> numbers; |
---|
273 | |
---|
274 | const float max = 1.0; |
---|
275 | const float min = 0.0; |
---|
276 | const size_t iterations = 1000; |
---|
277 | |
---|
278 | for (size_t i = 0; i < iterations; ++i) |
---|
279 | numbers.insert(rnd()); |
---|
280 | |
---|
281 | // must have at most <iterations> numbers in the set |
---|
282 | EXPECT_GE(iterations, numbers.size()); |
---|
283 | |
---|
284 | // all numbers must satisfy 0 <= <number> < 1 |
---|
285 | for (std::set<float>::iterator it = numbers.begin(); it != numbers.end(); ++it) |
---|
286 | { |
---|
287 | EXPECT_LE(min, *it); |
---|
288 | EXPECT_GT(max, *it); |
---|
289 | } |
---|
290 | } |
---|
291 | |
---|
292 | TEST(rnd, Max) |
---|
293 | { |
---|
294 | // how to test randomness? |
---|
295 | std::set<float> numbers; |
---|
296 | |
---|
297 | const float max = 10.0; |
---|
298 | const float min = 0.0; |
---|
299 | const size_t iterations = 1000; |
---|
300 | |
---|
301 | for (size_t i = 0; i < iterations; ++i) |
---|
302 | numbers.insert(rnd(max)); |
---|
303 | |
---|
304 | // must have at most <iterations> numbers in the set |
---|
305 | EXPECT_GE(iterations, numbers.size()); |
---|
306 | |
---|
307 | // all numbers must satisfy 0 <= <number> < <max> |
---|
308 | for (std::set<float>::iterator it = numbers.begin(); it != numbers.end(); ++it) |
---|
309 | { |
---|
310 | EXPECT_LE(min, *it); |
---|
311 | EXPECT_GT(max, *it); |
---|
312 | } |
---|
313 | } |
---|
314 | |
---|
315 | TEST(rnd, MinMax) |
---|
316 | { |
---|
317 | // how to test randomness? |
---|
318 | std::set<float> numbers; |
---|
319 | |
---|
320 | const float max = 10.0; |
---|
321 | const float min = 5.0; |
---|
322 | const size_t iterations = 1000; |
---|
323 | |
---|
324 | for (size_t i = 0; i < iterations; ++i) |
---|
325 | numbers.insert(rnd(min, max)); |
---|
326 | |
---|
327 | // must have at most <iterations> numbers in the set |
---|
328 | EXPECT_GE(iterations, numbers.size()); |
---|
329 | |
---|
330 | // all numbers must satisfy <min> <= <number> < <max> |
---|
331 | for (std::set<float>::iterator it = numbers.begin(); it != numbers.end(); ++it) |
---|
332 | { |
---|
333 | EXPECT_LE(min, *it); |
---|
334 | EXPECT_GT(max, *it); |
---|
335 | } |
---|
336 | } |
---|
337 | |
---|
338 | ////////////// |
---|
339 | // rndsgn() // |
---|
340 | ////////////// |
---|
341 | TEST(rndsgn, Test) |
---|
342 | { |
---|
343 | // how to test randomness? |
---|
344 | std::set<float> numbers; |
---|
345 | |
---|
346 | const size_t iterations = 100; |
---|
347 | |
---|
348 | for (size_t i = 0; i < iterations; ++i) |
---|
349 | numbers.insert(rndsgn()); |
---|
350 | |
---|
351 | // must have at most 2 numbers in the set |
---|
352 | EXPECT_GE((size_t)2, numbers.size()); |
---|
353 | |
---|
354 | // all numbers must be either 1 oder -1 |
---|
355 | for (std::set<float>::iterator it = numbers.begin(); it != numbers.end(); ++it) |
---|
356 | EXPECT_TRUE(*it == 1 || *it == -1); |
---|
357 | } |
---|
358 | |
---|
359 | /////////////////////// |
---|
360 | // getUniqueNumber() // |
---|
361 | /////////////////////// |
---|
362 | TEST(getUniqueNumber, Test) |
---|
363 | { |
---|
364 | std::set<float> numbers; |
---|
365 | |
---|
366 | const size_t iterations = 1000; |
---|
367 | |
---|
368 | for (size_t i = 0; i < iterations; ++i) |
---|
369 | numbers.insert(getUniqueNumber()); |
---|
370 | |
---|
371 | // must have exactly <iterations> numbers in the set, since all numbers should be unique |
---|
372 | EXPECT_EQ(iterations, numbers.size()); |
---|
373 | } |
---|
374 | /* |
---|
375 | getAngle |
---|
376 | get2DViewdirection |
---|
377 | get2DViewcoordinates |
---|
378 | getPredictedPosition |
---|
379 | */ |
---|
380 | } |
---|