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