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(SpeedSquaredTests, defaultConstructionIsInvalid)
26 : : {
27 : 1 : ::ad::physics::SpeedSquared value;
28 [ - + - - : 1 : EXPECT_FALSE(value.isValid());
- - - - -
- ]
29 : 1 : }
30 : :
31 : 2 : TEST(SpeedSquaredTests, minIsDefinedAsExpected)
32 : : {
33 [ + - - + : 1 : EXPECT_DOUBLE_EQ(-1e6, ::ad::physics::SpeedSquared::cMinValue);
- - - - -
- ]
34 [ + - - + : 1 : EXPECT_DOUBLE_EQ(::ad::physics::SpeedSquared::cMinValue, static_cast<double>(::ad::physics::SpeedSquared::getMin()));
- - - - -
- ]
35 : 1 : }
36 : :
37 : 2 : TEST(SpeedSquaredTests, maxIsDefinedAsExpected)
38 : : {
39 [ + - - + : 1 : EXPECT_DOUBLE_EQ(1e6, ::ad::physics::SpeedSquared::cMaxValue);
- - - - -
- ]
40 [ + - - + : 1 : EXPECT_DOUBLE_EQ(::ad::physics::SpeedSquared::cMaxValue, static_cast<double>(::ad::physics::SpeedSquared::getMax()));
- - - - -
- ]
41 : 1 : }
42 : :
43 : 2 : TEST(SpeedSquaredTests, precisionIsDefinedAsExpected)
44 : : {
45 [ + - - + : 1 : EXPECT_LT(0., ::ad::physics::SpeedSquared::cPrecisionValue);
- - - - -
- ]
46 [ + - - + : 1 : EXPECT_DOUBLE_EQ(1e-6, ::ad::physics::SpeedSquared::cPrecisionValue);
- - - - -
- ]
47 [ + - - + : 1 : EXPECT_DOUBLE_EQ(::ad::physics::SpeedSquared::cPrecisionValue,
- - - - -
- ]
48 : : static_cast<double>(::ad::physics::SpeedSquared::getPrecision()));
49 : 1 : }
50 : :
51 : 2 : TEST(SpeedSquaredTests, minIsValid)
52 : : {
53 [ - + - - : 1 : EXPECT_TRUE(::ad::physics::SpeedSquared::getMin().isValid());
- - - - -
- ]
54 : 1 : }
55 : :
56 : 2 : TEST(SpeedSquaredTests, aboveMinIsValid)
57 : : {
58 : 1 : ::ad::physics::SpeedSquared value(::ad::physics::SpeedSquared::cMinValue * 0.9);
59 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
60 : 1 : }
61 : :
62 : 2 : TEST(SpeedSquaredTests, belowMinIsInvalid)
63 : : {
64 : 1 : ::ad::physics::SpeedSquared value(::ad::physics::SpeedSquared::cMinValue * 1.1);
65 [ - + - - : 1 : EXPECT_FALSE(value.isValid());
- - - - -
- ]
66 : 1 : }
67 : :
68 : 2 : TEST(SpeedSquaredTests, maxIsValid)
69 : : {
70 [ - + - - : 1 : EXPECT_TRUE(::ad::physics::SpeedSquared::getMax().isValid());
- - - - -
- ]
71 : 1 : }
72 : :
73 : 2 : TEST(SpeedSquaredTests, aboveMaxIsInvalid)
74 : : {
75 : 1 : ::ad::physics::SpeedSquared value(::ad::physics::SpeedSquared::cMaxValue * 1.1);
76 [ - + - - : 1 : EXPECT_FALSE(value.isValid());
- - - - -
- ]
77 : 1 : }
78 : :
79 : 2 : TEST(SpeedSquaredTests, belowMaxIsValid)
80 : : {
81 : 1 : ::ad::physics::SpeedSquared value(::ad::physics::SpeedSquared::cMaxValue * 0.9);
82 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
83 : 1 : }
84 : :
85 : : #if (AD_PHYSICS_SPEEDSQUARED_THROWS_EXCEPTION == 1)
86 : 2 : TEST(SpeedSquaredTests, ensureValidThrowsOnInvalid)
87 : : {
88 : 1 : ::ad::physics::SpeedSquared value;
89 [ + - + - : 2 : EXPECT_THROW(value.ensureValid(), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
90 : 1 : }
91 : :
92 : 2 : TEST(SpeedSquaredTests, ensureValidNonZeroThrowsOnInvalid)
93 : : {
94 : 1 : ::ad::physics::SpeedSquared value;
95 [ + - + - : 2 : EXPECT_THROW(value.ensureValidNonZero(), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
96 : 1 : }
97 : :
98 : 2 : TEST(SpeedSquaredTests, ensureValidNonZeroThrowsOnZero)
99 : : {
100 : 1 : ::ad::physics::SpeedSquared value(0.);
101 [ + - + - : 2 : EXPECT_THROW(value.ensureValidNonZero(), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
102 : 1 : }
103 : : #endif
104 : :
105 : 2 : TEST(SpeedSquaredTestsStd, numericLimitsLowestIsMin)
106 : : {
107 [ + - - + : 1 : EXPECT_DOUBLE_EQ(static_cast<double>(::ad::physics::SpeedSquared::getMin()),
- - - - -
- ]
108 : : static_cast<double>(std::numeric_limits<::ad::physics::SpeedSquared>::lowest()));
109 : 1 : }
110 : :
111 : 2 : TEST(SpeedSquaredTestsStd, numericLimitsMaxIsMax)
112 : : {
113 [ + - - + : 1 : EXPECT_DOUBLE_EQ(static_cast<double>(::ad::physics::SpeedSquared::getMax()),
- - - - -
- ]
114 : : static_cast<double>(std::numeric_limits<::ad::physics::SpeedSquared>::max()));
115 : 1 : }
116 : :
117 : 2 : TEST(SpeedSquaredTestsStd, numericLimitsEpsilonIsPrecision)
118 : : {
119 [ + - - + : 1 : EXPECT_DOUBLE_EQ(static_cast<double>(::ad::physics::SpeedSquared::getPrecision()),
- - - - -
- ]
120 : : static_cast<double>(std::numeric_limits<::ad::physics::SpeedSquared>::epsilon()));
121 : 1 : }
122 : :
123 : 2 : TEST(SpeedSquaredTestsStd, fabsIsWorkingCorrectly)
124 : : {
125 [ + - - + : 1 : EXPECT_DOUBLE_EQ(0., static_cast<double>(std::fabs(::ad::physics::SpeedSquared(-0.))));
- - - - -
- ]
126 [ + - - + : 1 : EXPECT_DOUBLE_EQ(1., static_cast<double>(std::fabs(::ad::physics::SpeedSquared(-1.))));
- - - - -
- ]
127 [ + - - + : 1 : EXPECT_DOUBLE_EQ(
- - - - -
- ]
128 : : ::ad::physics::SpeedSquared::cPrecisionValue,
129 : : static_cast<double>(std::fabs(::ad::physics::SpeedSquared(::ad::physics::SpeedSquared::cPrecisionValue))));
130 [ + - - + : 1 : EXPECT_DOUBLE_EQ(std::fabs(::ad::physics::SpeedSquared::cMinValue),
- - - - -
- ]
131 : : static_cast<double>(std::fabs(::ad::physics::SpeedSquared(::ad::physics::SpeedSquared::cMinValue))));
132 [ + - - + : 1 : EXPECT_DOUBLE_EQ(
- - - - -
- ]
133 : : std::fabs(::ad::physics::SpeedSquared::cMinValue),
134 : : static_cast<double>(std::fabs(::ad::physics::SpeedSquared(-::ad::physics::SpeedSquared::cMinValue))));
135 [ + - - + : 1 : EXPECT_DOUBLE_EQ(std::fabs(::ad::physics::SpeedSquared::cMaxValue),
- - - - -
- ]
136 : : static_cast<double>(std::fabs(::ad::physics::SpeedSquared(::ad::physics::SpeedSquared::cMaxValue))));
137 [ + - - + : 1 : EXPECT_DOUBLE_EQ(
- - - - -
- ]
138 : : std::fabs(::ad::physics::SpeedSquared::cMaxValue),
139 : : static_cast<double>(std::fabs(::ad::physics::SpeedSquared(-::ad::physics::SpeedSquared::cMaxValue))));
140 : 1 : }
141 : :
142 : 2 : TEST(SpeedSquaredTests, constructionFromValidFPValue)
143 : : {
144 : 1 : double const validValue = ::ad::physics::SpeedSquared::cMinValue;
145 : 1 : ::ad::physics::SpeedSquared value(validValue);
146 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
147 [ + - - + : 1 : EXPECT_DOUBLE_EQ(validValue, static_cast<double>(value));
- - - - -
- ]
148 : 1 : }
149 : :
150 : 2 : TEST(SpeedSquaredTests, copyConstructionFromValidValue)
151 : : {
152 : 1 : ::ad::physics::SpeedSquared const validValue(::ad::physics::SpeedSquared::cMinValue);
153 : 1 : ::ad::physics::SpeedSquared value(validValue);
154 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
155 [ + - - + : 1 : EXPECT_DOUBLE_EQ(static_cast<double>(validValue), static_cast<double>(value));
- - - - -
- ]
156 : 1 : }
157 : :
158 : 2 : TEST(SpeedSquaredTests, moveConstructionFromValidValue)
159 : : {
160 : 1 : ::ad::physics::SpeedSquared validValue(::ad::physics::SpeedSquared::cMinValue);
161 : 1 : ::ad::physics::SpeedSquared value(std::move(validValue));
162 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
163 [ + - - + : 1 : EXPECT_DOUBLE_EQ(::ad::physics::SpeedSquared::cMinValue, static_cast<double>(value));
- - - - -
- ]
164 : 1 : }
165 : :
166 : 2 : TEST(SpeedSquaredTests, assignmentFromValidValue)
167 : : {
168 : 1 : ::ad::physics::SpeedSquared const validValue(::ad::physics::SpeedSquared::cMinValue);
169 : 1 : ::ad::physics::SpeedSquared value;
170 : 1 : value = validValue;
171 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
172 [ + - - + : 1 : EXPECT_DOUBLE_EQ(static_cast<double>(validValue), static_cast<double>(value));
- - - - -
- ]
173 : 1 : }
174 : :
175 : 2 : TEST(SpeedSquaredTests, moveAssignmentFromValidValue)
176 : : {
177 : 1 : ::ad::physics::SpeedSquared validValue(::ad::physics::SpeedSquared::cMinValue);
178 : 1 : ::ad::physics::SpeedSquared value;
179 : 1 : value = std::move(validValue);
180 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
181 [ + - - + : 1 : EXPECT_DOUBLE_EQ(::ad::physics::SpeedSquared::cMinValue, static_cast<double>(value));
- - - - -
- ]
182 : 1 : }
183 : :
184 : 2 : TEST(SpeedSquaredTests, constructionFromInvalidFPValue)
185 : : {
186 : 1 : double const invalidValue = std::numeric_limits<double>::quiet_NaN();
187 : 1 : ::ad::physics::SpeedSquared value(invalidValue);
188 [ - + - - : 1 : EXPECT_FALSE(value.isValid());
- - - - -
- ]
189 : 1 : }
190 : :
191 : 2 : TEST(SpeedSquaredTests, copyConstructionFromInvalidValue)
192 : : {
193 : 1 : ::ad::physics::SpeedSquared const invalidValue(std::numeric_limits<double>::quiet_NaN());
194 : 1 : ::ad::physics::SpeedSquared value(invalidValue);
195 [ - + - - : 1 : EXPECT_FALSE(value.isValid());
- - - - -
- ]
196 : 1 : }
197 : :
198 : 2 : TEST(SpeedSquaredTests, assignmentFromInvalidValue)
199 : : {
200 : 1 : ::ad::physics::SpeedSquared const invalidValue(std::numeric_limits<double>::quiet_NaN());
201 : 1 : ::ad::physics::SpeedSquared value;
202 : 1 : value = invalidValue;
203 [ - + - - : 1 : EXPECT_FALSE(value.isValid());
- - - - -
- ]
204 : 1 : }
205 : :
206 : 2 : TEST(SpeedSquaredTests, selfAssignment)
207 : : {
208 : 1 : ::ad::physics::SpeedSquared value(::ad::physics::SpeedSquared::cMinValue);
209 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
210 : 1 : value = value;
211 [ - + - - : 1 : EXPECT_TRUE(value.isValid());
- - - - -
- ]
212 : 1 : }
213 : :
214 : 2 : TEST(SpeedSquaredTests, ostreamOperatorTest)
215 : : {
216 [ + - ]: 1 : std::stringstream stream;
217 : 1 : ::ad::physics::SpeedSquared value;
218 [ + - ]: 1 : stream << value;
219 [ + - + - : 1 : ASSERT_GT(stream.str().size(), 0u);
- + - - -
- - - ]
220 : : }
221 : :
222 : : #if (AD_PHYSICS_SPEEDSQUARED_THROWS_EXCEPTION == 1)
223 : 2 : TEST(SpeedSquaredTests, comparisonOperatorsThrowOnInvalid)
224 : : {
225 : 1 : ::ad::physics::SpeedSquared const value(::ad::physics::SpeedSquared::cMinValue);
226 : 1 : ::ad::physics::SpeedSquared const invalidValue;
227 : :
228 [ + - + - : 2 : EXPECT_THROW((void)(invalidValue == value), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
229 [ + - + - : 2 : EXPECT_THROW((void)(value == invalidValue), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
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 : 1 : }
246 : :
247 : 2 : TEST(SpeedSquaredTests, arithmeticOperatorsThrowOnInvalid)
248 : : {
249 : 1 : ::ad::physics::SpeedSquared const minimalValue(::ad::physics::SpeedSquared::cMinValue);
250 : 1 : ::ad::physics::SpeedSquared const maximalValue(::ad::physics::SpeedSquared::cMaxValue);
251 : 1 : ::ad::physics::SpeedSquared const invalidValue;
252 : 1 : ::ad::physics::SpeedSquared calculationValue;
253 : :
254 : : // operator+(::ad::physics::SpeedSquared)
255 [ + - + - : 2 : EXPECT_THROW(invalidValue + maximalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
256 [ + - + - : 2 : EXPECT_THROW(maximalValue + invalidValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
257 [ + - + - : 2 : EXPECT_THROW(maximalValue + maximalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
258 : :
259 : : // operator+=(::ad::physics::SpeedSquared)
260 : 1 : calculationValue = invalidValue;
261 [ + - + - : 2 : EXPECT_THROW(calculationValue += maximalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
262 : 1 : calculationValue = maximalValue;
263 [ + - + - : 2 : EXPECT_THROW(calculationValue += invalidValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
264 : 1 : calculationValue = maximalValue;
265 [ + - + - : 2 : EXPECT_THROW(calculationValue += maximalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
266 : :
267 : : // operator-(::ad::physics::SpeedSquared)
268 [ + - + - : 2 : EXPECT_THROW(invalidValue - minimalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
269 [ + - + - : 2 : EXPECT_THROW(minimalValue - invalidValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
270 [ + - + - : 2 : EXPECT_THROW(minimalValue - maximalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
271 : :
272 : : // operator-=(::ad::physics::SpeedSquared)
273 : 1 : calculationValue = invalidValue;
274 [ + - + - : 2 : EXPECT_THROW(calculationValue -= minimalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
275 : 1 : calculationValue = minimalValue;
276 [ + - + - : 2 : EXPECT_THROW(calculationValue -= invalidValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
277 : 1 : calculationValue = minimalValue;
278 [ + - + - : 2 : EXPECT_THROW(calculationValue -= maximalValue, std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
279 : :
280 : : // operator*(double)
281 [ + - + - : 2 : EXPECT_THROW(invalidValue * static_cast<double>(maximalValue), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
282 [ + - + - : 2 : EXPECT_THROW(maximalValue * static_cast<double>(maximalValue), std::out_of_range);
+ - - + -
+ - - - -
- - - - ]
283 : :
284 : : // std::sqrt()
285 [ + - + - : 2 : EXPECT_THROW(std::sqrt(invalidValue), 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::physics::SpeedSquared)
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::physics::SpeedSquared(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(SpeedSquaredTests, comparisonOperatorsRespectPrecision)
316 : : {
317 : 1 : double const precisionValueTimesTen = ::ad::physics::SpeedSquared::cPrecisionValue * 10.;
318 : 1 : ::ad::physics::SpeedSquared value;
319 [ - + ]: 1 : if (::ad::physics::SpeedSquared::cMinValue > precisionValueTimesTen)
320 : : {
321 : 0 : value = ::ad::physics::SpeedSquared(::ad::physics::SpeedSquared::cMinValue + precisionValueTimesTen);
322 : : }
323 [ - + ]: 1 : else if (::ad::physics::SpeedSquared::cMaxValue < precisionValueTimesTen)
324 : : {
325 : 0 : value = ::ad::physics::SpeedSquared(::ad::physics::SpeedSquared::cMaxValue - precisionValueTimesTen);
326 : : }
327 : : else
328 : : {
329 : 1 : value = ::ad::physics::SpeedSquared(precisionValueTimesTen);
330 : : }
331 : 1 : ::ad::physics::SpeedSquared const sameValue = value;
332 : 1 : ::ad::physics::SpeedSquared const slightlyBiggerValue(static_cast<double>(value)
333 : 1 : + ::ad::physics::SpeedSquared::cPrecisionValue * 0.9);
334 : 1 : ::ad::physics::SpeedSquared const slightlySmallerValue(static_cast<double>(value)
335 : 1 : - ::ad::physics::SpeedSquared::cPrecisionValue * 0.9);
336 : 1 : ::ad::physics::SpeedSquared const actuallyBiggerValue(static_cast<double>(value)
337 : 1 : + ::ad::physics::SpeedSquared::cPrecisionValue * 1.1);
338 : 1 : ::ad::physics::SpeedSquared const actuallySmallerValue(static_cast<double>(value)
339 : 1 : - ::ad::physics::SpeedSquared::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(SpeedSquaredTests, arithmeticOperatorsComputeCorrectly)
381 : : {
382 : 1 : double const cDoubleNear = ::ad::physics::SpeedSquared::cPrecisionValue;
383 : 1 : double const precisionValueTimesTen = ::ad::physics::SpeedSquared::cPrecisionValue * 10.;
384 : 1 : ::ad::physics::SpeedSquared value;
385 [ - + ]: 1 : if (::ad::physics::SpeedSquared::cMinValue > precisionValueTimesTen)
386 : : {
387 : 0 : value = ::ad::physics::SpeedSquared(::ad::physics::SpeedSquared::cMinValue + precisionValueTimesTen);
388 : : }
389 [ - + ]: 1 : else if (::ad::physics::SpeedSquared::cMaxValue < precisionValueTimesTen)
390 : : {
391 : 0 : value = ::ad::physics::SpeedSquared(::ad::physics::SpeedSquared::cMaxValue - precisionValueTimesTen);
392 : : }
393 : : else
394 : : {
395 : 1 : value = ::ad::physics::SpeedSquared(precisionValueTimesTen);
396 : : }
397 : :
398 : 1 : ::ad::physics::SpeedSquared result;
399 : :
400 : : // operator+(::ad::physics::SpeedSquared)
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::physics::SpeedSquared)
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::physics::SpeedSquared)
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::physics::SpeedSquared)
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 : : // std::sqrt()
423 [ + - ]: 1 : ::ad::physics::Speed const squareRootResult = std::sqrt(value);
424 [ + - - + : 1 : EXPECT_NEAR(std::sqrt(static_cast<double>(value)), static_cast<double>(squareRootResult), cDoubleNear);
- - - - -
- ]
425 : :
426 : : // operator*(double, ::ad::physics::SpeedSquared)
427 [ + - ]: 1 : result = 5. * value;
428 [ + - - + : 1 : EXPECT_NEAR(static_cast<double>(value) * 5., static_cast<double>(result), cDoubleNear);
- - - - -
- ]
429 : :
430 : : // operator/(double)
431 [ + - ]: 1 : result = value / static_cast<double>(value);
432 [ + - - + : 1 : EXPECT_NEAR(static_cast<double>(value) / static_cast<double>(value), static_cast<double>(result), cDoubleNear);
- - - - -
- ]
433 : :
434 : : // operator/(::ad::physics::SpeedSquared)
435 [ + - ]: 1 : double const doubleResult = value / value;
436 [ + - - + : 1 : EXPECT_NEAR(static_cast<double>(value) / static_cast<double>(value), doubleResult, cDoubleNear);
- - - - -
- ]
437 : :
438 : : // operator-()
439 : 1 : if ((::ad::physics::SpeedSquared::cMinValue < -static_cast<double>(value))
440 [ + - + - : 1 : && (-static_cast<double>(value) < ::ad::physics::SpeedSquared::cMaxValue))
+ - ]
441 : : {
442 [ + - ]: 1 : result = -value;
443 : : }
444 : : else
445 : : {
446 : : // not clear on how to trigger valid result if such small value is not working
447 : : }
448 : 1 : }
449 : :
450 : : #if defined(__clang__) && (__clang_major__ >= 7)
451 : : #pragma GCC diagnostic pop
452 : : #endif
|
