[go: nahoru, domu]
Google Git
Sign in
chromium / chromium / src / b6bf5c32ed8ee629c82110241608e9e60c35752d / . / base / numerics / safe_numerics_unittest.cc
blob: 23c2c78a7866c4022cae593a5e0dcda0d497698e [file] [log] [blame]
scottmg@chromium.orgc1c090d32013-01-16 23:34:04[diff] [blame]1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]5#if defined(COMPILER_MSVC) && defined(ARCH_CPU_32_BITS)
6#include <mmintrin.h>
7#endif
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]8#include <stdint.h>
9
10#include <limits>
11
12#include "base/compiler_specific.h"
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]13#include "base/numerics/safe_conversions.h"
14#include "base/numerics/safe_math.h"
15#include "base/template_util.h"
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]16#include "testing/gtest/include/gtest/gtest.h"
scottmg@chromium.orgc1c090d32013-01-16 23:34:04[diff] [blame]17
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]18using std::numeric_limits;
19using base::CheckedNumeric;
20using base::checked_cast;
21using base::saturated_cast;
22using base::internal::MaxExponent;
23using base::internal::RANGE_VALID;
24using base::internal::RANGE_INVALID;
25using base::internal::RANGE_OVERFLOW;
26using base::internal::RANGE_UNDERFLOW;
27using base::enable_if;
28
29// MSVS 2013 ia32 may not reset the FPU between calculations, and the test
30// framework masks the exceptions. So we just force a manual reset after NaN.
31inline void ResetFloatingPointUnit() {
32#if defined(COMPILER_MSVC) && defined(ARCH_CPU_32_BITS)
33 _mm_empty();
34#endif
35}
36
ncbray@chromium.orgb6bf5c322014-08-09 05:24:02[diff] [blame^]37// These tests deliberately cause arithmetic overflows. If the compiler is
38// aggressive enough, it can const fold these overflows. Disable warnings about
39// overflows for const expressions.
40#if defined(OS_WIN)
41#pragma warning(disable:4756)
42#endif
43
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]44// Helper macros to wrap displaying the conversion types and line numbers.
45#define TEST_EXPECTED_VALIDITY(expected, actual) \
46 EXPECT_EQ(expected, CheckedNumeric<Dst>(actual).validity()) \
47 << "Result test: Value " << +(actual).ValueUnsafe() << " as " << dst \
48 << " on line " << line;
49
50#define TEST_EXPECTED_VALUE(expected, actual) \
51 EXPECT_EQ(static_cast<Dst>(expected), \
52 CheckedNumeric<Dst>(actual).ValueUnsafe()) \
53 << "Result test: Value " << +((actual).ValueUnsafe()) << " as " << dst \
54 << " on line " << line;
55
56// Signed integer arithmetic.
57template <typename Dst>
58static void TestSpecializedArithmetic(
59 const char* dst,
60 int line,
61 typename enable_if<
62 numeric_limits<Dst>::is_integer&& numeric_limits<Dst>::is_signed,
63 int>::type = 0) {
64 typedef numeric_limits<Dst> DstLimits;
65 TEST_EXPECTED_VALIDITY(RANGE_OVERFLOW,
66 -CheckedNumeric<Dst>(DstLimits::min()));
67 TEST_EXPECTED_VALIDITY(RANGE_OVERFLOW,
68 CheckedNumeric<Dst>(DstLimits::min()).Abs());
69 TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(-1).Abs());
70
71 TEST_EXPECTED_VALIDITY(RANGE_VALID,
72 CheckedNumeric<Dst>(DstLimits::max()) + -1);
73 TEST_EXPECTED_VALIDITY(RANGE_UNDERFLOW,
74 CheckedNumeric<Dst>(DstLimits::min()) + -1);
75 TEST_EXPECTED_VALIDITY(
76 RANGE_UNDERFLOW,
77 CheckedNumeric<Dst>(-DstLimits::max()) + -DstLimits::max());
78
79 TEST_EXPECTED_VALIDITY(RANGE_UNDERFLOW,
80 CheckedNumeric<Dst>(DstLimits::min()) - 1);
81 TEST_EXPECTED_VALIDITY(RANGE_VALID,
82 CheckedNumeric<Dst>(DstLimits::min()) - -1);
83 TEST_EXPECTED_VALIDITY(
84 RANGE_OVERFLOW,
85 CheckedNumeric<Dst>(DstLimits::max()) - -DstLimits::max());
86 TEST_EXPECTED_VALIDITY(
87 RANGE_UNDERFLOW,
88 CheckedNumeric<Dst>(-DstLimits::max()) - DstLimits::max());
89
90 TEST_EXPECTED_VALIDITY(RANGE_UNDERFLOW,
91 CheckedNumeric<Dst>(DstLimits::min()) * 2);
92
93 TEST_EXPECTED_VALIDITY(RANGE_OVERFLOW,
94 CheckedNumeric<Dst>(DstLimits::min()) / -1);
95 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(-1) / 2);
96
97 // Modulus is legal only for integers.
98 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>() % 1);
99 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % 1);
100 TEST_EXPECTED_VALUE(-1, CheckedNumeric<Dst>(-1) % 2);
101 TEST_EXPECTED_VALIDITY(RANGE_INVALID, CheckedNumeric<Dst>(-1) % -2);
102 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(DstLimits::min()) % 2);
103 TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(DstLimits::max()) % 2);
104 // Test all the different modulus combinations.
105 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % CheckedNumeric<Dst>(1));
106 TEST_EXPECTED_VALUE(0, 1 % CheckedNumeric<Dst>(1));
107 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % 1);
108 CheckedNumeric<Dst> checked_dst = 1;
109 TEST_EXPECTED_VALUE(0, checked_dst %= 1);
110}
111
112// Unsigned integer arithmetic.
113template <typename Dst>
114static void TestSpecializedArithmetic(
115 const char* dst,
116 int line,
117 typename enable_if<
118 numeric_limits<Dst>::is_integer && !numeric_limits<Dst>::is_signed,
119 int>::type = 0) {
120 typedef numeric_limits<Dst> DstLimits;
121 TEST_EXPECTED_VALIDITY(RANGE_VALID, -CheckedNumeric<Dst>(DstLimits::min()));
122 TEST_EXPECTED_VALIDITY(RANGE_VALID,
123 CheckedNumeric<Dst>(DstLimits::min()).Abs());
124 TEST_EXPECTED_VALIDITY(RANGE_UNDERFLOW,
125 CheckedNumeric<Dst>(DstLimits::min()) + -1);
126 TEST_EXPECTED_VALIDITY(RANGE_UNDERFLOW,
127 CheckedNumeric<Dst>(DstLimits::min()) - 1);
128 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(DstLimits::min()) * 2);
129 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) / 2);
130
131 // Modulus is legal only for integers.
132 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>() % 1);
133 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % 1);
134 TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) % 2);
135 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(DstLimits::min()) % 2);
136 TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(DstLimits::max()) % 2);
137 // Test all the different modulus combinations.
138 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % CheckedNumeric<Dst>(1));
139 TEST_EXPECTED_VALUE(0, 1 % CheckedNumeric<Dst>(1));
140 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) % 1);
141 CheckedNumeric<Dst> checked_dst = 1;
142 TEST_EXPECTED_VALUE(0, checked_dst %= 1);
143}
144
145// Floating point arithmetic.
146template <typename Dst>
147void TestSpecializedArithmetic(
148 const char* dst,
149 int line,
150 typename enable_if<numeric_limits<Dst>::is_iec559, int>::type = 0) {
151 typedef numeric_limits<Dst> DstLimits;
152 TEST_EXPECTED_VALIDITY(RANGE_VALID, -CheckedNumeric<Dst>(DstLimits::min()));
153
154 TEST_EXPECTED_VALIDITY(RANGE_VALID,
155 CheckedNumeric<Dst>(DstLimits::min()).Abs());
156 TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(-1).Abs());
157
158 TEST_EXPECTED_VALIDITY(RANGE_VALID,
159 CheckedNumeric<Dst>(DstLimits::min()) + -1);
160 TEST_EXPECTED_VALIDITY(RANGE_VALID,
161 CheckedNumeric<Dst>(DstLimits::max()) + 1);
162 TEST_EXPECTED_VALIDITY(
163 RANGE_UNDERFLOW,
164 CheckedNumeric<Dst>(-DstLimits::max()) + -DstLimits::max());
165
166 TEST_EXPECTED_VALIDITY(
167 RANGE_OVERFLOW,
168 CheckedNumeric<Dst>(DstLimits::max()) - -DstLimits::max());
169 TEST_EXPECTED_VALIDITY(
170 RANGE_UNDERFLOW,
171 CheckedNumeric<Dst>(-DstLimits::max()) - DstLimits::max());
172
173 TEST_EXPECTED_VALIDITY(RANGE_VALID,
174 CheckedNumeric<Dst>(DstLimits::min()) * 2);
175
176 TEST_EXPECTED_VALUE(-0.5, CheckedNumeric<Dst>(-1.0) / 2);
177 EXPECT_EQ(static_cast<Dst>(1.0), CheckedNumeric<Dst>(1.0).ValueFloating());
178}
179
180// Generic arithmetic tests.
181template <typename Dst>
182static void TestArithmetic(const char* dst, int line) {
183 typedef numeric_limits<Dst> DstLimits;
184
185 EXPECT_EQ(true, CheckedNumeric<Dst>().IsValid());
186 EXPECT_EQ(false,
187 CheckedNumeric<Dst>(CheckedNumeric<Dst>(DstLimits::max()) *
188 DstLimits::max()).IsValid());
189 EXPECT_EQ(static_cast<Dst>(0), CheckedNumeric<Dst>().ValueOrDie());
190 EXPECT_EQ(static_cast<Dst>(0), CheckedNumeric<Dst>().ValueOrDefault(1));
191 EXPECT_EQ(static_cast<Dst>(1),
192 CheckedNumeric<Dst>(CheckedNumeric<Dst>(DstLimits::max()) *
193 DstLimits::max()).ValueOrDefault(1));
194
195 // Test the operator combinations.
196 TEST_EXPECTED_VALUE(2, CheckedNumeric<Dst>(1) + CheckedNumeric<Dst>(1));
197 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) - CheckedNumeric<Dst>(1));
198 TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) * CheckedNumeric<Dst>(1));
199 TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) / CheckedNumeric<Dst>(1));
200 TEST_EXPECTED_VALUE(2, 1 + CheckedNumeric<Dst>(1));
201 TEST_EXPECTED_VALUE(0, 1 - CheckedNumeric<Dst>(1));
202 TEST_EXPECTED_VALUE(1, 1 * CheckedNumeric<Dst>(1));
203 TEST_EXPECTED_VALUE(1, 1 / CheckedNumeric<Dst>(1));
204 TEST_EXPECTED_VALUE(2, CheckedNumeric<Dst>(1) + 1);
205 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>(1) - 1);
206 TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) * 1);
207 TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) / 1);
208 CheckedNumeric<Dst> checked_dst = 1;
209 TEST_EXPECTED_VALUE(2, checked_dst += 1);
210 checked_dst = 1;
211 TEST_EXPECTED_VALUE(0, checked_dst -= 1);
212 checked_dst = 1;
213 TEST_EXPECTED_VALUE(1, checked_dst *= 1);
214 checked_dst = 1;
215 TEST_EXPECTED_VALUE(1, checked_dst /= 1);
216
217 // Generic negation.
218 TEST_EXPECTED_VALUE(0, -CheckedNumeric<Dst>());
219 TEST_EXPECTED_VALUE(-1, -CheckedNumeric<Dst>(1));
220 TEST_EXPECTED_VALUE(1, -CheckedNumeric<Dst>(-1));
221 TEST_EXPECTED_VALUE(static_cast<Dst>(DstLimits::max() * -1),
222 -CheckedNumeric<Dst>(DstLimits::max()));
223
224 // Generic absolute value.
225 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>().Abs());
226 TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1).Abs());
227 TEST_EXPECTED_VALUE(DstLimits::max(),
228 CheckedNumeric<Dst>(DstLimits::max()).Abs());
229
230 // Generic addition.
231 TEST_EXPECTED_VALUE(1, (CheckedNumeric<Dst>() + 1));
232 TEST_EXPECTED_VALUE(2, (CheckedNumeric<Dst>(1) + 1));
233 TEST_EXPECTED_VALUE(0, (CheckedNumeric<Dst>(-1) + 1));
234 TEST_EXPECTED_VALIDITY(RANGE_VALID,
235 CheckedNumeric<Dst>(DstLimits::min()) + 1);
236 TEST_EXPECTED_VALIDITY(
237 RANGE_OVERFLOW, CheckedNumeric<Dst>(DstLimits::max()) + DstLimits::max());
238
239 // Generic subtraction.
240 TEST_EXPECTED_VALUE(-1, (CheckedNumeric<Dst>() - 1));
241 TEST_EXPECTED_VALUE(0, (CheckedNumeric<Dst>(1) - 1));
242 TEST_EXPECTED_VALUE(-2, (CheckedNumeric<Dst>(-1) - 1));
243 TEST_EXPECTED_VALIDITY(RANGE_VALID,
244 CheckedNumeric<Dst>(DstLimits::max()) - 1);
245
246 // Generic multiplication.
247 TEST_EXPECTED_VALUE(0, (CheckedNumeric<Dst>() * 1));
248 TEST_EXPECTED_VALUE(1, (CheckedNumeric<Dst>(1) * 1));
249 TEST_EXPECTED_VALUE(-2, (CheckedNumeric<Dst>(-1) * 2));
250 TEST_EXPECTED_VALIDITY(
251 RANGE_OVERFLOW, CheckedNumeric<Dst>(DstLimits::max()) * DstLimits::max());
252
253 // Generic division.
254 TEST_EXPECTED_VALUE(0, CheckedNumeric<Dst>() / 1);
255 TEST_EXPECTED_VALUE(1, CheckedNumeric<Dst>(1) / 1);
256 TEST_EXPECTED_VALUE(DstLimits::min() / 2,
257 CheckedNumeric<Dst>(DstLimits::min()) / 2);
258 TEST_EXPECTED_VALUE(DstLimits::max() / 2,
259 CheckedNumeric<Dst>(DstLimits::max()) / 2);
260
261 TestSpecializedArithmetic<Dst>(dst, line);
262}
263
264// Helper macro to wrap displaying the conversion types and line numbers.
265#define TEST_ARITHMETIC(Dst) TestArithmetic<Dst>(#Dst, __LINE__)
266
267TEST(SafeNumerics, SignedIntegerMath) {
268 TEST_ARITHMETIC(int8_t);
269 TEST_ARITHMETIC(int);
270 TEST_ARITHMETIC(intptr_t);
271 TEST_ARITHMETIC(intmax_t);
272}
273
274TEST(SafeNumerics, UnsignedIntegerMath) {
275 TEST_ARITHMETIC(uint8_t);
276 TEST_ARITHMETIC(unsigned int);
277 TEST_ARITHMETIC(uintptr_t);
278 TEST_ARITHMETIC(uintmax_t);
279}
280
281TEST(SafeNumerics, FloatingPointMath) {
282 TEST_ARITHMETIC(float);
283 TEST_ARITHMETIC(double);
284}
scottmg@chromium.orgc1c090d32013-01-16 23:34:04[diff] [blame]285
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]286// Enumerates the five different conversions types we need to test.
287enum NumericConversionType {
288 SIGN_PRESERVING_VALUE_PRESERVING,
289 SIGN_PRESERVING_NARROW,
290 SIGN_TO_UNSIGN_WIDEN_OR_EQUAL,
291 SIGN_TO_UNSIGN_NARROW,
292 UNSIGN_TO_SIGN_NARROW_OR_EQUAL,
293};
scottmg@chromium.orgc1c090d32013-01-16 23:34:04[diff] [blame]294
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]295// Template covering the different conversion tests.
296template <typename Dst, typename Src, NumericConversionType conversion>
297struct TestNumericConversion {};
scottmg@chromium.orgc1c090d32013-01-16 23:34:04[diff] [blame]298
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]299// EXPECT_EQ wrappers providing specific detail on test failures.
300#define TEST_EXPECTED_RANGE(expected, actual) \
301 EXPECT_EQ(expected, base::internal::DstRangeRelationToSrcRange<Dst>(actual)) \
302 << "Conversion test: " << src << " value " << actual << " to " << dst \
303 << " on line " << line;
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]304
305template <typename Dst, typename Src>
306struct TestNumericConversion<Dst, Src, SIGN_PRESERVING_VALUE_PRESERVING> {
307 static void Test(const char *dst, const char *src, int line) {
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]308 typedef numeric_limits<Src> SrcLimits;
309 typedef numeric_limits<Dst> DstLimits;
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]310 // Integral to floating.
311 COMPILE_ASSERT((DstLimits::is_iec559 && SrcLimits::is_integer) ||
312 // Not floating to integral and...
313 (!(DstLimits::is_integer && SrcLimits::is_iec559) &&
314 // Same sign, same numeric, source is narrower or same.
315 ((SrcLimits::is_signed == DstLimits::is_signed &&
316 sizeof(Dst) >= sizeof(Src)) ||
317 // Or signed destination and source is smaller
318 (DstLimits::is_signed && sizeof(Dst) > sizeof(Src)))),
319 comparison_must_be_sign_preserving_and_value_preserving);
320
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]321 const CheckedNumeric<Dst> checked_dst = SrcLimits::max();
322 ;
323 TEST_EXPECTED_VALIDITY(RANGE_VALID, checked_dst);
324 if (MaxExponent<Dst>::value > MaxExponent<Src>::value) {
325 if (MaxExponent<Dst>::value >= MaxExponent<Src>::value * 2 - 1) {
326 // At least twice larger type.
327 TEST_EXPECTED_VALIDITY(RANGE_VALID, SrcLimits::max() * checked_dst);
328
329 } else { // Larger, but not at least twice as large.
330 TEST_EXPECTED_VALIDITY(RANGE_OVERFLOW, SrcLimits::max() * checked_dst);
331 TEST_EXPECTED_VALIDITY(RANGE_VALID, checked_dst + 1);
332 }
333 } else { // Same width type.
334 TEST_EXPECTED_VALIDITY(RANGE_OVERFLOW, checked_dst + 1);
335 }
336
337 TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::max());
338 TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(1));
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]339 if (SrcLimits::is_iec559) {
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]340 TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::max() * static_cast<Src>(-1));
341 TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::infinity());
342 TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::infinity() * -1);
343 TEST_EXPECTED_RANGE(RANGE_INVALID, SrcLimits::quiet_NaN());
344 ResetFloatingPointUnit();
345 } else if (numeric_limits<Src>::is_signed) {
346 TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(-1));
347 TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::min());
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]348 }
scottmg@chromium.orgc1c090d32013-01-16 23:34:04[diff] [blame]349 }
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]350};
351
352template <typename Dst, typename Src>
353struct TestNumericConversion<Dst, Src, SIGN_PRESERVING_NARROW> {
354 static void Test(const char *dst, const char *src, int line) {
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]355 typedef numeric_limits<Src> SrcLimits;
356 typedef numeric_limits<Dst> DstLimits;
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]357 COMPILE_ASSERT(SrcLimits::is_signed == DstLimits::is_signed,
358 destination_and_source_sign_must_be_the_same);
359 COMPILE_ASSERT(sizeof(Dst) < sizeof(Src) ||
360 (DstLimits::is_integer && SrcLimits::is_iec559),
361 destination_must_be_narrower_than_source);
362
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]363 const CheckedNumeric<Dst> checked_dst;
364 TEST_EXPECTED_VALIDITY(RANGE_OVERFLOW, checked_dst + SrcLimits::max());
365 TEST_EXPECTED_VALUE(1, checked_dst + static_cast<Src>(1));
366 TEST_EXPECTED_VALIDITY(RANGE_UNDERFLOW, checked_dst - SrcLimits::max());
367
368 TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::max());
369 TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(1));
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]370 if (SrcLimits::is_iec559) {
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]371 TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::max() * -1);
372 TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(-1));
373 TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::infinity());
374 TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::infinity() * -1);
375 TEST_EXPECTED_RANGE(RANGE_INVALID, SrcLimits::quiet_NaN());
376 ResetFloatingPointUnit();
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]377 } else if (SrcLimits::is_signed) {
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]378 TEST_EXPECTED_VALUE(-1, checked_dst - static_cast<Src>(1));
379 TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::min());
380 TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(-1));
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]381 } else {
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]382 TEST_EXPECTED_VALIDITY(RANGE_INVALID, checked_dst - static_cast<Src>(1));
383 TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::min());
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]384 }
385 }
386};
387
388template <typename Dst, typename Src>
389struct TestNumericConversion<Dst, Src, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL> {
390 static void Test(const char *dst, const char *src, int line) {
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]391 typedef numeric_limits<Src> SrcLimits;
392 typedef numeric_limits<Dst> DstLimits;
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]393 COMPILE_ASSERT(sizeof(Dst) >= sizeof(Src),
394 destination_must_be_equal_or_wider_than_source);
395 COMPILE_ASSERT(SrcLimits::is_signed, source_must_be_signed);
396 COMPILE_ASSERT(!DstLimits::is_signed, destination_must_be_unsigned);
397
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]398 const CheckedNumeric<Dst> checked_dst;
399 TEST_EXPECTED_VALUE(SrcLimits::max(), checked_dst + SrcLimits::max());
400 TEST_EXPECTED_VALIDITY(RANGE_UNDERFLOW, checked_dst + static_cast<Src>(-1));
401 TEST_EXPECTED_VALIDITY(RANGE_UNDERFLOW, checked_dst + -SrcLimits::max());
402
403 TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::min());
404 TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::max());
405 TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(1));
406 TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, static_cast<Src>(-1));
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]407 }
408};
409
410template <typename Dst, typename Src>
411struct TestNumericConversion<Dst, Src, SIGN_TO_UNSIGN_NARROW> {
412 static void Test(const char *dst, const char *src, int line) {
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]413 typedef numeric_limits<Src> SrcLimits;
414 typedef numeric_limits<Dst> DstLimits;
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]415 COMPILE_ASSERT((DstLimits::is_integer && SrcLimits::is_iec559) ||
416 (sizeof(Dst) < sizeof(Src)),
417 destination_must_be_narrower_than_source);
418 COMPILE_ASSERT(SrcLimits::is_signed, source_must_be_signed);
419 COMPILE_ASSERT(!DstLimits::is_signed, destination_must_be_unsigned);
420
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]421 const CheckedNumeric<Dst> checked_dst;
422 TEST_EXPECTED_VALUE(1, checked_dst + static_cast<Src>(1));
423 TEST_EXPECTED_VALIDITY(RANGE_OVERFLOW, checked_dst + SrcLimits::max());
424 TEST_EXPECTED_VALIDITY(RANGE_UNDERFLOW, checked_dst + static_cast<Src>(-1));
425 TEST_EXPECTED_VALIDITY(RANGE_UNDERFLOW, checked_dst + -SrcLimits::max());
426
427 TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::max());
428 TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(1));
429 TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, static_cast<Src>(-1));
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]430 if (SrcLimits::is_iec559) {
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]431 TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::max() * -1);
432 TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::infinity());
433 TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::infinity() * -1);
434 TEST_EXPECTED_RANGE(RANGE_INVALID, SrcLimits::quiet_NaN());
435 ResetFloatingPointUnit();
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]436 } else {
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]437 TEST_EXPECTED_RANGE(RANGE_UNDERFLOW, SrcLimits::min());
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]438 }
439 }
440};
441
442template <typename Dst, typename Src>
443struct TestNumericConversion<Dst, Src, UNSIGN_TO_SIGN_NARROW_OR_EQUAL> {
444 static void Test(const char *dst, const char *src, int line) {
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]445 typedef numeric_limits<Src> SrcLimits;
446 typedef numeric_limits<Dst> DstLimits;
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]447 COMPILE_ASSERT(sizeof(Dst) <= sizeof(Src),
448 destination_must_be_narrower_or_equal_to_source);
449 COMPILE_ASSERT(!SrcLimits::is_signed, source_must_be_unsigned);
450 COMPILE_ASSERT(DstLimits::is_signed, destination_must_be_signed);
451
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]452 const CheckedNumeric<Dst> checked_dst;
453 TEST_EXPECTED_VALUE(1, checked_dst + static_cast<Src>(1));
454 TEST_EXPECTED_VALIDITY(RANGE_OVERFLOW, checked_dst + SrcLimits::max());
455 TEST_EXPECTED_VALUE(SrcLimits::min(), checked_dst + SrcLimits::min());
456
457 TEST_EXPECTED_RANGE(RANGE_VALID, SrcLimits::min());
458 TEST_EXPECTED_RANGE(RANGE_OVERFLOW, SrcLimits::max());
459 TEST_EXPECTED_RANGE(RANGE_VALID, static_cast<Src>(1));
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]460 }
461};
462
463// Helper macro to wrap displaying the conversion types and line numbers
464#define TEST_NUMERIC_CONVERSION(d, s, t) \
465 TestNumericConversion<d, s, t>::Test(#d, #s, __LINE__)
466
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]467TEST(SafeNumerics, IntMinOperations) {
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]468 TEST_NUMERIC_CONVERSION(int8_t, int8_t, SIGN_PRESERVING_VALUE_PRESERVING);
469 TEST_NUMERIC_CONVERSION(uint8_t, uint8_t, SIGN_PRESERVING_VALUE_PRESERVING);
470
471 TEST_NUMERIC_CONVERSION(int8_t, int, SIGN_PRESERVING_NARROW);
472 TEST_NUMERIC_CONVERSION(uint8_t, unsigned int, SIGN_PRESERVING_NARROW);
473 TEST_NUMERIC_CONVERSION(int8_t, float, SIGN_PRESERVING_NARROW);
474
475 TEST_NUMERIC_CONVERSION(uint8_t, int8_t, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
476
477 TEST_NUMERIC_CONVERSION(uint8_t, int, SIGN_TO_UNSIGN_NARROW);
478 TEST_NUMERIC_CONVERSION(uint8_t, intmax_t, SIGN_TO_UNSIGN_NARROW);
479 TEST_NUMERIC_CONVERSION(uint8_t, float, SIGN_TO_UNSIGN_NARROW);
480
481 TEST_NUMERIC_CONVERSION(int8_t, unsigned int, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
482 TEST_NUMERIC_CONVERSION(int8_t, uintmax_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
scottmg@chromium.orgc1c090d32013-01-16 23:34:04[diff] [blame]483}
484
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]485TEST(SafeNumerics, IntOperations) {
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]486 TEST_NUMERIC_CONVERSION(int, int, SIGN_PRESERVING_VALUE_PRESERVING);
487 TEST_NUMERIC_CONVERSION(unsigned int, unsigned int,
488 SIGN_PRESERVING_VALUE_PRESERVING);
489 TEST_NUMERIC_CONVERSION(int, int8_t, SIGN_PRESERVING_VALUE_PRESERVING);
490 TEST_NUMERIC_CONVERSION(unsigned int, uint8_t,
491 SIGN_PRESERVING_VALUE_PRESERVING);
492 TEST_NUMERIC_CONVERSION(int, uint8_t, SIGN_PRESERVING_VALUE_PRESERVING);
493
494 TEST_NUMERIC_CONVERSION(int, intmax_t, SIGN_PRESERVING_NARROW);
495 TEST_NUMERIC_CONVERSION(unsigned int, uintmax_t, SIGN_PRESERVING_NARROW);
496 TEST_NUMERIC_CONVERSION(int, float, SIGN_PRESERVING_NARROW);
497 TEST_NUMERIC_CONVERSION(int, double, SIGN_PRESERVING_NARROW);
498
499 TEST_NUMERIC_CONVERSION(unsigned int, int, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
500 TEST_NUMERIC_CONVERSION(unsigned int, int8_t, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
501
502 TEST_NUMERIC_CONVERSION(unsigned int, intmax_t, SIGN_TO_UNSIGN_NARROW);
503 TEST_NUMERIC_CONVERSION(unsigned int, float, SIGN_TO_UNSIGN_NARROW);
504 TEST_NUMERIC_CONVERSION(unsigned int, double, SIGN_TO_UNSIGN_NARROW);
505
506 TEST_NUMERIC_CONVERSION(int, unsigned int, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
507 TEST_NUMERIC_CONVERSION(int, uintmax_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
scottmg@chromium.orgc1c090d32013-01-16 23:34:04[diff] [blame]508}
509
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]510TEST(SafeNumerics, IntMaxOperations) {
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]511 TEST_NUMERIC_CONVERSION(intmax_t, intmax_t, SIGN_PRESERVING_VALUE_PRESERVING);
512 TEST_NUMERIC_CONVERSION(uintmax_t, uintmax_t,
513 SIGN_PRESERVING_VALUE_PRESERVING);
514 TEST_NUMERIC_CONVERSION(intmax_t, int, SIGN_PRESERVING_VALUE_PRESERVING);
515 TEST_NUMERIC_CONVERSION(uintmax_t, unsigned int,
516 SIGN_PRESERVING_VALUE_PRESERVING);
517 TEST_NUMERIC_CONVERSION(intmax_t, unsigned int,
518 SIGN_PRESERVING_VALUE_PRESERVING);
519 TEST_NUMERIC_CONVERSION(intmax_t, uint8_t, SIGN_PRESERVING_VALUE_PRESERVING);
520
521 TEST_NUMERIC_CONVERSION(intmax_t, float, SIGN_PRESERVING_NARROW);
522 TEST_NUMERIC_CONVERSION(intmax_t, double, SIGN_PRESERVING_NARROW);
523
524 TEST_NUMERIC_CONVERSION(uintmax_t, int, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
525 TEST_NUMERIC_CONVERSION(uintmax_t, int8_t, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
526
527 TEST_NUMERIC_CONVERSION(uintmax_t, float, SIGN_TO_UNSIGN_NARROW);
528 TEST_NUMERIC_CONVERSION(uintmax_t, double, SIGN_TO_UNSIGN_NARROW);
529
530 TEST_NUMERIC_CONVERSION(intmax_t, uintmax_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
531}
532
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]533TEST(SafeNumerics, FloatOperations) {
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]534 TEST_NUMERIC_CONVERSION(float, intmax_t, SIGN_PRESERVING_VALUE_PRESERVING);
535 TEST_NUMERIC_CONVERSION(float, uintmax_t,
536 SIGN_PRESERVING_VALUE_PRESERVING);
537 TEST_NUMERIC_CONVERSION(float, int, SIGN_PRESERVING_VALUE_PRESERVING);
538 TEST_NUMERIC_CONVERSION(float, unsigned int,
539 SIGN_PRESERVING_VALUE_PRESERVING);
540
541 TEST_NUMERIC_CONVERSION(float, double, SIGN_PRESERVING_NARROW);
542}
543
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]544TEST(SafeNumerics, DoubleOperations) {
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]545 TEST_NUMERIC_CONVERSION(double, intmax_t, SIGN_PRESERVING_VALUE_PRESERVING);
546 TEST_NUMERIC_CONVERSION(double, uintmax_t,
547 SIGN_PRESERVING_VALUE_PRESERVING);
548 TEST_NUMERIC_CONVERSION(double, int, SIGN_PRESERVING_VALUE_PRESERVING);
549 TEST_NUMERIC_CONVERSION(double, unsigned int,
550 SIGN_PRESERVING_VALUE_PRESERVING);
551}
552
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]553TEST(SafeNumerics, SizeTOperations) {
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]554 TEST_NUMERIC_CONVERSION(size_t, int, SIGN_TO_UNSIGN_WIDEN_OR_EQUAL);
555 TEST_NUMERIC_CONVERSION(int, size_t, UNSIGN_TO_SIGN_NARROW_OR_EQUAL);
556}
557
558TEST(SafeNumerics, CastTests) {
559// MSVC catches and warns that we're forcing saturation in these tests.
560// Since that's intentional, we need to shut this warning off.
561#if defined(COMPILER_MSVC)
562#pragma warning(disable : 4756)
scottmg@chromium.orgc1c090d32013-01-16 23:34:04[diff] [blame]563#endif
564
scottmg@chromium.orgc1c090d32013-01-16 23:34:04[diff] [blame]565 int small_positive = 1;
566 int small_negative = -1;
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]567 double double_small = 1.0;
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]568 double double_large = numeric_limits<double>::max();
569 double double_infinity = numeric_limits<float>::infinity();
scottmg@chromium.orgc1c090d32013-01-16 23:34:04[diff] [blame]570
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]571 // Just test that the cast compiles, since the other tests cover logic.
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]572 EXPECT_EQ(0, checked_cast<int>(static_cast<size_t>(0)));
scottmg@chromium.orgc1c090d32013-01-16 23:34:04[diff] [blame]573
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]574 // Test various saturation corner cases.
575 EXPECT_EQ(saturated_cast<int>(small_negative),
576 static_cast<int>(small_negative));
577 EXPECT_EQ(saturated_cast<int>(small_positive),
578 static_cast<int>(small_positive));
579 EXPECT_EQ(saturated_cast<unsigned>(small_negative),
580 static_cast<unsigned>(0));
581 EXPECT_EQ(saturated_cast<int>(double_small),
582 static_cast<int>(double_small));
jschuh@chromium.org5bfecbc2014-02-27 13:49:04[diff] [blame]583 EXPECT_EQ(saturated_cast<int>(double_large), numeric_limits<int>::max());
jschuh@chromium.org4efb2c32014-01-16 06:57:25[diff] [blame]584 EXPECT_EQ(saturated_cast<float>(double_large), double_infinity);
585 EXPECT_EQ(saturated_cast<float>(-double_large), -double_infinity);
scottmg@chromium.orgc1c090d32013-01-16 23:34:04[diff] [blame]586}
jschuh@chromium.orgcb154062014-01-17 03:32:40[diff] [blame]587