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