unittest_psen_scan_internal_angle.cpp
Go to the documentation of this file.
1 // Copyright (c) 2020 Pilz GmbH & Co. KG
2 //
3 // This program is free software: you can redistribute it and/or modify
4 // it under the terms of the GNU Lesser General Public License as published by
5 // the Free Software Foundation, either version 3 of the License, or
6 // (at your option) any later version.
7 //
8 // This program is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 // GNU Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public License
14 // along with this program. If not, see <https://www.gnu.org/licenses/>.
15 
16 #include <gtest/gtest.h>
17 #include <limits>
18 #include <random>
19 
20 #include <psen_scan/psen_scan_internal_angle.h>
21 
22 using namespace psen_scan;
23 
24 TEST(DegreeTest, copy_constructor)
25 {
26  Degree deg1(2.);
27  Degree deg2 = deg1;
28 
29  EXPECT_EQ(static_cast<double>(deg1), 2.);
30  EXPECT_EQ(static_cast<double>(deg2), 2.);
31  EXPECT_EQ(deg1, deg2);
32 }
33 
34 TEST(DegreeTest, double_constructor)
35 {
36  Degree deg(0.);
37  EXPECT_EQ(static_cast<double>(deg), 0.);
38 
39  deg = Degree(std::numeric_limits<double>::max());
40  EXPECT_EQ(static_cast<double>(deg), std::numeric_limits<double>::max());
41 
42  deg = Degree(std::numeric_limits<double>::lowest());
43  EXPECT_EQ(static_cast<double>(deg), std::numeric_limits<double>::lowest());
44 }
45 
46 TEST(DegreeTest, psen_scan_internal_angle_constructor)
47 {
48  Degree deg(PSENscanInternalAngle(0));
49  EXPECT_EQ(static_cast<double>(deg), 0.);
50 
51  deg = Degree(PSENscanInternalAngle(-1));
52  EXPECT_EQ(static_cast<double>(deg), -0.1);
53 
54  deg = Degree(PSENscanInternalAngle(2));
55  EXPECT_EQ(static_cast<double>(deg), 0.2);
56 
57  deg = Degree(PSENscanInternalAngle(1776));
58  EXPECT_EQ(static_cast<double>(deg), 177.6);
59 
60  deg = Degree(PSENscanInternalAngle(std::numeric_limits<int>::max()));
61  EXPECT_EQ(static_cast<double>(deg), std::numeric_limits<int>::max() / 10.);
62 
63  deg = Degree(PSENscanInternalAngle(std::numeric_limits<int>::lowest()));
64  EXPECT_EQ(static_cast<double>(deg), std::numeric_limits<int>::lowest() / 10.);
65 }
66 
67 TEST(DegreeTest, operator_smaller_than)
68 {
69  Degree deg_neg_l(-100.);
70  Degree deg_neg_s(-1.);
71  Degree deg_zero(0.);
72  Degree deg_pos_s(1.);
73  Degree deg_pos_l(100.);
74 
75  EXPECT_EQ(deg_neg_l < deg_neg_l, false);
76  EXPECT_EQ(deg_neg_l < deg_neg_s, true);
77  EXPECT_EQ(deg_neg_l < deg_zero, true);
78  EXPECT_EQ(deg_neg_l < deg_pos_s, true);
79  EXPECT_EQ(deg_neg_l < deg_pos_l, true);
80 
81  EXPECT_EQ(deg_neg_s < deg_neg_l, false);
82  EXPECT_EQ(deg_neg_s < deg_neg_s, false);
83  EXPECT_EQ(deg_neg_s < deg_zero, true);
84  EXPECT_EQ(deg_neg_s < deg_pos_s, true);
85  EXPECT_EQ(deg_neg_s < deg_pos_l, true);
86 
87  EXPECT_EQ(deg_zero < deg_neg_l, false);
88  EXPECT_EQ(deg_zero < deg_neg_s, false);
89  EXPECT_EQ(deg_zero < deg_zero, false);
90  EXPECT_EQ(deg_zero < deg_pos_s, true);
91  EXPECT_EQ(deg_zero < deg_pos_l, true);
92 
93  EXPECT_EQ(deg_pos_s < deg_neg_l, false);
94  EXPECT_EQ(deg_pos_s < deg_neg_s, false);
95  EXPECT_EQ(deg_pos_s < deg_zero, false);
96  EXPECT_EQ(deg_pos_s < deg_pos_s, false);
97  EXPECT_EQ(deg_pos_s < deg_pos_l, true);
98 
99  EXPECT_EQ(deg_pos_l < deg_neg_l, false);
100  EXPECT_EQ(deg_pos_l < deg_neg_s, false);
101  EXPECT_EQ(deg_pos_l < deg_zero, false);
102  EXPECT_EQ(deg_pos_l < deg_pos_s, false);
103  EXPECT_EQ(deg_pos_l < deg_pos_l, false);
104 }
105 
106 TEST(DegreeTest, operator_greater_than)
107 {
108  Degree deg_neg_l(-100.);
109  Degree deg_neg_s(-1.);
110  Degree deg_zero(0.);
111  Degree deg_pos_s(1.);
112  Degree deg_pos_l(100.);
113 
114  EXPECT_EQ(deg_neg_l > deg_neg_l, false);
115  EXPECT_EQ(deg_neg_l > deg_neg_s, false);
116  EXPECT_EQ(deg_neg_l > deg_zero, false);
117  EXPECT_EQ(deg_neg_l > deg_pos_s, false);
118  EXPECT_EQ(deg_neg_l > deg_pos_l, false);
119 
120  EXPECT_EQ(deg_neg_s > deg_neg_l, true);
121  EXPECT_EQ(deg_neg_s > deg_neg_s, false);
122  EXPECT_EQ(deg_neg_s > deg_zero, false);
123  EXPECT_EQ(deg_neg_s > deg_pos_s, false);
124  EXPECT_EQ(deg_neg_s > deg_pos_l, false);
125 
126  EXPECT_EQ(deg_zero > deg_neg_l, true);
127  EXPECT_EQ(deg_zero > deg_neg_s, true);
128  EXPECT_EQ(deg_zero > deg_zero, false);
129  EXPECT_EQ(deg_zero > deg_pos_s, false);
130  EXPECT_EQ(deg_zero > deg_pos_l, false);
131 
132  EXPECT_EQ(deg_pos_s > deg_neg_l, true);
133  EXPECT_EQ(deg_pos_s > deg_neg_s, true);
134  EXPECT_EQ(deg_pos_s > deg_zero, true);
135  EXPECT_EQ(deg_pos_s > deg_pos_s, false);
136  EXPECT_EQ(deg_pos_s > deg_pos_l, false);
137 
138  EXPECT_EQ(deg_pos_l > deg_neg_l, true);
139  EXPECT_EQ(deg_pos_l > deg_neg_s, true);
140  EXPECT_EQ(deg_pos_l > deg_zero, true);
141  EXPECT_EQ(deg_pos_l > deg_pos_s, true);
142  EXPECT_EQ(deg_pos_l > deg_pos_l, false);
143 }
144 
145 TEST(DegreeTest, operator_is_equal)
146 {
147  Degree deg_neg(-100.);
148  Degree deg_zero(0.);
149  Degree deg_pos(100.);
150 
151  EXPECT_EQ(deg_neg == deg_neg, true);
152  EXPECT_EQ(deg_neg == deg_zero, false);
153  EXPECT_EQ(deg_neg == deg_pos, false);
154 
155  EXPECT_EQ(deg_zero == deg_neg, false);
156  EXPECT_EQ(deg_zero == deg_zero, true);
157  EXPECT_EQ(deg_zero == deg_pos, false);
158 
159  EXPECT_EQ(deg_pos == deg_neg, false);
160  EXPECT_EQ(deg_pos == deg_zero, false);
161  EXPECT_EQ(deg_pos == deg_pos, true);
162 }
163 
164 TEST(DegreeTest, operator_multiplication_assignment)
165 {
166  std::srand(1);
167 
168  for (int i = 0; i < 1000; i++)
169  {
170  double factor1 = (static_cast<double>(std::rand()) - static_cast<double>(RAND_MAX) / 2.) / 10000.;
171  double factor2 = (static_cast<double>(std::rand()) - static_cast<double>(RAND_MAX) / 2.) / 10000.;
172  double product = factor1 * factor2;
173  Degree multiplicand(factor1);
174  ASSERT_EQ(static_cast<double>(multiplicand), factor1);
175  multiplicand *= factor2;
176  EXPECT_EQ(static_cast<double>(multiplicand), product);
177  multiplicand *= -1.;
178  EXPECT_EQ(static_cast<double>(multiplicand), -product);
179  multiplicand *= 1.;
180  EXPECT_EQ(static_cast<double>(multiplicand), -product);
181  multiplicand *= 0.;
182  EXPECT_EQ(static_cast<double>(multiplicand), 0.);
183  }
184 
185  for (int i = 0; i < 1000; i++)
186  {
187  Degree multiplicand_neg_unit(-1.);
188  Degree multiplicand_zero(0.);
189  Degree multiplicand_pos_unit(1.);
190 
191  double multiplicator = (static_cast<double>(std::rand()) - static_cast<double>(RAND_MAX) / 2.) / 10000.;
192  multiplicand_neg_unit *= multiplicator;
193  EXPECT_EQ(static_cast<double>(multiplicand_neg_unit), -multiplicator);
194  multiplicand_pos_unit *= multiplicator;
195  EXPECT_EQ(static_cast<double>(multiplicand_pos_unit), multiplicator);
196  multiplicand_zero *= multiplicator;
197  EXPECT_EQ(static_cast<double>(multiplicand_zero), 0.);
198  }
199 }
200 
201 TEST(DegreeTest, operator_multiplication)
202 {
203  std::srand(1);
204 
205  for (int i = 0; i < 1000; i++)
206  {
207  double factor1 = (static_cast<double>(std::rand()) - static_cast<double>(RAND_MAX) / 2.) / 10000.;
208  double factor2 = (static_cast<double>(std::rand()) - static_cast<double>(RAND_MAX) / 2.) / 10000.;
209  double product = factor1 * factor2;
210  Degree multiplicand(factor1);
211  ASSERT_EQ(static_cast<double>(multiplicand), factor1);
212  EXPECT_EQ(static_cast<double>(multiplicand * factor2), product);
213  EXPECT_EQ(multiplicand * -1., -multiplicand);
214  EXPECT_EQ(multiplicand * 1., multiplicand);
215  EXPECT_EQ(static_cast<double>(multiplicand * 0.), 0.);
216  }
217 
218  Degree multiplicand_neg_unit(-1.);
219  Degree multiplicand_zero(0.);
220  Degree multiplicand_pos_unit(1.);
221 
222  for (int i = 0; i < 1000; i++)
223  {
224  double multiplicator = (static_cast<double>(std::rand()) - static_cast<double>(RAND_MAX) / 2.) / 10000.;
225  EXPECT_EQ(static_cast<double>(multiplicand_neg_unit * multiplicator), -multiplicator);
226  EXPECT_EQ(static_cast<double>(multiplicand_pos_unit * multiplicator), multiplicator);
227  EXPECT_EQ(static_cast<double>(multiplicand_zero * multiplicator), 0.);
228  }
229 }
230 
231 TEST(DegreeTest, operator_minus_assignment)
232 {
233  std::srand(1);
234 
235  for (int i = 0; i < 1000; i++)
236  {
237  double minuend_temp = (static_cast<double>(std::rand()) - static_cast<double>(RAND_MAX) / 2.) / 10000.;
238  double subtrahend_temp = (static_cast<double>(std::rand()) - static_cast<double>(RAND_MAX) / 2.) / 10000.;
239  double difference = minuend_temp - subtrahend_temp;
240  Degree minuend(minuend_temp);
241  Degree subtrahend(subtrahend_temp);
242  ASSERT_EQ(static_cast<double>(minuend), minuend_temp);
243  ASSERT_EQ(static_cast<double>(subtrahend), subtrahend_temp);
244  minuend -= subtrahend;
245  EXPECT_EQ(static_cast<double>(minuend), difference);
246  minuend -= Degree(0);
247  EXPECT_EQ(minuend, minuend);
248  }
249 }
250 
251 TEST(DegreeTest, operator_minus)
252 {
253  std::srand(1);
254 
255  for (int i = 0; i < 1000; i++)
256  {
257  double minuend_temp = (static_cast<double>(std::rand()) - static_cast<double>(RAND_MAX) / 2.) / 10000.;
258  double subtrahend_temp = (static_cast<double>(std::rand()) - static_cast<double>(RAND_MAX) / 2.) / 10000.;
259  double difference = minuend_temp - subtrahend_temp;
260  Degree minuend(minuend_temp);
261  Degree subtrahend(subtrahend_temp);
262  ASSERT_EQ(static_cast<double>(minuend), minuend_temp);
263  ASSERT_EQ(static_cast<double>(subtrahend), subtrahend_temp);
264  EXPECT_EQ(static_cast<double>(minuend - subtrahend), difference);
265  EXPECT_EQ(minuend - Degree(0), minuend);
266  EXPECT_EQ(Degree(0) - subtrahend, -subtrahend);
267  }
268 }
269 
270 TEST(DegreeTest, operator_unary_minus)
271 {
272  std::srand(1);
273 
274  for (int i = 0; i < 1000; i++)
275  {
276  double temp = (static_cast<double>(std::rand()) - static_cast<double>(RAND_MAX) / 2.) / 10000.;
277  Degree deg(temp);
278  ASSERT_EQ(static_cast<double>(deg), temp);
279  EXPECT_EQ(static_cast<double>(-deg), -temp);
280  }
281 }
282 
283 TEST(DegreeTest, operator_assignment)
284 {
285  std::srand(1);
286 
287  for (int i = 0; i < 1000; i++)
288  {
289  double temp1 = (static_cast<double>(std::rand()) - static_cast<double>(RAND_MAX) / 2.) / 10000.;
290  double temp2 = (static_cast<double>(std::rand()) - static_cast<double>(RAND_MAX) / 2.) / 10000.;
291  Degree deg1(temp1);
292  Degree deg2(temp2);
293  ASSERT_EQ(static_cast<double>(deg1), temp1);
294  ASSERT_EQ(static_cast<double>(deg2), temp2);
295  deg1 = deg2;
296  EXPECT_EQ(deg1, deg2);
297  }
298 }
299 
300 TEST(DegreeTest, operator_stream)
301 {
302  std::stringstream expected_string;
303  expected_string << "123";
304 
305  std::stringstream ss;
306  ss << Degree(123);
307 
308  EXPECT_EQ(ss.str(), expected_string.str());
309 
310  expected_string.str(std::string());
311  expected_string << "1.23";
312 
313  ss.str(std::string());
314  ss << Degree(1.23);
315 
316  EXPECT_EQ(ss.str(), expected_string.str());
317 }
318 
319 TEST(PSENscanInternalAngleTest, copy_constructor)
320 {
321  PSENscanInternalAngle deg(1);
322 
323  ASSERT_EQ(static_cast<int>(deg), 1);
324  deg = PSENscanInternalAngle(2);
325  ASSERT_EQ(static_cast<int>(deg), 2);
326 }
327 
328 TEST(PSENscanInternalAngleTest, int_constructor)
329 {
330  PSENscanInternalAngle deg_min(std::numeric_limits<int>::lowest());
331  PSENscanInternalAngle deg_neg(-100);
332  PSENscanInternalAngle deg_zero(0);
333  PSENscanInternalAngle deg_pos(100);
334  PSENscanInternalAngle deg_max(std::numeric_limits<int>::max());
335 
336  EXPECT_EQ(static_cast<int>(deg_min), std::numeric_limits<int>::lowest());
337  EXPECT_EQ(static_cast<int>(deg_neg), -100);
338  EXPECT_EQ(static_cast<int>(deg_zero), 0);
339  EXPECT_EQ(static_cast<int>(deg_pos), 100);
340  EXPECT_EQ(static_cast<int>(deg_max), std::numeric_limits<int>::max());
341 }
342 
343 TEST(PSENscanInternalAngleTest, degree_constructor)
344 {
345  EXPECT_ANY_THROW(PSENscanInternalAngle deg_double_min((Degree(std::numeric_limits<double>::lowest()))));
346  EXPECT_ANY_THROW(PSENscanInternalAngle deg_int_min((Degree(std::numeric_limits<int>::lowest()))));
347  PSENscanInternalAngle deg_neg(Degree(-100));
348  PSENscanInternalAngle deg_zero(Degree(0));
349  PSENscanInternalAngle deg_pos(Degree(100));
350  EXPECT_ANY_THROW(PSENscanInternalAngle deg_int_max((Degree(std::numeric_limits<int>::max()))));
351  EXPECT_ANY_THROW(PSENscanInternalAngle deg_double_max((Degree(std::numeric_limits<double>::max()))));
352 
353  EXPECT_EQ(static_cast<int>(deg_neg), -1000);
354  EXPECT_EQ(static_cast<int>(deg_zero), 0);
355  EXPECT_EQ(static_cast<int>(deg_pos), 1000);
356 }
357 
358 TEST(PSENscanInternalAngleTest, operator_smaller_than)
359 {
360  PSENscanInternalAngle deg_neg_l(-100);
361  PSENscanInternalAngle deg_neg_s(-1);
362  PSENscanInternalAngle deg_zero(0);
363  PSENscanInternalAngle deg_pos_s(1);
364  PSENscanInternalAngle deg_pos_l(100);
365 
366  EXPECT_EQ(deg_neg_l < deg_neg_l, false);
367  EXPECT_EQ(deg_neg_l < deg_neg_s, true);
368  EXPECT_EQ(deg_neg_l < deg_zero, true);
369  EXPECT_EQ(deg_neg_l < deg_pos_s, true);
370  EXPECT_EQ(deg_neg_l < deg_pos_l, true);
371 
372  EXPECT_EQ(deg_neg_s < deg_neg_l, false);
373  EXPECT_EQ(deg_neg_s < deg_neg_s, false);
374  EXPECT_EQ(deg_neg_s < deg_zero, true);
375  EXPECT_EQ(deg_neg_s < deg_pos_s, true);
376  EXPECT_EQ(deg_neg_s < deg_pos_l, true);
377 
378  EXPECT_EQ(deg_zero < deg_neg_l, false);
379  EXPECT_EQ(deg_zero < deg_neg_s, false);
380  EXPECT_EQ(deg_zero < deg_zero, false);
381  EXPECT_EQ(deg_zero < deg_pos_s, true);
382  EXPECT_EQ(deg_zero < deg_pos_l, true);
383 
384  EXPECT_EQ(deg_pos_s < deg_neg_l, false);
385  EXPECT_EQ(deg_pos_s < deg_neg_s, false);
386  EXPECT_EQ(deg_pos_s < deg_zero, false);
387  EXPECT_EQ(deg_pos_s < deg_pos_s, false);
388  EXPECT_EQ(deg_pos_s < deg_pos_l, true);
389 
390  EXPECT_EQ(deg_pos_l < deg_neg_l, false);
391  EXPECT_EQ(deg_pos_l < deg_neg_s, false);
392  EXPECT_EQ(deg_pos_l < deg_zero, false);
393  EXPECT_EQ(deg_pos_l < deg_pos_s, false);
394  EXPECT_EQ(deg_pos_l < deg_pos_l, false);
395 }
396 
397 TEST(PSENscanInternalAngleTest, operator_greater_than)
398 {
399  PSENscanInternalAngle deg_neg_l(-100);
400  PSENscanInternalAngle deg_neg_s(-1);
401  PSENscanInternalAngle deg_zero(0);
402  PSENscanInternalAngle deg_pos_s(1);
403  PSENscanInternalAngle deg_pos_l(100);
404 
405  EXPECT_EQ(deg_neg_l > deg_neg_l, false);
406  EXPECT_EQ(deg_neg_l > deg_neg_s, false);
407  EXPECT_EQ(deg_neg_l > deg_zero, false);
408  EXPECT_EQ(deg_neg_l > deg_pos_s, false);
409  EXPECT_EQ(deg_neg_l > deg_pos_l, false);
410 
411  EXPECT_EQ(deg_neg_s > deg_neg_l, true);
412  EXPECT_EQ(deg_neg_s > deg_neg_s, false);
413  EXPECT_EQ(deg_neg_s > deg_zero, false);
414  EXPECT_EQ(deg_neg_s > deg_pos_s, false);
415  EXPECT_EQ(deg_neg_s > deg_pos_l, false);
416 
417  EXPECT_EQ(deg_zero > deg_neg_l, true);
418  EXPECT_EQ(deg_zero > deg_neg_s, true);
419  EXPECT_EQ(deg_zero > deg_zero, false);
420  EXPECT_EQ(deg_zero > deg_pos_s, false);
421  EXPECT_EQ(deg_zero > deg_pos_l, false);
422 
423  EXPECT_EQ(deg_pos_s > deg_neg_l, true);
424  EXPECT_EQ(deg_pos_s > deg_neg_s, true);
425  EXPECT_EQ(deg_pos_s > deg_zero, true);
426  EXPECT_EQ(deg_pos_s > deg_pos_s, false);
427  EXPECT_EQ(deg_pos_s > deg_pos_l, false);
428 
429  EXPECT_EQ(deg_pos_l > deg_neg_l, true);
430  EXPECT_EQ(deg_pos_l > deg_neg_s, true);
431  EXPECT_EQ(deg_pos_l > deg_zero, true);
432  EXPECT_EQ(deg_pos_l > deg_pos_s, true);
433  EXPECT_EQ(deg_pos_l > deg_pos_l, false);
434 }
435 
436 TEST(PSENscanInternalAngleTest, operator_smaller_than_or_equal)
437 {
438  PSENscanInternalAngle deg_neg_l(-100);
439  PSENscanInternalAngle deg_neg_s(-1);
440  PSENscanInternalAngle deg_zero(0);
441  PSENscanInternalAngle deg_pos_s(1);
442  PSENscanInternalAngle deg_pos_l(100);
443 
444  EXPECT_EQ(deg_neg_l <= deg_neg_l, true);
445  EXPECT_EQ(deg_neg_l <= deg_neg_s, true);
446  EXPECT_EQ(deg_neg_l <= deg_zero, true);
447  EXPECT_EQ(deg_neg_l <= deg_pos_s, true);
448  EXPECT_EQ(deg_neg_l <= deg_pos_l, true);
449 
450  EXPECT_EQ(deg_neg_s <= deg_neg_l, false);
451  EXPECT_EQ(deg_neg_s <= deg_neg_s, true);
452  EXPECT_EQ(deg_neg_s <= deg_zero, true);
453  EXPECT_EQ(deg_neg_s <= deg_pos_s, true);
454  EXPECT_EQ(deg_neg_s <= deg_pos_l, true);
455 
456  EXPECT_EQ(deg_zero <= deg_neg_l, false);
457  EXPECT_EQ(deg_zero <= deg_neg_s, false);
458  EXPECT_EQ(deg_zero <= deg_zero, true);
459  EXPECT_EQ(deg_zero <= deg_pos_s, true);
460  EXPECT_EQ(deg_zero <= deg_pos_l, true);
461 
462  EXPECT_EQ(deg_pos_s <= deg_neg_l, false);
463  EXPECT_EQ(deg_pos_s <= deg_neg_s, false);
464  EXPECT_EQ(deg_pos_s <= deg_zero, false);
465  EXPECT_EQ(deg_pos_s <= deg_pos_s, true);
466  EXPECT_EQ(deg_pos_s <= deg_pos_l, true);
467 
468  EXPECT_EQ(deg_pos_l <= deg_neg_l, false);
469  EXPECT_EQ(deg_pos_l <= deg_neg_s, false);
470  EXPECT_EQ(deg_pos_l <= deg_zero, false);
471  EXPECT_EQ(deg_pos_l <= deg_pos_s, false);
472  EXPECT_EQ(deg_pos_l <= deg_pos_l, true);
473 }
474 
475 TEST(PSENscanInternalAngleTest, operator_greater_than_or_equal)
476 {
477  PSENscanInternalAngle deg_neg_l(-100);
478  PSENscanInternalAngle deg_neg_s(-1);
479  PSENscanInternalAngle deg_zero(0);
480  PSENscanInternalAngle deg_pos_s(1);
481  PSENscanInternalAngle deg_pos_l(100);
482 
483  EXPECT_EQ(deg_neg_l >= deg_neg_l, true);
484  EXPECT_EQ(deg_neg_l >= deg_neg_s, false);
485  EXPECT_EQ(deg_neg_l >= deg_zero, false);
486  EXPECT_EQ(deg_neg_l >= deg_pos_s, false);
487  EXPECT_EQ(deg_neg_l >= deg_pos_l, false);
488 
489  EXPECT_EQ(deg_neg_s >= deg_neg_l, true);
490  EXPECT_EQ(deg_neg_s >= deg_neg_s, true);
491  EXPECT_EQ(deg_neg_s >= deg_zero, false);
492  EXPECT_EQ(deg_neg_s >= deg_pos_s, false);
493  EXPECT_EQ(deg_neg_s >= deg_pos_l, false);
494 
495  EXPECT_EQ(deg_zero >= deg_neg_l, true);
496  EXPECT_EQ(deg_zero >= deg_neg_s, true);
497  EXPECT_EQ(deg_zero >= deg_zero, true);
498  EXPECT_EQ(deg_zero >= deg_pos_s, false);
499  EXPECT_EQ(deg_zero >= deg_pos_l, false);
500 
501  EXPECT_EQ(deg_pos_s >= deg_neg_l, true);
502  EXPECT_EQ(deg_pos_s >= deg_neg_s, true);
503  EXPECT_EQ(deg_pos_s >= deg_zero, true);
504  EXPECT_EQ(deg_pos_s >= deg_pos_s, true);
505  EXPECT_EQ(deg_pos_s >= deg_pos_l, false);
506 
507  EXPECT_EQ(deg_pos_l >= deg_neg_l, true);
508  EXPECT_EQ(deg_pos_l >= deg_neg_s, true);
509  EXPECT_EQ(deg_pos_l >= deg_zero, true);
510  EXPECT_EQ(deg_pos_l >= deg_pos_s, true);
511  EXPECT_EQ(deg_pos_l >= deg_pos_l, true);
512 }
513 
514 TEST(PSENscanInternalAngleTest, operator_is_equal)
515 {
516  PSENscanInternalAngle deg_neg(-100);
517  PSENscanInternalAngle deg_zero(0);
518  PSENscanInternalAngle deg_pos(100);
519 
520  EXPECT_EQ(deg_neg == deg_neg, true);
521  EXPECT_EQ(deg_neg == deg_zero, false);
522  EXPECT_EQ(deg_neg == deg_pos, false);
523 
524  EXPECT_EQ(deg_zero == deg_neg, false);
525  EXPECT_EQ(deg_zero == deg_zero, true);
526  EXPECT_EQ(deg_zero == deg_pos, false);
527 
528  EXPECT_EQ(deg_pos == deg_neg, false);
529  EXPECT_EQ(deg_pos == deg_zero, false);
530  EXPECT_EQ(deg_pos == deg_pos, true);
531 }
532 
533 TEST(PSENscanInternalAngleTest, operator_is_not_equal)
534 {
535  PSENscanInternalAngle deg_neg(-100);
536  PSENscanInternalAngle deg_zero(0);
537  PSENscanInternalAngle deg_pos(100);
538 
539  EXPECT_EQ(deg_neg != deg_neg, false);
540  EXPECT_EQ(deg_neg != deg_zero, true);
541  EXPECT_EQ(deg_neg != deg_pos, true);
542 
543  EXPECT_EQ(deg_zero != deg_neg, true);
544  EXPECT_EQ(deg_zero != deg_zero, false);
545  EXPECT_EQ(deg_zero != deg_pos, true);
546 
547  EXPECT_EQ(deg_pos != deg_neg, true);
548  EXPECT_EQ(deg_pos != deg_zero, true);
549  EXPECT_EQ(deg_pos != deg_pos, false);
550 }
551 
552 TEST(PSENscanInternalAngleTest, operator_minus_assignment)
553 {
554  std::srand(1);
555 
556  for (int i = 0; i < 1000; i++)
557  {
558  int minuend_temp = std::rand() - RAND_MAX / 2;
559  int subtrahend_temp = std::rand() - RAND_MAX / 2;
560  int difference = minuend_temp - subtrahend_temp;
561  PSENscanInternalAngle minuend(minuend_temp);
562  PSENscanInternalAngle subtrahend(subtrahend_temp);
563  ASSERT_EQ(static_cast<int>(minuend), minuend_temp);
564  ASSERT_EQ(static_cast<int>(subtrahend), subtrahend_temp);
565  minuend -= subtrahend;
566  EXPECT_EQ(static_cast<int>(minuend), difference);
567  minuend -= PSENscanInternalAngle(0);
568  EXPECT_EQ(minuend, minuend);
569  }
570 }
571 
572 TEST(PSENscanInternalAngleTest, operator_minus)
573 {
574  std::srand(1);
575 
576  for (int i = 0; i < 1000; i++)
577  {
578  int minuend_temp = std::rand() - RAND_MAX / 2;
579  int subtrahend_temp = std::rand() - RAND_MAX / 2;
580  int difference = minuend_temp - subtrahend_temp;
581  PSENscanInternalAngle minuend(minuend_temp);
582  PSENscanInternalAngle subtrahend(subtrahend_temp);
583  ASSERT_EQ(static_cast<int>(minuend), minuend_temp);
584  ASSERT_EQ(static_cast<int>(subtrahend), subtrahend_temp);
585  EXPECT_EQ(static_cast<int>(minuend - subtrahend), difference);
586  EXPECT_EQ(minuend - PSENscanInternalAngle(0), minuend);
587  EXPECT_EQ(PSENscanInternalAngle(0) - subtrahend, -subtrahend);
588  }
589 }
590 
591 TEST(PSENscanInternalAngleTest, operator_plus_assignment)
592 {
593  std::srand(1);
594 
595  for (int i = 0; i < 1000; i++)
596  {
597  int augend_temp = std::rand() - RAND_MAX / 2;
598  int addend_temp = std::rand() - RAND_MAX / 2;
599  int sum = augend_temp + addend_temp;
600  PSENscanInternalAngle augend(augend_temp);
601  PSENscanInternalAngle addend(addend_temp);
602  ASSERT_EQ(static_cast<int>(augend), augend_temp);
603  ASSERT_EQ(static_cast<int>(addend), addend_temp);
604  augend += addend;
605  EXPECT_EQ(static_cast<int>(augend), sum);
606  augend += PSENscanInternalAngle(0);
607  EXPECT_EQ(augend, augend);
608  }
609 }
610 
611 TEST(PSENscanInternalAngleTest, operator_plus)
612 {
613  std::srand(1);
614 
615  for (int i = 0; i < 1000; i++)
616  {
617  int augend_temp = std::rand() - RAND_MAX / 2;
618  int addend_temp = std::rand() - RAND_MAX / 2;
619  int sum = augend_temp + addend_temp;
620  PSENscanInternalAngle augend(augend_temp);
621  PSENscanInternalAngle addend(addend_temp);
622  ASSERT_EQ(static_cast<int>(augend), augend_temp);
623  ASSERT_EQ(static_cast<int>(addend), addend_temp);
624  EXPECT_EQ(static_cast<int>(augend + addend), sum);
625  EXPECT_EQ(augend + PSENscanInternalAngle(0), augend);
626  EXPECT_EQ(PSENscanInternalAngle(0) + addend, addend);
627  }
628 }
629 
630 TEST(PSENscanInternalAngleTest, operator_assignment)
631 {
632  std::srand(1);
633 
634  for (int i = 0; i < 1000; i++)
635  {
636  double temp1 = std::rand() - RAND_MAX / 2;
637  double temp2 = std::rand() - RAND_MAX / 2;
638  PSENscanInternalAngle deg1(temp1);
639  PSENscanInternalAngle deg2(temp2);
640  ASSERT_EQ(static_cast<int>(deg1), temp1);
641  ASSERT_EQ(static_cast<int>(deg2), temp2);
642  deg1 = deg2;
643  EXPECT_EQ(deg1, deg2);
644  }
645 }
646 
647 TEST(PSENscanInternalAngleTest, operator_stream)
648 {
649  std::stringstream expected_string;
650  expected_string << "123";
651 
652  std::stringstream ss;
653  ss << PSENscanInternalAngle(123);
654 
655  EXPECT_EQ(ss.str(), expected_string.str());
656 }
psen_scan::Degree
Class to model angles in degrees from user&#39;s perspective.
Definition: psen_scan_internal_angle.h:29
TEST
TEST(DegreeTest, copy_constructor)
Definition: unittest_psen_scan_internal_angle.cpp:24
psen_scan_internal_angle.h
psen_scan::PSENscanInternalAngle
Class to model angles in PSENscan internal format (tenth of degrees)
Definition: psen_scan_internal_angle.h:55
psen_scan
Definition: build_ros_message_exception.h:21

psen_scan
Author(s):
autogenerated on Mon Feb 28 2022 23:16:20