Line data Source code
1 : // Copyright 2014 the V8 project 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 "src/utils.h"
8 : #include "testing/gtest-support.h"
9 :
10 : namespace v8 {
11 : namespace internal {
12 :
13 : template <typename T>
14 108 : class UtilsTest : public ::testing::Test {};
15 :
16 : typedef ::testing::Types<signed char, unsigned char,
17 : short, // NOLINT(runtime/int)
18 : unsigned short, // NOLINT(runtime/int)
19 : int, unsigned int, long, // NOLINT(runtime/int)
20 : unsigned long, // NOLINT(runtime/int)
21 : long long, // NOLINT(runtime/int)
22 : unsigned long long, // NOLINT(runtime/int)
23 : int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t,
24 : int64_t, uint64_t>
25 : IntegerTypes;
26 :
27 : TYPED_TEST_SUITE(UtilsTest, IntegerTypes);
28 :
29 12424 : TYPED_TEST(UtilsTest, SaturateSub) {
30 17 : TypeParam min = std::numeric_limits<TypeParam>::min();
31 17 : TypeParam max = std::numeric_limits<TypeParam>::max();
32 35 : EXPECT_EQ(SaturateSub<TypeParam>(min, 0), min);
33 35 : EXPECT_EQ(SaturateSub<TypeParam>(max, 0), max);
34 52 : EXPECT_EQ(SaturateSub<TypeParam>(max, min), max);
35 52 : EXPECT_EQ(SaturateSub<TypeParam>(min, max), min);
36 52 : EXPECT_EQ(SaturateSub<TypeParam>(min, max / 3), min);
37 52 : EXPECT_EQ(SaturateSub<TypeParam>(min + 1, 2), min);
38 : if (std::numeric_limits<TypeParam>::is_signed) {
39 21 : EXPECT_EQ(SaturateSub<TypeParam>(min, min), static_cast<TypeParam>(0));
40 25 : EXPECT_EQ(SaturateSub<TypeParam>(0, min), max);
41 25 : EXPECT_EQ(SaturateSub<TypeParam>(max / 3, min), max);
42 25 : EXPECT_EQ(SaturateSub<TypeParam>(max / 5, min), max);
43 25 : EXPECT_EQ(SaturateSub<TypeParam>(min / 3, max), min);
44 25 : EXPECT_EQ(SaturateSub<TypeParam>(min / 9, max), min);
45 25 : EXPECT_EQ(SaturateSub<TypeParam>(max, min / 3), max);
46 25 : EXPECT_EQ(SaturateSub<TypeParam>(min, max / 3), min);
47 25 : EXPECT_EQ(SaturateSub<TypeParam>(max / 3 * 2, min / 2), max);
48 25 : EXPECT_EQ(SaturateSub<TypeParam>(min / 3 * 2, max / 2), min);
49 : } else {
50 18 : EXPECT_EQ(SaturateSub<TypeParam>(min, min), min);
51 27 : EXPECT_EQ(SaturateSub<TypeParam>(0, min), min);
52 27 : EXPECT_EQ(SaturateSub<TypeParam>(0, max), min);
53 27 : EXPECT_EQ(SaturateSub<TypeParam>(max / 3, max), min);
54 27 : EXPECT_EQ(SaturateSub<TypeParam>(max - 3, max), min);
55 : }
56 : TypeParam test_cases[] = {static_cast<TypeParam>(min / 23),
57 : static_cast<TypeParam>(max / 3),
58 : 63,
59 : static_cast<TypeParam>(min / 6),
60 : static_cast<TypeParam>(max / 55),
61 : static_cast<TypeParam>(min / 2),
62 : static_cast<TypeParam>(max / 2),
63 : 0,
64 : 1,
65 : 2,
66 : 3,
67 : 4,
68 18 : 42};
69 954 : TRACED_FOREACH(TypeParam, x, test_cases) {
70 12402 : TRACED_FOREACH(TypeParam, y, test_cases) {
71 : if (std::numeric_limits<TypeParam>::is_signed) {
72 4394 : EXPECT_EQ(SaturateSub<TypeParam>(x, y), x - y);
73 : } else {
74 4563 : EXPECT_EQ(SaturateSub<TypeParam>(x, y), y > x ? min : x - y);
75 : }
76 : }
77 : }
78 18 : }
79 :
80 12424 : TYPED_TEST(UtilsTest, SaturateAdd) {
81 17 : TypeParam min = std::numeric_limits<TypeParam>::min();
82 17 : TypeParam max = std::numeric_limits<TypeParam>::max();
83 35 : EXPECT_EQ(SaturateAdd<TypeParam>(min, min), min);
84 52 : EXPECT_EQ(SaturateAdd<TypeParam>(max, max), max);
85 52 : EXPECT_EQ(SaturateAdd<TypeParam>(min, min / 3), min);
86 52 : EXPECT_EQ(SaturateAdd<TypeParam>(max / 8 * 7, max / 3 * 2), max);
87 52 : EXPECT_EQ(SaturateAdd<TypeParam>(min / 3 * 2, min / 8 * 7), min);
88 52 : EXPECT_EQ(SaturateAdd<TypeParam>(max / 20 * 18, max / 25 * 18), max);
89 52 : EXPECT_EQ(SaturateAdd<TypeParam>(min / 3 * 2, min / 3 * 2), min);
90 52 : EXPECT_EQ(SaturateAdd<TypeParam>(max - 1, 2), max);
91 52 : EXPECT_EQ(SaturateAdd<TypeParam>(max - 100, 101), max);
92 : TypeParam test_cases[] = {static_cast<TypeParam>(min / 23),
93 : static_cast<TypeParam>(max / 3),
94 : 63,
95 : static_cast<TypeParam>(min / 6),
96 : static_cast<TypeParam>(max / 55),
97 : static_cast<TypeParam>(min / 2),
98 : static_cast<TypeParam>(max / 2),
99 : 0,
100 : 1,
101 : 2,
102 : 3,
103 : 4,
104 18 : 42};
105 954 : TRACED_FOREACH(TypeParam, x, test_cases) {
106 12402 : TRACED_FOREACH(TypeParam, y, test_cases) {
107 8957 : EXPECT_EQ(SaturateAdd<TypeParam>(x, y), x + y);
108 : }
109 : }
110 18 : }
111 :
112 12424 : TYPED_TEST(UtilsTest, PassesFilterTest) {
113 36 : EXPECT_TRUE(PassesFilter(CStrVector("abcdefg"), CStrVector("abcdefg")));
114 36 : EXPECT_TRUE(PassesFilter(CStrVector("abcdefg"), CStrVector("abcdefg*")));
115 36 : EXPECT_TRUE(PassesFilter(CStrVector("abcdefg"), CStrVector("abc*")));
116 36 : EXPECT_TRUE(PassesFilter(CStrVector("abcdefg"), CStrVector("*")));
117 36 : EXPECT_TRUE(PassesFilter(CStrVector("abcdefg"), CStrVector("-~")));
118 36 : EXPECT_TRUE(PassesFilter(CStrVector("abcdefg"), CStrVector("-abcdefgh")));
119 36 : EXPECT_TRUE(PassesFilter(CStrVector("abdefg"), CStrVector("-")));
120 36 : EXPECT_FALSE(PassesFilter(CStrVector("abcdefg"), CStrVector("-abcdefg")));
121 36 : EXPECT_FALSE(PassesFilter(CStrVector("abcdefg"), CStrVector("-abcdefg*")));
122 36 : EXPECT_FALSE(PassesFilter(CStrVector("abcdefg"), CStrVector("-abc*")));
123 36 : EXPECT_FALSE(PassesFilter(CStrVector("abcdefg"), CStrVector("-*")));
124 36 : EXPECT_FALSE(PassesFilter(CStrVector("abcdefg"), CStrVector("~")));
125 36 : EXPECT_FALSE(PassesFilter(CStrVector("abcdefg"), CStrVector("")));
126 36 : EXPECT_FALSE(PassesFilter(CStrVector("abcdefg"), CStrVector("abcdefgh")));
127 :
128 36 : EXPECT_TRUE(PassesFilter(CStrVector(""), CStrVector("")));
129 36 : EXPECT_TRUE(PassesFilter(CStrVector(""), CStrVector("*")));
130 36 : EXPECT_FALSE(PassesFilter(CStrVector(""), CStrVector("-")));
131 36 : EXPECT_FALSE(PassesFilter(CStrVector(""), CStrVector("-*")));
132 36 : EXPECT_FALSE(PassesFilter(CStrVector(""), CStrVector("a")));
133 18 : }
134 :
135 15443 : TEST(UtilsTest, IsInBounds) {
136 : // for column consistency and terseness
137 : #define INB(x, y, z) EXPECT_TRUE(IsInBounds(x, y, z))
138 : #define OOB(x, y, z) EXPECT_FALSE(IsInBounds(x, y, z))
139 : INB(0, 0, 1);
140 : INB(0, 1, 1);
141 : INB(1, 0, 1);
142 :
143 : OOB(0, 2, 1);
144 : OOB(2, 0, 1);
145 :
146 : INB(0, 0, 2);
147 : INB(0, 1, 2);
148 : INB(0, 2, 2);
149 :
150 : INB(0, 0, 2);
151 : INB(1, 0, 2);
152 : INB(2, 0, 2);
153 :
154 : OOB(0, 3, 2);
155 : OOB(3, 0, 2);
156 :
157 : INB(0, 1, 2);
158 : INB(1, 1, 2);
159 :
160 : OOB(1, 2, 2);
161 : OOB(2, 1, 2);
162 :
163 : const size_t max = std::numeric_limits<size_t>::max();
164 : const size_t half = max / 2;
165 :
166 : // limit cases.
167 : INB(0, 0, max);
168 : INB(0, 1, max);
169 : INB(1, 0, max);
170 : INB(max, 0, max);
171 : INB(0, max, max);
172 : INB(max - 1, 0, max);
173 : INB(0, max - 1, max);
174 : INB(max - 1, 1, max);
175 : INB(1, max - 1, max);
176 :
177 : INB(half, half, max);
178 : INB(half + 1, half, max);
179 : INB(half, half + 1, max);
180 :
181 : OOB(max, 0, 0);
182 : OOB(0, max, 0);
183 : OOB(max, 0, 1);
184 : OOB(0, max, 1);
185 : OOB(max, 0, 2);
186 : OOB(0, max, 2);
187 :
188 : OOB(max, 0, max - 1);
189 : OOB(0, max, max - 1);
190 :
191 : // wraparound cases.
192 : OOB(max, 1, max);
193 : OOB(1, max, max);
194 : OOB(max - 1, 2, max);
195 : OOB(2, max - 1, max);
196 : OOB(half + 1, half + 1, max);
197 : OOB(half + 1, half + 1, max);
198 :
199 : #undef INB
200 : #undef OOB
201 1 : }
202 :
203 : } // namespace internal
204 9264 : } // namespace v8
|
