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