OLD | NEW |
(Empty) | |
| 1 // Copyright 2016 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 |
| 5 #include <limits> |
| 6 |
| 7 #include "base/logging.h" |
| 8 #include "base/macros.h" |
| 9 #include "base/numerics/saturated_arithmetic.h" |
| 10 #include "build/build_config.h" |
| 11 #include "testing/gtest/include/gtest/gtest.h" |
| 12 |
| 13 namespace base { |
| 14 |
| 15 TEST(SaturatedArithmeticTest, Addition) { |
| 16 int int_max = std::numeric_limits<int>::max(); |
| 17 int int_min = std::numeric_limits<int>::min(); |
| 18 |
| 19 EXPECT_EQ(0, SaturatedAddition(0, 0)); |
| 20 EXPECT_EQ(1, SaturatedAddition(0, 1)); |
| 21 EXPECT_EQ(100, SaturatedAddition(0, 100)); |
| 22 EXPECT_EQ(150, SaturatedAddition(100, 50)); |
| 23 |
| 24 EXPECT_EQ(-1, SaturatedAddition(0, -1)); |
| 25 EXPECT_EQ(0, SaturatedAddition(1, -1)); |
| 26 EXPECT_EQ(50, SaturatedAddition(100, -50)); |
| 27 EXPECT_EQ(-50, SaturatedAddition(50, -100)); |
| 28 |
| 29 EXPECT_EQ(int_max - 1, SaturatedAddition(int_max - 1, 0)); |
| 30 EXPECT_EQ(int_max, SaturatedAddition(int_max - 1, 1)); |
| 31 EXPECT_EQ(int_max, SaturatedAddition(int_max - 1, 2)); |
| 32 EXPECT_EQ(int_max - 1, SaturatedAddition(0, int_max - 1)); |
| 33 EXPECT_EQ(int_max, SaturatedAddition(1, int_max - 1)); |
| 34 EXPECT_EQ(int_max, SaturatedAddition(2, int_max - 1)); |
| 35 EXPECT_EQ(int_max, SaturatedAddition(int_max - 1, int_max - 1)); |
| 36 EXPECT_EQ(int_max, SaturatedAddition(int_max, int_max)); |
| 37 |
| 38 EXPECT_EQ(int_min, SaturatedAddition(int_min, 0)); |
| 39 EXPECT_EQ(int_min + 1, SaturatedAddition(int_min + 1, 0)); |
| 40 EXPECT_EQ(int_min + 2, SaturatedAddition(int_min + 1, 1)); |
| 41 EXPECT_EQ(int_min + 3, SaturatedAddition(int_min + 1, 2)); |
| 42 EXPECT_EQ(int_min, SaturatedAddition(int_min + 1, -1)); |
| 43 EXPECT_EQ(int_min, SaturatedAddition(int_min + 1, -2)); |
| 44 EXPECT_EQ(int_min + 1, SaturatedAddition(0, int_min + 1)); |
| 45 EXPECT_EQ(int_min, SaturatedAddition(-1, int_min + 1)); |
| 46 EXPECT_EQ(int_min, SaturatedAddition(-2, int_min + 1)); |
| 47 |
| 48 EXPECT_EQ(int_max / 2 + 10000, SaturatedAddition(int_max / 2, 10000)); |
| 49 EXPECT_EQ(int_max, SaturatedAddition(int_max / 2 + 1, int_max / 2 + 1)); |
| 50 EXPECT_EQ(-1, SaturatedAddition(int_min, int_max)); |
| 51 } |
| 52 |
| 53 TEST(SaturatedArithmeticTest, Subtraction) { |
| 54 int int_max = std::numeric_limits<int>::max(); |
| 55 int int_min = std::numeric_limits<int>::min(); |
| 56 |
| 57 EXPECT_EQ(0, SaturatedSubtraction(0, 0)); |
| 58 EXPECT_EQ(-1, SaturatedSubtraction(0, 1)); |
| 59 EXPECT_EQ(-100, SaturatedSubtraction(0, 100)); |
| 60 EXPECT_EQ(50, SaturatedSubtraction(100, 50)); |
| 61 |
| 62 EXPECT_EQ(1, SaturatedSubtraction(0, -1)); |
| 63 EXPECT_EQ(2, SaturatedSubtraction(1, -1)); |
| 64 EXPECT_EQ(150, SaturatedSubtraction(100, -50)); |
| 65 EXPECT_EQ(150, SaturatedSubtraction(50, -100)); |
| 66 |
| 67 EXPECT_EQ(int_max, SaturatedSubtraction(int_max, 0)); |
| 68 EXPECT_EQ(int_max - 1, SaturatedSubtraction(int_max, 1)); |
| 69 EXPECT_EQ(int_max - 1, SaturatedSubtraction(int_max - 1, 0)); |
| 70 EXPECT_EQ(int_max, SaturatedSubtraction(int_max - 1, -1)); |
| 71 EXPECT_EQ(int_max, SaturatedSubtraction(int_max - 1, -2)); |
| 72 EXPECT_EQ(-int_max + 1, SaturatedSubtraction(0, int_max - 1)); |
| 73 EXPECT_EQ(-int_max, SaturatedSubtraction(-1, int_max - 1)); |
| 74 EXPECT_EQ(-int_max - 1, SaturatedSubtraction(-2, int_max - 1)); |
| 75 EXPECT_EQ(-int_max - 1, SaturatedSubtraction(-3, int_max - 1)); |
| 76 |
| 77 EXPECT_EQ(int_min, SaturatedSubtraction(int_min, 0)); |
| 78 EXPECT_EQ(int_min + 1, SaturatedSubtraction(int_min + 1, 0)); |
| 79 EXPECT_EQ(int_min, SaturatedSubtraction(int_min + 1, 1)); |
| 80 EXPECT_EQ(int_min, SaturatedSubtraction(int_min + 1, 2)); |
| 81 |
| 82 EXPECT_EQ(0, SaturatedSubtraction(int_min, int_min)); |
| 83 EXPECT_EQ(0, SaturatedSubtraction(int_max, int_max)); |
| 84 EXPECT_EQ(int_max, SaturatedSubtraction(int_max, int_min)); |
| 85 } |
| 86 |
| 87 TEST(SaturatedArithmeticTest, SetSigned) { |
| 88 int int_max = std::numeric_limits<int>::max(); |
| 89 int int_min = std::numeric_limits<int>::min(); |
| 90 |
| 91 const int kFractionBits = 6; |
| 92 const int kIntMaxForLayoutUnit = int_max >> kFractionBits; |
| 93 const int kIntMinForLayoutUnit = int_min >> kFractionBits; |
| 94 |
| 95 EXPECT_EQ(0, SaturatedSet<kFractionBits>(0)); |
| 96 |
| 97 // Internally the max number we can represent (without saturating) |
| 98 // is all the (non-sign) bits set except for the bottom n fraction bits |
| 99 const int max_internal_representation = int_max ^ ((1 << kFractionBits) - 1); |
| 100 EXPECT_EQ(max_internal_representation, |
| 101 SaturatedSet<kFractionBits>(kIntMaxForLayoutUnit)); |
| 102 |
| 103 EXPECT_EQ(GetMaxSaturatedSetResultForTesting(kFractionBits), |
| 104 SaturatedSet<kFractionBits>(kIntMaxForLayoutUnit + 100)); |
| 105 |
| 106 EXPECT_EQ((kIntMaxForLayoutUnit - 100) << kFractionBits, |
| 107 SaturatedSet<kFractionBits>(kIntMaxForLayoutUnit - 100)); |
| 108 |
| 109 EXPECT_EQ(GetMinSaturatedSetResultForTesting(kFractionBits), |
| 110 SaturatedSet<kFractionBits>(kIntMinForLayoutUnit)); |
| 111 |
| 112 EXPECT_EQ(GetMinSaturatedSetResultForTesting(kFractionBits), |
| 113 SaturatedSet<kFractionBits>(kIntMinForLayoutUnit - 100)); |
| 114 |
| 115 // Shifting negative numbers left has undefined behavior, so use |
| 116 // multiplication instead of direct shifting here. |
| 117 EXPECT_EQ((kIntMinForLayoutUnit + 100) * (1 << kFractionBits), |
| 118 SaturatedSet<kFractionBits>(kIntMinForLayoutUnit + 100)); |
| 119 } |
| 120 |
| 121 TEST(SaturatedArithmeticTest, SetUnsigned) { |
| 122 int int_max = std::numeric_limits<int>::max(); |
| 123 |
| 124 const int kFractionBits = 6; |
| 125 const int kIntMaxForLayoutUnit = int_max >> kFractionBits; |
| 126 |
| 127 EXPECT_EQ(0, SaturatedSet<kFractionBits>((unsigned)0)); |
| 128 |
| 129 EXPECT_EQ(GetMaxSaturatedSetResultForTesting(kFractionBits), |
| 130 SaturatedSet<kFractionBits>((unsigned)kIntMaxForLayoutUnit)); |
| 131 |
| 132 const unsigned kOverflowed = kIntMaxForLayoutUnit + 100; |
| 133 EXPECT_EQ(GetMaxSaturatedSetResultForTesting(kFractionBits), |
| 134 SaturatedSet<kFractionBits>(kOverflowed)); |
| 135 |
| 136 const unsigned kNotOverflowed = kIntMaxForLayoutUnit - 100; |
| 137 EXPECT_EQ((kIntMaxForLayoutUnit - 100) << kFractionBits, |
| 138 SaturatedSet<kFractionBits>(kNotOverflowed)); |
| 139 } |
| 140 |
| 141 } // namespace base |
OLD | NEW |