Branch data Line data Source code
1 : : /*
2 : : * ----------------- BEGIN LICENSE BLOCK ---------------------------------
3 : : *
4 : : * Copyright (C) 2018-2021 Intel Corporation
5 : : *
6 : : * SPDX-License-Identifier: MIT
7 : : *
8 : : * ----------------- END LICENSE BLOCK -----------------------------------
9 : : */
10 : :
11 : : /*
12 : : * Generated file
13 : : */
14 : :
15 : : #if defined(__clang__) && (__clang_major__ >= 7)
16 : : #pragma GCC diagnostic push
17 : : #pragma GCC diagnostic ignored "-Wself-assign-overloaded"
18 : : #endif
19 : :
20 : : #include <gtest/gtest.h>
21 : : #include <limits>
22 : : #include "ad/map/point/ENUHeading.hpp"
23 : :
24 : 2 : TEST(ENUHeadingTests, defaultConstructionIsInvalid)
25 : : {
26 : 1 : ::ad::map::point::ENUHeading value;
27 [ - + - - : 1 : EXPECT_FALSE(value.isValid());
- - - - -
- ]
28 : 1 : }
29 : :
30 : 2 : TEST(ENUHeadingTests, precisionIsDefinedAsExpected)
31 : : {
32 [ + - - + : 1 : EXPECT_LT(0., ::ad::map::point::ENUHeading::cPrecisionValue);
- - - - -
- ]
33 [ + - - + : 1 : EXPECT_DOUBLE_EQ(0.0001, ::ad::map::point::ENUHeading::cPrecisionValue);
- - - - -
- ]
34 [ + - - + : 1 : EXPECT_DOUBLE_EQ(::ad::map::point::ENUHeading::cPrecisionValue,
- - - - -
- ]
35 : : static_cast<double>(::ad::map::point::ENUHeading::getPrecision()));
36 : 1 : }
37 : :
38 : 2 : TEST(ENUHeadingTests, minIsValid)
39 : : {
40 [ - + - - : 1 : EXPECT_TRUE(::ad::map::point::ENUHeading::getMin().isValid());
- - - - -
- ]
41 : 1 : }
42 : :
43 : 2 : TEST(ENUHeadingTests, aboveMinIsValid)
44 : : {
45 : 1 : ::ad::map::point::ENUHeading value(::ad::map::point::ENUHeading::cMinValue * 0.9);
46 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
47 : 1 : }
48 : :
49 : 2 : TEST(ENUHeadingTests, belowMinIsInvalid)
50 : : {
51 : 1 : ::ad::map::point::ENUHeading value(::ad::map::point::ENUHeading::cMinValue * 1.1);
52 [ - + - - : 1 : EXPECT_FALSE(value.isValid());
- - - - -
- ]
53 : 1 : }
54 : :
55 : 2 : TEST(ENUHeadingTests, maxIsValid)
56 : : {
57 [ - + - - : 1 : EXPECT_TRUE(::ad::map::point::ENUHeading::getMax().isValid());
- - - - -
- ]
58 : 1 : }
59 : :
60 : 2 : TEST(ENUHeadingTests, aboveMaxIsInvalid)
61 : : {
62 : 1 : ::ad::map::point::ENUHeading value(::ad::map::point::ENUHeading::cMaxValue * 1.1);
63 [ - + - - : 1 : EXPECT_FALSE(value.isValid());
- - - - -
- ]
64 : 1 : }
65 : :
66 : 2 : TEST(ENUHeadingTests, belowMaxIsValid)
67 : : {
68 : 1 : ::ad::map::point::ENUHeading value(::ad::map::point::ENUHeading::cMaxValue * 0.9);
69 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
70 : 1 : }
71 : :
72 : : #if (AD_MAP_POINT_ENUHEADING_THROWS_EXCEPTION == 1)
73 : 2 : TEST(ENUHeadingTests, ensureValidThrowsOnInvalid)
74 : : {
75 : 1 : ::ad::map::point::ENUHeading value;
76 [ + - + - : 2 : EXPECT_THROW(value.ensureValid(), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
77 : 1 : }
78 : :
79 : 2 : TEST(ENUHeadingTests, ensureValidNonZeroThrowsOnInvalid)
80 : : {
81 : 1 : ::ad::map::point::ENUHeading value;
82 [ + - + - : 2 : EXPECT_THROW(value.ensureValidNonZero(), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
83 : 1 : }
84 : :
85 : 2 : TEST(ENUHeadingTests, ensureValidNonZeroThrowsOnZero)
86 : : {
87 : 1 : ::ad::map::point::ENUHeading value(0.);
88 [ + - + - : 2 : EXPECT_THROW(value.ensureValidNonZero(), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
89 : 1 : }
90 : : #endif
91 : :
92 : 2 : TEST(ENUHeadingTestsStd, numericLimitsLowestIsMin)
93 : : {
94 [ + - - + : 1 : EXPECT_DOUBLE_EQ(static_cast<double>(::ad::map::point::ENUHeading::getMin()),
- - - - -
- ]
95 : : static_cast<double>(std::numeric_limits<::ad::map::point::ENUHeading>::lowest()));
96 : 1 : }
97 : :
98 : 2 : TEST(ENUHeadingTestsStd, numericLimitsMaxIsMax)
99 : : {
100 [ + - - + : 1 : EXPECT_DOUBLE_EQ(static_cast<double>(::ad::map::point::ENUHeading::getMax()),
- - - - -
- ]
101 : : static_cast<double>(std::numeric_limits<::ad::map::point::ENUHeading>::max()));
102 : 1 : }
103 : :
104 : 2 : TEST(ENUHeadingTestsStd, numericLimitsEpsilonIsPrecision)
105 : : {
106 [ + - - + : 1 : EXPECT_DOUBLE_EQ(static_cast<double>(::ad::map::point::ENUHeading::getPrecision()),
- - - - -
- ]
107 : : static_cast<double>(std::numeric_limits<::ad::map::point::ENUHeading>::epsilon()));
108 : 1 : }
109 : :
110 : 2 : TEST(ENUHeadingTestsStd, fabsIsWorkingCorrectly)
111 : : {
112 [ + - - + : 1 : EXPECT_DOUBLE_EQ(0., static_cast<double>(std::fabs(::ad::map::point::ENUHeading(-0.))));
- - - - -
- ]
113 [ + - - + : 1 : EXPECT_DOUBLE_EQ(1., static_cast<double>(std::fabs(::ad::map::point::ENUHeading(-1.))));
- - - - -
- ]
114 [ + - - + : 1 : EXPECT_DOUBLE_EQ(
- - - - -
- ]
115 : : ::ad::map::point::ENUHeading::cPrecisionValue,
116 : : static_cast<double>(std::fabs(::ad::map::point::ENUHeading(::ad::map::point::ENUHeading::cPrecisionValue))));
117 [ + - - + : 1 : EXPECT_DOUBLE_EQ(
- - - - -
- ]
118 : : std::fabs(::ad::map::point::ENUHeading::cMinValue),
119 : : static_cast<double>(std::fabs(::ad::map::point::ENUHeading(::ad::map::point::ENUHeading::cMinValue))));
120 [ + - - + : 1 : EXPECT_DOUBLE_EQ(
- - - - -
- ]
121 : : std::fabs(::ad::map::point::ENUHeading::cMinValue),
122 : : static_cast<double>(std::fabs(::ad::map::point::ENUHeading(-::ad::map::point::ENUHeading::cMinValue))));
123 [ + - - + : 1 : EXPECT_DOUBLE_EQ(
- - - - -
- ]
124 : : std::fabs(::ad::map::point::ENUHeading::cMaxValue),
125 : : static_cast<double>(std::fabs(::ad::map::point::ENUHeading(::ad::map::point::ENUHeading::cMaxValue))));
126 [ + - - + : 1 : EXPECT_DOUBLE_EQ(
- - - - -
- ]
127 : : std::fabs(::ad::map::point::ENUHeading::cMaxValue),
128 : : static_cast<double>(std::fabs(::ad::map::point::ENUHeading(-::ad::map::point::ENUHeading::cMaxValue))));
129 : 1 : }
130 : :
131 : 2 : TEST(ENUHeadingTests, constructionFromValidFPValue)
132 : : {
133 : 1 : double const validValue = ::ad::map::point::ENUHeading::cMinValue;
134 : 1 : ::ad::map::point::ENUHeading value(validValue);
135 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
136 [ + - - + : 1 : EXPECT_DOUBLE_EQ(validValue, static_cast<double>(value));
- - - - -
- ]
137 : 1 : }
138 : :
139 : 2 : TEST(ENUHeadingTests, copyConstructionFromValidValue)
140 : : {
141 : 1 : ::ad::map::point::ENUHeading const validValue(::ad::map::point::ENUHeading::cMinValue);
142 : 1 : ::ad::map::point::ENUHeading value(validValue);
143 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
144 [ + - - + : 1 : EXPECT_DOUBLE_EQ(static_cast<double>(validValue), static_cast<double>(value));
- - - - -
- ]
145 : 1 : }
146 : :
147 : 2 : TEST(ENUHeadingTests, moveConstructionFromValidValue)
148 : : {
149 : 1 : ::ad::map::point::ENUHeading validValue(::ad::map::point::ENUHeading::cMinValue);
150 : 1 : ::ad::map::point::ENUHeading value(std::move(validValue));
151 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
152 [ + - - + : 1 : EXPECT_DOUBLE_EQ(::ad::map::point::ENUHeading::cMinValue, static_cast<double>(value));
- - - - -
- ]
153 : 1 : }
154 : :
155 : 2 : TEST(ENUHeadingTests, assignmentFromValidValue)
156 : : {
157 : 1 : ::ad::map::point::ENUHeading const validValue(::ad::map::point::ENUHeading::cMinValue);
158 : 1 : ::ad::map::point::ENUHeading value;
159 : 1 : value = validValue;
160 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
161 [ + - - + : 1 : EXPECT_DOUBLE_EQ(static_cast<double>(validValue), static_cast<double>(value));
- - - - -
- ]
162 : 1 : }
163 : :
164 : 2 : TEST(ENUHeadingTests, moveAssignmentFromValidValue)
165 : : {
166 : 1 : ::ad::map::point::ENUHeading validValue(::ad::map::point::ENUHeading::cMinValue);
167 : 1 : ::ad::map::point::ENUHeading value;
168 : 1 : value = std::move(validValue);
169 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
170 [ + - - + : 1 : EXPECT_DOUBLE_EQ(::ad::map::point::ENUHeading::cMinValue, static_cast<double>(value));
- - - - -
- ]
171 : 1 : }
172 : :
173 : 2 : TEST(ENUHeadingTests, constructionFromInvalidFPValue)
174 : : {
175 : 1 : double const invalidValue = std::numeric_limits<double>::quiet_NaN();
176 : 1 : ::ad::map::point::ENUHeading value(invalidValue);
177 [ - + - - : 1 : EXPECT_FALSE(value.isValid());
- - - - -
- ]
178 : 1 : }
179 : :
180 : 2 : TEST(ENUHeadingTests, copyConstructionFromInvalidValue)
181 : : {
182 : 1 : ::ad::map::point::ENUHeading const invalidValue(std::numeric_limits<double>::quiet_NaN());
183 : 1 : ::ad::map::point::ENUHeading value(invalidValue);
184 [ - + - - : 1 : EXPECT_FALSE(value.isValid());
- - - - -
- ]
185 : 1 : }
186 : :
187 : 2 : TEST(ENUHeadingTests, assignmentFromInvalidValue)
188 : : {
189 : 1 : ::ad::map::point::ENUHeading const invalidValue(std::numeric_limits<double>::quiet_NaN());
190 : 1 : ::ad::map::point::ENUHeading value;
191 : 1 : value = invalidValue;
192 [ - + - - : 1 : EXPECT_FALSE(value.isValid());
- - - - -
- ]
193 : 1 : }
194 : :
195 : 2 : TEST(ENUHeadingTests, selfAssignment)
196 : : {
197 : 1 : ::ad::map::point::ENUHeading value(::ad::map::point::ENUHeading::cMinValue);
198 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
199 : 1 : value = value;
200 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
201 : 1 : }
202 : :
203 : 2 : TEST(ENUHeadingTests, ostreamOperatorTest)
204 : : {
205 [ + - ]: 1 : std::stringstream stream;
206 : 1 : ::ad::map::point::ENUHeading value;
207 [ + - ]: 1 : stream << value;
208 [ + - + - : 1 : ASSERT_GT(stream.str().size(), 0u);
- + - - -
- - - ]
209 : : }
210 : :
211 : : #if (AD_MAP_POINT_ENUHEADING_THROWS_EXCEPTION == 1)
212 : 2 : TEST(ENUHeadingTests, comparisonOperatorsThrowOnInvalid)
213 : : {
214 : 1 : ::ad::map::point::ENUHeading const value(::ad::map::point::ENUHeading::cMinValue);
215 : 1 : ::ad::map::point::ENUHeading const invalidValue;
216 : :
217 [ + - + - : 2 : EXPECT_THROW((void)(invalidValue == value), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
218 [ + - + - : 2 : EXPECT_THROW((void)(value == invalidValue), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
219 : :
220 [ + - + - : 2 : EXPECT_THROW((void)(invalidValue != value), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
221 [ + - + - : 2 : EXPECT_THROW((void)(value != invalidValue), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
222 : :
223 [ + - + - : 2 : EXPECT_THROW((void)(invalidValue > value), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
224 [ + - + - : 2 : EXPECT_THROW((void)(value > invalidValue), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
225 : :
226 [ + - + - : 2 : EXPECT_THROW((void)(invalidValue < value), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
227 [ + - + - : 2 : EXPECT_THROW((void)(value < invalidValue), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
228 : :
229 [ + - + - : 2 : EXPECT_THROW((void)(invalidValue >= value), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
230 [ + - + - : 2 : EXPECT_THROW((void)(value >= invalidValue), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
231 : :
232 [ + - + - : 2 : EXPECT_THROW((void)(invalidValue <= value), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
233 [ + - + - : 2 : EXPECT_THROW((void)(value <= invalidValue), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
234 : 1 : }
235 : :
236 : 2 : TEST(ENUHeadingTests, arithmeticOperatorsThrowOnInvalid)
237 : : {
238 : 1 : ::ad::map::point::ENUHeading const minimalValue(::ad::map::point::ENUHeading::cMinValue);
239 : 1 : ::ad::map::point::ENUHeading const maximalValue(::ad::map::point::ENUHeading::cMaxValue);
240 : 1 : ::ad::map::point::ENUHeading const invalidValue;
241 : 1 : ::ad::map::point::ENUHeading calculationValue;
242 : :
243 : : // operator+(::ad::map::point::ENUHeading)
244 [ + - + - : 2 : EXPECT_THROW(invalidValue + maximalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
245 [ + - + - : 2 : EXPECT_THROW(maximalValue + invalidValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
246 [ + - + - : 2 : EXPECT_THROW(maximalValue + maximalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
247 : :
248 : : // operator+=(::ad::map::point::ENUHeading)
249 : 1 : calculationValue = invalidValue;
250 [ + - + - : 2 : EXPECT_THROW(calculationValue += maximalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
251 : 1 : calculationValue = maximalValue;
252 [ + - + - : 2 : EXPECT_THROW(calculationValue += invalidValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
253 : 1 : calculationValue = maximalValue;
254 [ + - + - : 2 : EXPECT_THROW(calculationValue += maximalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
255 : :
256 : : // operator-(::ad::map::point::ENUHeading)
257 [ + - + - : 2 : EXPECT_THROW(invalidValue - minimalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
258 [ + - + - : 2 : EXPECT_THROW(minimalValue - invalidValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
259 [ + - + - : 2 : EXPECT_THROW(minimalValue - maximalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
260 : :
261 : : // operator-=(::ad::map::point::ENUHeading)
262 : 1 : calculationValue = invalidValue;
263 [ + - + - : 2 : EXPECT_THROW(calculationValue -= minimalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
264 : 1 : calculationValue = minimalValue;
265 [ + - + - : 2 : EXPECT_THROW(calculationValue -= invalidValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
266 : 1 : calculationValue = minimalValue;
267 [ + - + - : 2 : EXPECT_THROW(calculationValue -= maximalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
268 : :
269 : : // operator*(double)
270 [ + - + - : 2 : EXPECT_THROW(invalidValue * static_cast<double>(maximalValue), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
271 [ + - + - : 2 : EXPECT_THROW(maximalValue * static_cast<double>(maximalValue), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
272 : :
273 : : // operator/(double)
274 [ + - + - : 2 : EXPECT_THROW(invalidValue / static_cast<double>(maximalValue), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
275 [ + - + - : 2 : EXPECT_THROW(maximalValue / static_cast<double>(invalidValue), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
276 [ + - + - : 2 : EXPECT_THROW(maximalValue / 0.0, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
277 [ + - + - : 2 : EXPECT_THROW(maximalValue / 0.5, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
278 : :
279 : : // operator/(::ad::map::point::ENUHeading)
280 [ + - + - : 2 : EXPECT_THROW(invalidValue / maximalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
281 [ + - + - : 2 : EXPECT_THROW(maximalValue / invalidValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
282 [ + - + - : 2 : EXPECT_THROW(maximalValue / ::ad::map::point::ENUHeading(0.0), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
283 : :
284 : : // operator-()
285 [ + - + - : 2 : EXPECT_THROW(-invalidValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
286 [ - + ]: 1 : if (std::fabs(static_cast<double>(maximalValue)) > std::fabs(static_cast<double>(minimalValue)))
287 : : {
288 [ # # # # : 0 : EXPECT_THROW(-maximalValue, std::out_of_range);
# # # # #
# # # # #
# # # # ]
289 : : }
290 [ - + ]: 1 : else if (std::fabs(static_cast<double>(maximalValue)) < std::fabs(static_cast<double>(minimalValue)))
291 : : {
292 [ # # # # : 0 : EXPECT_THROW(-minimalValue, std::out_of_range);
# # # # #
# # # # #
# # # # ]
293 : : }
294 : : else
295 : : {
296 : : // impossible to trigger invalid result while operand is valid
297 : : }
298 : 1 : }
299 : : #endif
300 : :
301 : 2 : TEST(ENUHeadingTests, comparisonOperatorsRespectPrecision)
302 : : {
303 : 1 : double const precisionValueTimesTen = ::ad::map::point::ENUHeading::cPrecisionValue * 10.;
304 : 1 : ::ad::map::point::ENUHeading value;
305 [ - + ]: 1 : if (::ad::map::point::ENUHeading::cMinValue > precisionValueTimesTen)
306 : : {
307 : 0 : value = ::ad::map::point::ENUHeading(::ad::map::point::ENUHeading::cMinValue + precisionValueTimesTen);
308 : : }
309 [ - + ]: 1 : else if (::ad::map::point::ENUHeading::cMaxValue < precisionValueTimesTen)
310 : : {
311 : 0 : value = ::ad::map::point::ENUHeading(::ad::map::point::ENUHeading::cMaxValue - precisionValueTimesTen);
312 : : }
313 : : else
314 : : {
315 : 1 : value = ::ad::map::point::ENUHeading(precisionValueTimesTen);
316 : : }
317 : 1 : ::ad::map::point::ENUHeading const sameValue = value;
318 : 1 : ::ad::map::point::ENUHeading const slightlyBiggerValue(static_cast<double>(value)
319 : 1 : + ::ad::map::point::ENUHeading::cPrecisionValue * 0.9);
320 : 1 : ::ad::map::point::ENUHeading const slightlySmallerValue(static_cast<double>(value)
321 : 1 : - ::ad::map::point::ENUHeading::cPrecisionValue * 0.9);
322 : 1 : ::ad::map::point::ENUHeading const actuallyBiggerValue(static_cast<double>(value)
323 : 1 : + ::ad::map::point::ENUHeading::cPrecisionValue * 1.1);
324 : 1 : ::ad::map::point::ENUHeading const actuallySmallerValue(static_cast<double>(value)
325 : 1 : - ::ad::map::point::ENUHeading::cPrecisionValue * 1.1);
326 : :
327 : : // operator ==
328 [ + - - + : 1 : EXPECT_TRUE(value == sameValue);
- - - - -
- - - ]
329 [ + - - + : 1 : EXPECT_TRUE(value == slightlyBiggerValue);
- - - - -
- - - ]
330 [ + - - + : 1 : EXPECT_TRUE(value == slightlySmallerValue);
- - - - -
- - - ]
331 [ + - - + : 1 : EXPECT_FALSE(value == actuallyBiggerValue);
- - - - -
- - - ]
332 [ + - - + : 1 : EXPECT_FALSE(value == actuallySmallerValue);
- - - - -
- - - ]
333 : :
334 : : // operator !=
335 [ + - - + : 1 : EXPECT_FALSE(value != sameValue);
- - - - -
- - - ]
336 [ + - - + : 1 : EXPECT_FALSE(value != slightlyBiggerValue);
- - - - -
- - - ]
337 [ + - - + : 1 : EXPECT_FALSE(value != slightlySmallerValue);
- - - - -
- - - ]
338 [ + - - + : 1 : EXPECT_TRUE(value != actuallyBiggerValue);
- - - - -
- - - ]
339 [ + - - + : 1 : EXPECT_TRUE(value != actuallySmallerValue);
- - - - -
- - - ]
340 : :
341 : : // operator >
342 [ + - - + : 1 : EXPECT_FALSE(value > value);
- - - - -
- - - ]
343 [ + - - + : 1 : EXPECT_FALSE(slightlyBiggerValue > value);
- - - - -
- - - ]
344 [ + - - + : 1 : EXPECT_TRUE(actuallyBiggerValue > value);
- - - - -
- - - ]
345 : :
346 : : // operator >=
347 [ + - - + : 1 : EXPECT_FALSE(actuallySmallerValue >= value);
- - - - -
- - - ]
348 [ + - - + : 1 : EXPECT_TRUE(slightlySmallerValue >= value);
- - - - -
- - - ]
349 [ + - - + : 1 : EXPECT_TRUE(value >= value);
- - - - -
- - - ]
350 [ + - - + : 1 : EXPECT_TRUE(slightlyBiggerValue >= value);
- - - - -
- - - ]
351 [ + - - + : 1 : EXPECT_TRUE(actuallyBiggerValue >= value);
- - - - -
- - - ]
352 : :
353 : : // operator <
354 [ + - - + : 1 : EXPECT_FALSE(value < value);
- - - - -
- - - ]
355 [ + - - + : 1 : EXPECT_FALSE(slightlySmallerValue < value);
- - - - -
- - - ]
356 [ + - - + : 1 : EXPECT_TRUE(actuallySmallerValue < value);
- - - - -
- - - ]
357 : :
358 : : // operator <=
359 [ + - - + : 1 : EXPECT_FALSE(actuallyBiggerValue <= value);
- - - - -
- - - ]
360 [ + - - + : 1 : EXPECT_TRUE(slightlyBiggerValue <= value);
- - - - -
- - - ]
361 [ + - - + : 1 : EXPECT_TRUE(value <= value);
- - - - -
- - - ]
362 [ + - - + : 1 : EXPECT_TRUE(slightlySmallerValue <= value);
- - - - -
- - - ]
363 [ + - - + : 1 : EXPECT_TRUE(actuallySmallerValue <= value);
- - - - -
- - - ]
364 : 1 : }
365 : :
366 : 2 : TEST(ENUHeadingTests, arithmeticOperatorsComputeCorrectly)
367 : : {
368 : 1 : double const cDoubleNear = ::ad::map::point::ENUHeading::cPrecisionValue;
369 : 1 : double const precisionValueTimesTen = ::ad::map::point::ENUHeading::cPrecisionValue * 10.;
370 : 1 : ::ad::map::point::ENUHeading value;
371 [ - + ]: 1 : if (::ad::map::point::ENUHeading::cMinValue > precisionValueTimesTen)
372 : : {
373 : 0 : value = ::ad::map::point::ENUHeading(::ad::map::point::ENUHeading::cMinValue + precisionValueTimesTen);
374 : : }
375 [ - + ]: 1 : else if (::ad::map::point::ENUHeading::cMaxValue < precisionValueTimesTen)
376 : : {
377 : 0 : value = ::ad::map::point::ENUHeading(::ad::map::point::ENUHeading::cMaxValue - precisionValueTimesTen);
378 : : }
379 : : else
380 : : {
381 : 1 : value = ::ad::map::point::ENUHeading(precisionValueTimesTen);
382 : : }
383 : :
384 : 1 : ::ad::map::point::ENUHeading result;
385 : :
386 : : // operator+(::ad::map::point::ENUHeading)
387 [ + - ]: 1 : result = value + value;
388 [ + - - + : 1 : EXPECT_NEAR(static_cast<double>(value) + static_cast<double>(value), static_cast<double>(result), cDoubleNear);
- - - - -
- ]
389 : :
390 : : // operator+=(::ad::map::point::ENUHeading)
391 : 1 : result = value;
392 [ + - ]: 1 : result += value;
393 [ + - - + : 1 : EXPECT_NEAR(static_cast<double>(value) + static_cast<double>(value), static_cast<double>(result), cDoubleNear);
- - - - -
- ]
394 : :
395 : : // operator-(::ad::map::point::ENUHeading)
396 [ + - ]: 1 : result = value - value;
397 [ + - - + : 1 : EXPECT_NEAR(static_cast<double>(value) - static_cast<double>(value), static_cast<double>(result), cDoubleNear);
- - - - -
- ]
398 : :
399 : : // operator-=(::ad::map::point::ENUHeading)
400 : 1 : result = value;
401 [ + - ]: 1 : result -= value;
402 [ + - - + : 1 : EXPECT_NEAR(static_cast<double>(value) - static_cast<double>(value), static_cast<double>(result), cDoubleNear);
- - - - -
- ]
403 : :
404 : : // operator*(double)
405 [ + - ]: 1 : result = value * 5.;
406 [ + - - + : 1 : EXPECT_NEAR(static_cast<double>(value) * 5., static_cast<double>(result), cDoubleNear);
- - - - -
- ]
407 : :
408 : : // operator*(double, ::ad::map::point::ENUHeading)
409 [ + - ]: 1 : result = 5. * value;
410 [ + - - + : 1 : EXPECT_NEAR(static_cast<double>(value) * 5., static_cast<double>(result), cDoubleNear);
- - - - -
- ]
411 : :
412 : : // operator/(double)
413 [ + - ]: 1 : result = value / static_cast<double>(value);
414 [ + - - + : 1 : EXPECT_NEAR(static_cast<double>(value) / static_cast<double>(value), static_cast<double>(result), cDoubleNear);
- - - - -
- ]
415 : :
416 : : // operator/(::ad::map::point::ENUHeading)
417 [ + - ]: 1 : double const doubleResult = value / value;
418 [ + - - + : 1 : EXPECT_NEAR(static_cast<double>(value) / static_cast<double>(value), doubleResult, cDoubleNear);
- - - - -
- ]
419 : :
420 : : // operator-()
421 : 1 : if ((::ad::map::point::ENUHeading::cMinValue < -static_cast<double>(value))
422 [ + - + - : 1 : && (-static_cast<double>(value) < ::ad::map::point::ENUHeading::cMaxValue))
+ - ]
423 : : {
424 [ + - ]: 1 : result = -value;
425 : : }
426 : : else
427 : : {
428 : : // not clear on how to trigger valid result if such small value is not working
429 : : }
430 : 1 : }
431 : :
432 : : #if defined(__clang__) && (__clang_major__ >= 7)
433 : : #pragma GCC diagnostic pop
434 : : #endif
|
