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