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