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