1 | //===- unittests/Support/MathExtrasTest.cpp - math utils tests ------------===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | #include "llvm/Support/MathExtras.h" |
10 | #include "gtest/gtest.h" |
11 | |
12 | using namespace llvm; |
13 | |
14 | namespace { |
15 | |
16 | TEST(MathExtras, onesMask) { |
17 | EXPECT_EQ(0U, maskLeadingOnes<uint8_t>(0)); |
18 | EXPECT_EQ(0U, maskTrailingOnes<uint8_t>(0)); |
19 | EXPECT_EQ(0U, maskLeadingOnes<uint16_t>(0)); |
20 | EXPECT_EQ(0U, maskTrailingOnes<uint16_t>(0)); |
21 | EXPECT_EQ(0U, maskLeadingOnes<uint32_t>(0)); |
22 | EXPECT_EQ(0U, maskTrailingOnes<uint32_t>(0)); |
23 | EXPECT_EQ(0U, maskLeadingOnes<uint64_t>(0)); |
24 | EXPECT_EQ(0U, maskTrailingOnes<uint64_t>(0)); |
25 | |
26 | EXPECT_EQ(0x00000003U, maskTrailingOnes<uint32_t>(2U)); |
27 | EXPECT_EQ(0xC0000000U, maskLeadingOnes<uint32_t>(2U)); |
28 | |
29 | EXPECT_EQ(0x000007FFU, maskTrailingOnes<uint32_t>(11U)); |
30 | EXPECT_EQ(0xFFE00000U, maskLeadingOnes<uint32_t>(11U)); |
31 | |
32 | EXPECT_EQ(0xFFFFFFFFU, maskTrailingOnes<uint32_t>(32U)); |
33 | EXPECT_EQ(0xFFFFFFFFU, maskLeadingOnes<uint32_t>(32U)); |
34 | EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, maskTrailingOnes<uint64_t>(64U)); |
35 | EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, maskLeadingOnes<uint64_t>(64U)); |
36 | |
37 | EXPECT_EQ(0x0000FFFFFFFFFFFFULL, maskTrailingOnes<uint64_t>(48U)); |
38 | EXPECT_EQ(0xFFFFFFFFFFFF0000ULL, maskLeadingOnes<uint64_t>(48U)); |
39 | } |
40 | |
41 | TEST(MathExtras, isIntN) { |
42 | EXPECT_TRUE(isIntN(16, 32767)); |
43 | EXPECT_FALSE(isIntN(16, 32768)); |
44 | EXPECT_TRUE(isIntN(0, 0)); |
45 | EXPECT_FALSE(isIntN(0, 1)); |
46 | EXPECT_FALSE(isIntN(0, -1)); |
47 | } |
48 | |
49 | TEST(MathExtras, isUIntN) { |
50 | EXPECT_TRUE(isUIntN(16, 65535)); |
51 | EXPECT_FALSE(isUIntN(16, 65536)); |
52 | EXPECT_TRUE(isUIntN(1, 0)); |
53 | EXPECT_TRUE(isUIntN(6, 63)); |
54 | EXPECT_TRUE(isUIntN(0, 0)); |
55 | EXPECT_FALSE(isUIntN(0, 1)); |
56 | } |
57 | |
58 | TEST(MathExtras, maxIntN) { |
59 | EXPECT_EQ(32767, maxIntN(16)); |
60 | EXPECT_EQ(2147483647, maxIntN(32)); |
61 | EXPECT_EQ(std::numeric_limits<int32_t>::max(), maxIntN(32)); |
62 | EXPECT_EQ(std::numeric_limits<int64_t>::max(), maxIntN(64)); |
63 | EXPECT_EQ(0, maxIntN(0)); |
64 | } |
65 | |
66 | TEST(MathExtras, minIntN) { |
67 | EXPECT_EQ(-32768LL, minIntN(16)); |
68 | EXPECT_EQ(-64LL, minIntN(7)); |
69 | EXPECT_EQ(std::numeric_limits<int32_t>::min(), minIntN(32)); |
70 | EXPECT_EQ(std::numeric_limits<int64_t>::min(), minIntN(64)); |
71 | EXPECT_EQ(0, minIntN(0)); |
72 | } |
73 | |
74 | TEST(MathExtras, maxUIntN) { |
75 | EXPECT_EQ(0xffffULL, maxUIntN(16)); |
76 | EXPECT_EQ(0xffffffffULL, maxUIntN(32)); |
77 | EXPECT_EQ(0xffffffffffffffffULL, maxUIntN(64)); |
78 | EXPECT_EQ(1ULL, maxUIntN(1)); |
79 | EXPECT_EQ(0x0fULL, maxUIntN(4)); |
80 | EXPECT_EQ(0ULL, maxUIntN(0)); |
81 | } |
82 | |
83 | TEST(MathExtras, reverseBits) { |
84 | uint8_t NZ8 = 42; |
85 | uint16_t NZ16 = 42; |
86 | uint32_t NZ32 = 42; |
87 | uint64_t NZ64 = 42; |
88 | EXPECT_EQ(0x54ULL, reverseBits(NZ8)); |
89 | EXPECT_EQ(0x5400ULL, reverseBits(NZ16)); |
90 | EXPECT_EQ(0x54000000ULL, reverseBits(NZ32)); |
91 | EXPECT_EQ(0x5400000000000000ULL, reverseBits(NZ64)); |
92 | } |
93 | |
94 | TEST(MathExtras, isShiftedMask_32) { |
95 | EXPECT_FALSE(isShiftedMask_32(0x01010101)); |
96 | EXPECT_TRUE(isShiftedMask_32(0xf0000000)); |
97 | EXPECT_TRUE(isShiftedMask_32(0xffff0000)); |
98 | EXPECT_TRUE(isShiftedMask_32(0xff << 1)); |
99 | |
100 | unsigned MaskIdx, MaskLen; |
101 | EXPECT_FALSE(isShiftedMask_32(0x01010101, MaskIdx, MaskLen)); |
102 | EXPECT_TRUE(isShiftedMask_32(0xf0000000, MaskIdx, MaskLen)); |
103 | EXPECT_EQ(28, (int)MaskIdx); |
104 | EXPECT_EQ(4, (int)MaskLen); |
105 | EXPECT_TRUE(isShiftedMask_32(0xffff0000, MaskIdx, MaskLen)); |
106 | EXPECT_EQ(16, (int)MaskIdx); |
107 | EXPECT_EQ(16, (int)MaskLen); |
108 | EXPECT_TRUE(isShiftedMask_32(0xff << 1, MaskIdx, MaskLen)); |
109 | EXPECT_EQ(1, (int)MaskIdx); |
110 | EXPECT_EQ(8, (int)MaskLen); |
111 | } |
112 | |
113 | TEST(MathExtras, isShiftedMask_64) { |
114 | EXPECT_FALSE(isShiftedMask_64(0x0101010101010101ull)); |
115 | EXPECT_TRUE(isShiftedMask_64(0xf000000000000000ull)); |
116 | EXPECT_TRUE(isShiftedMask_64(0xffff000000000000ull)); |
117 | EXPECT_TRUE(isShiftedMask_64(0xffull << 55)); |
118 | |
119 | unsigned MaskIdx, MaskLen; |
120 | EXPECT_FALSE(isShiftedMask_64(0x0101010101010101ull, MaskIdx, MaskLen)); |
121 | EXPECT_TRUE(isShiftedMask_64(0xf000000000000000ull, MaskIdx, MaskLen)); |
122 | EXPECT_EQ(60, (int)MaskIdx); |
123 | EXPECT_EQ(4, (int)MaskLen); |
124 | EXPECT_TRUE(isShiftedMask_64(0xffff000000000000ull, MaskIdx, MaskLen)); |
125 | EXPECT_EQ(48, (int)MaskIdx); |
126 | EXPECT_EQ(16, (int)MaskLen); |
127 | EXPECT_TRUE(isShiftedMask_64(0xffull << 55, MaskIdx, MaskLen)); |
128 | EXPECT_EQ(55, (int)MaskIdx); |
129 | EXPECT_EQ(8, (int)MaskLen); |
130 | } |
131 | |
132 | TEST(MathExtras, isPowerOf2_32) { |
133 | EXPECT_FALSE(isPowerOf2_32(0)); |
134 | EXPECT_TRUE(isPowerOf2_32(1 << 6)); |
135 | EXPECT_TRUE(isPowerOf2_32(1 << 12)); |
136 | EXPECT_FALSE(isPowerOf2_32((1 << 19) + 3)); |
137 | EXPECT_FALSE(isPowerOf2_32(0xABCDEF0)); |
138 | } |
139 | |
140 | TEST(MathExtras, isPowerOf2_64) { |
141 | EXPECT_FALSE(isPowerOf2_64(0)); |
142 | EXPECT_TRUE(isPowerOf2_64(1LL << 46)); |
143 | EXPECT_TRUE(isPowerOf2_64(1LL << 12)); |
144 | EXPECT_FALSE(isPowerOf2_64((1LL << 53) + 3)); |
145 | EXPECT_FALSE(isPowerOf2_64(0xABCDEF0ABCDEF0LL)); |
146 | } |
147 | |
148 | TEST(MathExtras, PowerOf2Ceil) { |
149 | EXPECT_EQ(0U, PowerOf2Ceil(0U)); |
150 | EXPECT_EQ(8U, PowerOf2Ceil(8U)); |
151 | EXPECT_EQ(8U, PowerOf2Ceil(7U)); |
152 | } |
153 | |
154 | TEST(MathExtras, CTLog2) { |
155 | EXPECT_EQ(CTLog2<1ULL << 0>(), 0U); |
156 | EXPECT_EQ(CTLog2<1ULL << 1>(), 1U); |
157 | EXPECT_EQ(CTLog2<1ULL << 2>(), 2U); |
158 | EXPECT_EQ(CTLog2<1ULL << 3>(), 3U); |
159 | EXPECT_EQ(CTLog2<1ULL << 4>(), 4U); |
160 | EXPECT_EQ(CTLog2<1ULL << 5>(), 5U); |
161 | EXPECT_EQ(CTLog2<1ULL << 6>(), 6U); |
162 | EXPECT_EQ(CTLog2<1ULL << 7>(), 7U); |
163 | EXPECT_EQ(CTLog2<1ULL << 8>(), 8U); |
164 | EXPECT_EQ(CTLog2<1ULL << 9>(), 9U); |
165 | EXPECT_EQ(CTLog2<1ULL << 10>(), 10U); |
166 | EXPECT_EQ(CTLog2<1ULL << 11>(), 11U); |
167 | EXPECT_EQ(CTLog2<1ULL << 12>(), 12U); |
168 | EXPECT_EQ(CTLog2<1ULL << 13>(), 13U); |
169 | EXPECT_EQ(CTLog2<1ULL << 14>(), 14U); |
170 | EXPECT_EQ(CTLog2<1ULL << 15>(), 15U); |
171 | } |
172 | |
173 | TEST(MathExtras, MinAlign) { |
174 | EXPECT_EQ(1u, MinAlign(2, 3)); |
175 | EXPECT_EQ(2u, MinAlign(2, 4)); |
176 | EXPECT_EQ(1u, MinAlign(17, 64)); |
177 | EXPECT_EQ(256u, MinAlign(256, 512)); |
178 | } |
179 | |
180 | TEST(MathExtras, NextPowerOf2) { |
181 | EXPECT_EQ(4u, NextPowerOf2(3)); |
182 | EXPECT_EQ(16u, NextPowerOf2(15)); |
183 | EXPECT_EQ(256u, NextPowerOf2(128)); |
184 | } |
185 | |
186 | TEST(MathExtras, alignTo) { |
187 | EXPECT_EQ(8u, alignTo(5, 8)); |
188 | EXPECT_EQ(24u, alignTo(17, 8)); |
189 | EXPECT_EQ(0u, alignTo(~0LL, 8)); |
190 | |
191 | EXPECT_EQ(7u, alignTo(5, 8, 7)); |
192 | EXPECT_EQ(17u, alignTo(17, 8, 1)); |
193 | EXPECT_EQ(3u, alignTo(~0LL, 8, 3)); |
194 | EXPECT_EQ(552u, alignTo(321, 255, 42)); |
195 | } |
196 | |
197 | template <typename T> void SaturatingAddTestHelper() { |
198 | const T Max = std::numeric_limits<T>::max(); |
199 | bool ResultOverflowed; |
200 | |
201 | EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2))); |
202 | EXPECT_EQ(T(3), SaturatingAdd(T(1), T(2), &ResultOverflowed)); |
203 | EXPECT_FALSE(ResultOverflowed); |
204 | |
205 | EXPECT_EQ(Max, SaturatingAdd(Max, T(1))); |
206 | EXPECT_EQ(Max, SaturatingAdd(Max, T(1), &ResultOverflowed)); |
207 | EXPECT_TRUE(ResultOverflowed); |
208 | |
209 | EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 1))); |
210 | EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 1), &ResultOverflowed)); |
211 | EXPECT_FALSE(ResultOverflowed); |
212 | |
213 | EXPECT_EQ(Max, SaturatingAdd(T(1), Max)); |
214 | EXPECT_EQ(Max, SaturatingAdd(T(1), Max, &ResultOverflowed)); |
215 | EXPECT_TRUE(ResultOverflowed); |
216 | |
217 | EXPECT_EQ(Max, SaturatingAdd(Max, Max)); |
218 | EXPECT_EQ(Max, SaturatingAdd(Max, Max, &ResultOverflowed)); |
219 | EXPECT_TRUE(ResultOverflowed); |
220 | |
221 | EXPECT_EQ(T(6), SaturatingAdd(T(1), T(2), T(3))); |
222 | EXPECT_EQ(T(6), SaturatingAdd(T(1), T(2), T(3), &ResultOverflowed)); |
223 | EXPECT_FALSE(ResultOverflowed); |
224 | |
225 | EXPECT_EQ(T(10), SaturatingAdd(T(1), T(2), T(3), T(4))); |
226 | EXPECT_EQ(T(10), SaturatingAdd(T(1), T(2), T(3), T(4), &ResultOverflowed)); |
227 | EXPECT_FALSE(ResultOverflowed); |
228 | |
229 | EXPECT_EQ(Max, SaturatingAdd(Max, T(0), T(0))); |
230 | EXPECT_EQ(Max, SaturatingAdd(Max, T(0), T(0), &ResultOverflowed)); |
231 | EXPECT_FALSE(ResultOverflowed); |
232 | |
233 | EXPECT_EQ(Max, SaturatingAdd(T(0), T(0), Max)); |
234 | EXPECT_EQ(Max, SaturatingAdd(T(0), T(0), Max, &ResultOverflowed)); |
235 | EXPECT_FALSE(ResultOverflowed); |
236 | |
237 | EXPECT_EQ(Max, SaturatingAdd(Max, T(0), T(1))); |
238 | EXPECT_EQ(Max, SaturatingAdd(Max, T(0), T(1), &ResultOverflowed)); |
239 | EXPECT_TRUE(ResultOverflowed); |
240 | |
241 | EXPECT_EQ(Max, SaturatingAdd(T(0), T(1), Max)); |
242 | EXPECT_EQ(Max, SaturatingAdd(T(0), T(1), Max, &ResultOverflowed)); |
243 | EXPECT_TRUE(ResultOverflowed); |
244 | |
245 | EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 2), T(1))); |
246 | EXPECT_EQ(Max, SaturatingAdd(T(1), T(Max - 2), T(1), &ResultOverflowed)); |
247 | EXPECT_FALSE(ResultOverflowed); |
248 | |
249 | EXPECT_EQ(Max, SaturatingAdd(T(1), T(1), T(Max - 2))); |
250 | EXPECT_EQ(Max, SaturatingAdd(T(1), T(1), T(Max - 2), &ResultOverflowed)); |
251 | EXPECT_FALSE(ResultOverflowed); |
252 | |
253 | EXPECT_EQ(Max, SaturatingAdd(Max, Max, Max)); |
254 | EXPECT_EQ(Max, SaturatingAdd(Max, Max, Max, &ResultOverflowed)); |
255 | EXPECT_TRUE(ResultOverflowed); |
256 | } |
257 | |
258 | TEST(MathExtras, SaturatingAdd) { |
259 | SaturatingAddTestHelper<uint8_t>(); |
260 | SaturatingAddTestHelper<uint16_t>(); |
261 | SaturatingAddTestHelper<uint32_t>(); |
262 | SaturatingAddTestHelper<uint64_t>(); |
263 | } |
264 | |
265 | template<typename T> |
266 | void SaturatingMultiplyTestHelper() |
267 | { |
268 | const T Max = std::numeric_limits<T>::max(); |
269 | bool ResultOverflowed; |
270 | |
271 | // Test basic multiplication. |
272 | EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3))); |
273 | EXPECT_EQ(T(6), SaturatingMultiply(T(2), T(3), &ResultOverflowed)); |
274 | EXPECT_FALSE(ResultOverflowed); |
275 | |
276 | EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2))); |
277 | EXPECT_EQ(T(6), SaturatingMultiply(T(3), T(2), &ResultOverflowed)); |
278 | EXPECT_FALSE(ResultOverflowed); |
279 | |
280 | // Test multiplication by zero. |
281 | EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0))); |
282 | EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(0), &ResultOverflowed)); |
283 | EXPECT_FALSE(ResultOverflowed); |
284 | |
285 | EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0))); |
286 | EXPECT_EQ(T(0), SaturatingMultiply(T(1), T(0), &ResultOverflowed)); |
287 | EXPECT_FALSE(ResultOverflowed); |
288 | |
289 | EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1))); |
290 | EXPECT_EQ(T(0), SaturatingMultiply(T(0), T(1), &ResultOverflowed)); |
291 | EXPECT_FALSE(ResultOverflowed); |
292 | |
293 | EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0))); |
294 | EXPECT_EQ(T(0), SaturatingMultiply(Max, T(0), &ResultOverflowed)); |
295 | EXPECT_FALSE(ResultOverflowed); |
296 | |
297 | EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max)); |
298 | EXPECT_EQ(T(0), SaturatingMultiply(T(0), Max, &ResultOverflowed)); |
299 | EXPECT_FALSE(ResultOverflowed); |
300 | |
301 | // Test multiplication by maximum value. |
302 | EXPECT_EQ(Max, SaturatingMultiply(Max, T(2))); |
303 | EXPECT_EQ(Max, SaturatingMultiply(Max, T(2), &ResultOverflowed)); |
304 | EXPECT_TRUE(ResultOverflowed); |
305 | |
306 | EXPECT_EQ(Max, SaturatingMultiply(T(2), Max)); |
307 | EXPECT_EQ(Max, SaturatingMultiply(T(2), Max, &ResultOverflowed)); |
308 | EXPECT_TRUE(ResultOverflowed); |
309 | |
310 | EXPECT_EQ(Max, SaturatingMultiply(Max, Max)); |
311 | EXPECT_EQ(Max, SaturatingMultiply(Max, Max, &ResultOverflowed)); |
312 | EXPECT_TRUE(ResultOverflowed); |
313 | |
314 | // Test interesting boundary conditions for algorithm - |
315 | // ((1 << A) - 1) * ((1 << B) + K) for K in [-1, 0, 1] |
316 | // and A + B == std::numeric_limits<T>::digits. |
317 | // We expect overflow iff A > B and K = 1. |
318 | const int Digits = std::numeric_limits<T>::digits; |
319 | for (int A = 1, B = Digits - 1; B >= 1; ++A, --B) { |
320 | for (int K = -1; K <= 1; ++K) { |
321 | T X = (T(1) << A) - T(1); |
322 | T Y = (T(1) << B) + K; |
323 | bool OverflowExpected = A > B && K == 1; |
324 | |
325 | if(OverflowExpected) { |
326 | EXPECT_EQ(Max, SaturatingMultiply(X, Y)); |
327 | EXPECT_EQ(Max, SaturatingMultiply(X, Y, &ResultOverflowed)); |
328 | EXPECT_TRUE(ResultOverflowed); |
329 | } else { |
330 | EXPECT_EQ(X * Y, SaturatingMultiply(X, Y)); |
331 | EXPECT_EQ(X * Y, SaturatingMultiply(X, Y, &ResultOverflowed)); |
332 | EXPECT_FALSE(ResultOverflowed); |
333 | } |
334 | } |
335 | } |
336 | } |
337 | |
338 | TEST(MathExtras, SaturatingMultiply) { |
339 | SaturatingMultiplyTestHelper<uint8_t>(); |
340 | SaturatingMultiplyTestHelper<uint16_t>(); |
341 | SaturatingMultiplyTestHelper<uint32_t>(); |
342 | SaturatingMultiplyTestHelper<uint64_t>(); |
343 | } |
344 | |
345 | template<typename T> |
346 | void SaturatingMultiplyAddTestHelper() |
347 | { |
348 | const T Max = std::numeric_limits<T>::max(); |
349 | bool ResultOverflowed; |
350 | |
351 | // Test basic multiply-add. |
352 | EXPECT_EQ(T(16), SaturatingMultiplyAdd(T(2), T(3), T(10))); |
353 | EXPECT_EQ(T(16), SaturatingMultiplyAdd(T(2), T(3), T(10), &ResultOverflowed)); |
354 | EXPECT_FALSE(ResultOverflowed); |
355 | |
356 | // Test multiply overflows, add doesn't overflow |
357 | EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, T(0), &ResultOverflowed)); |
358 | EXPECT_TRUE(ResultOverflowed); |
359 | |
360 | // Test multiply doesn't overflow, add overflows |
361 | EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), T(1), Max, &ResultOverflowed)); |
362 | EXPECT_TRUE(ResultOverflowed); |
363 | |
364 | // Test multiply-add with Max as operand |
365 | EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), T(1), Max, &ResultOverflowed)); |
366 | EXPECT_TRUE(ResultOverflowed); |
367 | |
368 | EXPECT_EQ(Max, SaturatingMultiplyAdd(T(1), Max, T(1), &ResultOverflowed)); |
369 | EXPECT_TRUE(ResultOverflowed); |
370 | |
371 | EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, T(1), &ResultOverflowed)); |
372 | EXPECT_TRUE(ResultOverflowed); |
373 | |
374 | EXPECT_EQ(Max, SaturatingMultiplyAdd(Max, Max, Max, &ResultOverflowed)); |
375 | EXPECT_TRUE(ResultOverflowed); |
376 | |
377 | // Test multiply-add with 0 as operand |
378 | EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(1), T(1), T(0), &ResultOverflowed)); |
379 | EXPECT_FALSE(ResultOverflowed); |
380 | |
381 | EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(1), T(0), T(1), &ResultOverflowed)); |
382 | EXPECT_FALSE(ResultOverflowed); |
383 | |
384 | EXPECT_EQ(T(1), SaturatingMultiplyAdd(T(0), T(0), T(1), &ResultOverflowed)); |
385 | EXPECT_FALSE(ResultOverflowed); |
386 | |
387 | EXPECT_EQ(T(0), SaturatingMultiplyAdd(T(0), T(0), T(0), &ResultOverflowed)); |
388 | EXPECT_FALSE(ResultOverflowed); |
389 | |
390 | } |
391 | |
392 | TEST(MathExtras, SaturatingMultiplyAdd) { |
393 | SaturatingMultiplyAddTestHelper<uint8_t>(); |
394 | SaturatingMultiplyAddTestHelper<uint16_t>(); |
395 | SaturatingMultiplyAddTestHelper<uint32_t>(); |
396 | SaturatingMultiplyAddTestHelper<uint64_t>(); |
397 | } |
398 | |
399 | TEST(MathExtras, IsShiftedUInt) { |
400 | EXPECT_TRUE((isShiftedUInt<1, 0>(0))); |
401 | EXPECT_TRUE((isShiftedUInt<1, 0>(1))); |
402 | EXPECT_FALSE((isShiftedUInt<1, 0>(2))); |
403 | EXPECT_FALSE((isShiftedUInt<1, 0>(3))); |
404 | EXPECT_FALSE((isShiftedUInt<1, 0>(0x8000000000000000))); |
405 | EXPECT_TRUE((isShiftedUInt<1, 63>(0x8000000000000000))); |
406 | EXPECT_TRUE((isShiftedUInt<2, 62>(0xC000000000000000))); |
407 | EXPECT_FALSE((isShiftedUInt<2, 62>(0xE000000000000000))); |
408 | |
409 | // 0x201 is ten bits long and has a 1 in the MSB and LSB. |
410 | EXPECT_TRUE((isShiftedUInt<10, 5>(uint64_t(0x201) << 5))); |
411 | EXPECT_FALSE((isShiftedUInt<10, 5>(uint64_t(0x201) << 4))); |
412 | EXPECT_FALSE((isShiftedUInt<10, 5>(uint64_t(0x201) << 6))); |
413 | } |
414 | |
415 | TEST(MathExtras, IsShiftedInt) { |
416 | EXPECT_TRUE((isShiftedInt<1, 0>(0))); |
417 | EXPECT_TRUE((isShiftedInt<1, 0>(-1))); |
418 | EXPECT_FALSE((isShiftedInt<1, 0>(2))); |
419 | EXPECT_FALSE((isShiftedInt<1, 0>(3))); |
420 | EXPECT_FALSE((isShiftedInt<1, 0>(0x8000000000000000))); |
421 | EXPECT_TRUE((isShiftedInt<1, 63>(0x8000000000000000))); |
422 | EXPECT_TRUE((isShiftedInt<2, 62>(0xC000000000000000))); |
423 | EXPECT_FALSE((isShiftedInt<2, 62>(0xE000000000000000))); |
424 | |
425 | // 0x201 is ten bits long and has a 1 in the MSB and LSB. |
426 | EXPECT_TRUE((isShiftedInt<11, 5>(int64_t(0x201) << 5))); |
427 | EXPECT_FALSE((isShiftedInt<11, 5>(int64_t(0x201) << 3))); |
428 | EXPECT_FALSE((isShiftedInt<11, 5>(int64_t(0x201) << 6))); |
429 | EXPECT_TRUE((isShiftedInt<11, 5>(-(int64_t(0x201) << 5)))); |
430 | EXPECT_FALSE((isShiftedInt<11, 5>(-(int64_t(0x201) << 3)))); |
431 | EXPECT_FALSE((isShiftedInt<11, 5>(-(int64_t(0x201) << 6)))); |
432 | |
433 | EXPECT_TRUE((isShiftedInt<6, 10>(-(int64_t(1) << 15)))); |
434 | EXPECT_FALSE((isShiftedInt<6, 10>(int64_t(1) << 15))); |
435 | } |
436 | |
437 | template <typename T> |
438 | class OverflowTest : public ::testing::Test { }; |
439 | |
440 | using OverflowTestTypes = ::testing::Types<signed char, short, int, long, |
441 | long long>; |
442 | |
443 | TYPED_TEST_SUITE(OverflowTest, OverflowTestTypes, ); |
444 | |
445 | TYPED_TEST(OverflowTest, AddNoOverflow) { |
446 | TypeParam Result; |
447 | EXPECT_FALSE(AddOverflow<TypeParam>(1, 2, Result)); |
448 | EXPECT_EQ(Result, TypeParam(3)); |
449 | } |
450 | |
451 | TYPED_TEST(OverflowTest, AddOverflowToNegative) { |
452 | TypeParam Result; |
453 | auto MaxValue = std::numeric_limits<TypeParam>::max(); |
454 | EXPECT_TRUE(AddOverflow<TypeParam>(MaxValue, MaxValue, Result)); |
455 | EXPECT_EQ(Result, TypeParam(-2)); |
456 | } |
457 | |
458 | TYPED_TEST(OverflowTest, AddOverflowToMin) { |
459 | TypeParam Result; |
460 | auto MaxValue = std::numeric_limits<TypeParam>::max(); |
461 | EXPECT_TRUE(AddOverflow<TypeParam>(MaxValue, TypeParam(1), Result)); |
462 | EXPECT_EQ(Result, std::numeric_limits<TypeParam>::min()); |
463 | } |
464 | |
465 | TYPED_TEST(OverflowTest, AddOverflowToZero) { |
466 | TypeParam Result; |
467 | auto MinValue = std::numeric_limits<TypeParam>::min(); |
468 | EXPECT_TRUE(AddOverflow<TypeParam>(MinValue, MinValue, Result)); |
469 | EXPECT_EQ(Result, TypeParam(0)); |
470 | } |
471 | |
472 | TYPED_TEST(OverflowTest, AddOverflowToMax) { |
473 | TypeParam Result; |
474 | auto MinValue = std::numeric_limits<TypeParam>::min(); |
475 | EXPECT_TRUE(AddOverflow<TypeParam>(MinValue, TypeParam(-1), Result)); |
476 | EXPECT_EQ(Result, std::numeric_limits<TypeParam>::max()); |
477 | } |
478 | |
479 | TYPED_TEST(OverflowTest, SubNoOverflow) { |
480 | TypeParam Result; |
481 | EXPECT_FALSE(SubOverflow<TypeParam>(1, 2, Result)); |
482 | EXPECT_EQ(Result, TypeParam(-1)); |
483 | } |
484 | |
485 | TYPED_TEST(OverflowTest, SubOverflowToMax) { |
486 | TypeParam Result; |
487 | auto MinValue = std::numeric_limits<TypeParam>::min(); |
488 | EXPECT_TRUE(SubOverflow<TypeParam>(0, MinValue, Result)); |
489 | EXPECT_EQ(Result, MinValue); |
490 | } |
491 | |
492 | TYPED_TEST(OverflowTest, SubOverflowToMin) { |
493 | TypeParam Result; |
494 | auto MinValue = std::numeric_limits<TypeParam>::min(); |
495 | EXPECT_TRUE(SubOverflow<TypeParam>(0, MinValue, Result)); |
496 | EXPECT_EQ(Result, MinValue); |
497 | } |
498 | |
499 | TYPED_TEST(OverflowTest, SubOverflowToNegative) { |
500 | TypeParam Result; |
501 | auto MaxValue = std::numeric_limits<TypeParam>::max(); |
502 | auto MinValue = std::numeric_limits<TypeParam>::min(); |
503 | EXPECT_TRUE(SubOverflow<TypeParam>(MaxValue, MinValue, Result)); |
504 | EXPECT_EQ(Result, TypeParam(-1)); |
505 | } |
506 | |
507 | TYPED_TEST(OverflowTest, SubOverflowToPositive) { |
508 | TypeParam Result; |
509 | auto MaxValue = std::numeric_limits<TypeParam>::max(); |
510 | auto MinValue = std::numeric_limits<TypeParam>::min(); |
511 | EXPECT_TRUE(SubOverflow<TypeParam>(MinValue, MaxValue, Result)); |
512 | EXPECT_EQ(Result, TypeParam(1)); |
513 | } |
514 | |
515 | TYPED_TEST(OverflowTest, MulNoOverflow) { |
516 | TypeParam Result; |
517 | EXPECT_FALSE(MulOverflow<TypeParam>(1, 2, Result)); |
518 | EXPECT_EQ(Result, 2); |
519 | EXPECT_FALSE(MulOverflow<TypeParam>(-1, 3, Result)); |
520 | EXPECT_EQ(Result, -3); |
521 | EXPECT_FALSE(MulOverflow<TypeParam>(4, -2, Result)); |
522 | EXPECT_EQ(Result, -8); |
523 | EXPECT_FALSE(MulOverflow<TypeParam>(-6, -5, Result)); |
524 | EXPECT_EQ(Result, 30); |
525 | } |
526 | |
527 | TYPED_TEST(OverflowTest, MulNoOverflowToMax) { |
528 | TypeParam Result; |
529 | auto MaxValue = std::numeric_limits<TypeParam>::max(); |
530 | auto MinValue = std::numeric_limits<TypeParam>::min(); |
531 | EXPECT_FALSE(MulOverflow<TypeParam>(MinValue + 1, -1, Result)); |
532 | EXPECT_EQ(Result, MaxValue); |
533 | } |
534 | |
535 | TYPED_TEST(OverflowTest, MulOverflowToMin) { |
536 | TypeParam Result; |
537 | auto MinValue = std::numeric_limits<TypeParam>::min(); |
538 | EXPECT_TRUE(MulOverflow<TypeParam>(MinValue, -1, Result)); |
539 | EXPECT_EQ(Result, MinValue); |
540 | } |
541 | |
542 | TYPED_TEST(OverflowTest, MulOverflowMax) { |
543 | TypeParam Result; |
544 | auto MinValue = std::numeric_limits<TypeParam>::min(); |
545 | auto MaxValue = std::numeric_limits<TypeParam>::max(); |
546 | EXPECT_TRUE(MulOverflow<TypeParam>(MinValue, MinValue, Result)); |
547 | EXPECT_EQ(Result, 0); |
548 | EXPECT_TRUE(MulOverflow<TypeParam>(MaxValue, MaxValue, Result)); |
549 | EXPECT_EQ(Result, 1); |
550 | } |
551 | |
552 | TYPED_TEST(OverflowTest, MulResultZero) { |
553 | TypeParam Result; |
554 | EXPECT_FALSE(MulOverflow<TypeParam>(4, 0, Result)); |
555 | EXPECT_EQ(Result, TypeParam(0)); |
556 | EXPECT_FALSE(MulOverflow<TypeParam>(-5, 0, Result)); |
557 | EXPECT_EQ(Result, TypeParam(0)); |
558 | EXPECT_FALSE(MulOverflow<TypeParam>(0, 5, Result)); |
559 | EXPECT_EQ(Result, TypeParam(0)); |
560 | EXPECT_FALSE(MulOverflow<TypeParam>(0, -5, Result)); |
561 | EXPECT_EQ(Result, TypeParam(0)); |
562 | } |
563 | |
564 | } // namespace |
565 | |