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