1 : // Copyright 2011 Google Inc. All Rights Reserved.
2 : //
3 : // Licensed under the Apache License, Version 2.0 (the "License");
4 : // you may not use this file except in compliance with the License.
5 : // You may obtain a copy of the License at
6 : //
7 : // http://www.apache.org/licenses/LICENSE-2.0
8 : //
9 : // Unless required by applicable law or agreed to in writing, software
10 : // distributed under the License is distributed on an "AS IS" BASIS,
11 : // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 : // See the License for the specific language governing permissions and
13 : // limitations under the License.
14 :
15 : #include "syzygy/common/align.h"
16 : #include "gtest/gtest.h"
17 :
18 : namespace common {
19 :
20 E : TEST(AlignTest, IsPowerOfTwo) {
21 E : EXPECT_FALSE(IsPowerOfTwo(0));
22 E : EXPECT_TRUE(IsPowerOfTwo(1));
23 E : EXPECT_TRUE(IsPowerOfTwo(2));
24 E : EXPECT_FALSE(IsPowerOfTwo(3));
25 E : EXPECT_TRUE(IsPowerOfTwo(4));
26 E : EXPECT_TRUE(IsPowerOfTwo(0x80000000));
27 E : EXPECT_FALSE(IsPowerOfTwo(0x80000001U));
28 E : EXPECT_TRUE(IsPowerOfTwo(reinterpret_cast<uint16*>(0x40000000U)));
29 E : EXPECT_FALSE(IsPowerOfTwo(reinterpret_cast<uint16*>(0x40000001U)));
30 E : }
31 :
32 E : TEST(AlignTest, AlignUp) {
33 : // Try power of two alignments.
34 E : EXPECT_EQ(0, AlignUp(0, 1));
35 E : EXPECT_EQ(1, AlignUp(1, 1));
36 :
37 E : EXPECT_EQ(0, AlignUp(0, 2));
38 E : EXPECT_EQ(2, AlignUp(1, 2));
39 :
40 E : EXPECT_EQ(0x8000000, AlignUp(3, 0x8000000));
41 E : EXPECT_EQ(0x8000000, AlignUp(0x8000000, 0x8000000));
42 :
43 : EXPECT_EQ(reinterpret_cast<void*>(0x40000000U),
44 E : AlignUp(reinterpret_cast<void*>(0x40000000U), 4));
45 :
46 : // And non-power of two alignments.
47 E : EXPECT_EQ(0, AlignUp(0, 3));
48 E : EXPECT_EQ(3, AlignUp(1, 3));
49 :
50 E : EXPECT_EQ(0, AlignUp(0, 7));
51 E : EXPECT_EQ(7, AlignUp(1, 7));
52 :
53 E : EXPECT_EQ(0, AlignUp(0, 0x8000123));
54 E : EXPECT_EQ(0x8000123, AlignUp(3, 0x8000123));
55 :
56 : EXPECT_EQ(reinterpret_cast<void*>(0x40000008U),
57 E : AlignUp(reinterpret_cast<void*>(0x40000001U), 8));
58 E : }
59 :
60 E : TEST(AlignTest, AlignDown) {
61 : // Try power of two alignments.
62 E : EXPECT_EQ(0, AlignDown(0, 1));
63 E : EXPECT_EQ(1, AlignDown(1, 1));
64 :
65 E : EXPECT_EQ(0, AlignDown(0, 2));
66 E : EXPECT_EQ(0, AlignDown(1, 2));
67 :
68 E : EXPECT_EQ(0x8000000, AlignDown(0x8000000, 0x8000000));
69 E : EXPECT_EQ(0x8000000, AlignDown(0x8000003, 0x8000000));
70 :
71 : EXPECT_EQ(reinterpret_cast<int32*>(0x40000000U),
72 E : AlignUp(reinterpret_cast<int32*>(0x40000000U), 4));
73 :
74 : // And non-power of two alignments.
75 E : EXPECT_EQ(0, AlignDown(0, 3));
76 E : EXPECT_EQ(0, AlignDown(1, 3));
77 E : EXPECT_EQ(6, AlignDown(7, 3));
78 :
79 E : EXPECT_EQ(0, AlignDown(0, 7));
80 E : EXPECT_EQ(14, AlignDown(14, 7));
81 :
82 E : EXPECT_EQ(0, AlignDown(1234, 0x8000123));
83 E : EXPECT_EQ(0x8000123, AlignDown(0x8000123, 0x8000123));
84 E : EXPECT_EQ(0x8000123, AlignDown(0x8000124, 0x8000123));
85 :
86 : EXPECT_EQ(reinterpret_cast<int32*>(0x40000010U),
87 E : AlignUp(reinterpret_cast<int32*>(0x40000001U), 16));
88 E : }
89 :
90 E : TEST(AlignTest, IsAligned) {
91 : // Try power of two alignments.
92 E : EXPECT_TRUE(IsAligned(0, 1));
93 E : EXPECT_TRUE(IsAligned(1, 1));
94 :
95 E : EXPECT_TRUE(IsAligned(0, 2));
96 E : EXPECT_FALSE(IsAligned(1, 2));
97 :
98 E : EXPECT_TRUE(IsAligned(0x8000000, 0x8000000));
99 E : EXPECT_FALSE(IsAligned(0x8000003, 0x8000000));
100 :
101 E : EXPECT_TRUE(IsAligned(reinterpret_cast<const char*>(0x40000000U), 4));
102 :
103 : // And non-power of two alignments.
104 E : EXPECT_TRUE(IsAligned(0, 3));
105 E : EXPECT_FALSE(IsAligned(1, 3));
106 E : EXPECT_FALSE(IsAligned(7, 3));
107 E : EXPECT_TRUE(IsAligned(3, 3));
108 :
109 E : EXPECT_TRUE(IsAligned(0, 7));
110 E : EXPECT_TRUE(IsAligned(14, 7));
111 E : EXPECT_FALSE(IsAligned(13, 7));
112 :
113 E : EXPECT_FALSE(IsAligned(1234, 0x8000123));
114 E : EXPECT_TRUE(IsAligned(0x8000123, 0x8000123));
115 E : EXPECT_FALSE(IsAligned(0x8000124, 0x8000123));
116 :
117 E : EXPECT_FALSE(IsAligned(reinterpret_cast<const char*>(0x40000001U), 4));
118 E : }
119 :
120 E : TEST(AlignTest, GetAlignment) {
121 E : const size_t max_alignment = 0x80000000;
122 :
123 E : EXPECT_EQ(max_alignment, GetAlignment(0));
124 :
125 : // Try power of 2 values.
126 E : for (uint32 i = 1; i < max_alignment; i <<= 1)
127 E : EXPECT_EQ(i, GetAlignment(i));
128 :
129 E : EXPECT_EQ(max_alignment, GetAlignment(max_alignment));
130 :
131 : // Try non-power of 2 values.
132 E : EXPECT_EQ(16, GetAlignment(0x3210));
133 E : EXPECT_EQ(8, GetAlignment(0xFFF8));
134 E : EXPECT_EQ(4, GetAlignment(0xF0F4));
135 E : EXPECT_EQ(2, GetAlignment(0xF122));
136 E : EXPECT_EQ(1, GetAlignment(0xF123));
137 E : }
138 :
139 E : TEST(AlignTest, IsPowerOfTwo64) {
140 E : EXPECT_FALSE(IsPowerOfTwo64(0));
141 E : EXPECT_TRUE(IsPowerOfTwo64(1));
142 E : EXPECT_TRUE(IsPowerOfTwo64(2));
143 E : EXPECT_FALSE(IsPowerOfTwo64(3));
144 E : EXPECT_TRUE(IsPowerOfTwo64(4));
145 E : EXPECT_TRUE(IsPowerOfTwo64(0x80000000ULL));
146 E : EXPECT_FALSE(IsPowerOfTwo64(0x80000001ULL));
147 E : EXPECT_FALSE(IsPowerOfTwo64(0x123000000000ULL));
148 E : EXPECT_FALSE(IsPowerOfTwo64(0x123000000001ULL));
149 E : EXPECT_TRUE(IsPowerOfTwo64(0x100000000000ULL));
150 E : EXPECT_TRUE(IsPowerOfTwo64(0x200000000000ULL));
151 E : EXPECT_FALSE(IsPowerOfTwo64(0x100000000001ULL));
152 E : EXPECT_FALSE(IsPowerOfTwo64(0x200000000002ULL));
153 E : EXPECT_TRUE(IsPowerOfTwo64(0x8000000000000000ULL));
154 E : EXPECT_FALSE(IsPowerOfTwo64(0x8000000000000001ULL));
155 E : }
156 :
157 E : TEST(AlignTest, AlignUp64) {
158 : // Try power of two alignments.
159 E : EXPECT_EQ(0, AlignUp64(0, 1));
160 E : EXPECT_EQ(1, AlignUp64(1, 1));
161 :
162 E : EXPECT_EQ(0, AlignUp64(0, 2));
163 E : EXPECT_EQ(2, AlignUp64(1, 2));
164 :
165 E : EXPECT_EQ(0x8000000, AlignUp64(3, 0x8000000));
166 E : EXPECT_EQ(0x8000000, AlignUp64(0x8000000, 0x8000000));
167 :
168 : // And non-power of two alignments.
169 E : EXPECT_EQ(0, AlignUp64(0, 3));
170 E : EXPECT_EQ(3, AlignUp64(1, 3));
171 :
172 E : EXPECT_EQ(0, AlignUp64(0, 7));
173 E : EXPECT_EQ(7, AlignUp64(1, 7));
174 :
175 E : EXPECT_EQ(0, AlignUp64(0, 0x8000123));
176 E : EXPECT_EQ(0x8000123, AlignUp64(3, 0x8000123));
177 :
178 : // Try alignments of huge values.
179 E : EXPECT_EQ(0x1000000004ULL, AlignUp64(0x1000000001ULL, 4));
180 E : EXPECT_EQ(0x1000000002ULL, AlignUp64(0x1000000001ULL, 2));
181 E : EXPECT_EQ(0x1000000001ULL, AlignUp64(0x1000000001ULL, 1));
182 E : EXPECT_EQ(0xCCCCCCCCABCDABD0ULL, AlignUp64(0xCCCCCCCCABCDABCDULL, 16));
183 E : }
184 :
185 E : TEST(AlignTest, AlignDown64) {
186 : // Try power of two alignments.
187 E : EXPECT_EQ(0, AlignDown64(0, 1));
188 E : EXPECT_EQ(1, AlignDown64(1, 1));
189 :
190 E : EXPECT_EQ(0, AlignDown64(0, 2));
191 E : EXPECT_EQ(0, AlignDown64(1, 2));
192 :
193 E : EXPECT_EQ(0x8000000, AlignDown64(0x8000000, 0x8000000));
194 E : EXPECT_EQ(0x8000000, AlignDown64(0x8000003, 0x8000000));
195 :
196 : // And non-power of two alignments.
197 E : EXPECT_EQ(0, AlignDown64(0, 3));
198 E : EXPECT_EQ(0, AlignDown64(1, 3));
199 E : EXPECT_EQ(6, AlignDown64(7, 3));
200 :
201 E : EXPECT_EQ(0, AlignDown64(0, 7));
202 E : EXPECT_EQ(14, AlignDown64(14, 7));
203 :
204 E : EXPECT_EQ(0, AlignDown64(1234, 0x8000123));
205 E : EXPECT_EQ(0x8000123, AlignDown64(0x8000123, 0x8000123));
206 E : EXPECT_EQ(0x8000123, AlignDown64(0x8000124, 0x8000123));
207 :
208 : // Try alignments of huge values.
209 E : EXPECT_EQ(0x1000000000ULL, AlignDown64(0x1000000001ULL, 4));
210 E : EXPECT_EQ(0x1000000000ULL, AlignDown64(0x1000000001ULL, 2));
211 E : EXPECT_EQ(0x1000000001ULL, AlignDown64(0x1000000001ULL, 1));
212 E : EXPECT_EQ(0xCCCCCCCCABCDABC0ULL, AlignDown64(0xCCCCCCCCABCDABCDULL, 16));
213 E : }
214 :
215 E : TEST(AlignTest, IsAligned64) {
216 : // Try power of two alignments.
217 E : EXPECT_TRUE(IsAligned64(0, 1));
218 E : EXPECT_TRUE(IsAligned64(1, 1));
219 :
220 E : EXPECT_TRUE(IsAligned64(0, 2));
221 E : EXPECT_FALSE(IsAligned64(1, 2));
222 :
223 E : EXPECT_TRUE(IsAligned64(0x8000000, 0x8000000));
224 E : EXPECT_FALSE(IsAligned64(0x8000003, 0x8000000));
225 :
226 : // And non-power of two alignments.
227 E : EXPECT_TRUE(IsAligned64(0, 3));
228 E : EXPECT_FALSE(IsAligned64(1, 3));
229 E : EXPECT_FALSE(IsAligned64(7, 3));
230 E : EXPECT_TRUE(IsAligned64(3, 3));
231 :
232 E : EXPECT_TRUE(IsAligned64(0, 7));
233 E : EXPECT_TRUE(IsAligned64(14, 7));
234 E : EXPECT_FALSE(IsAligned64(13, 7));
235 :
236 E : EXPECT_FALSE(IsAligned64(1234, 0x8000123));
237 E : EXPECT_TRUE(IsAligned64(0x8000123, 0x8000123));
238 E : EXPECT_FALSE(IsAligned64(0x8000124, 0x8000123));
239 :
240 : // Try alignments of huge values.
241 E : EXPECT_FALSE(IsAligned64(0x1000000001ULL, 4));
242 E : EXPECT_FALSE(IsAligned64(0x1000000001ULL, 2));
243 E : EXPECT_TRUE(IsAligned64(0x1000000002ULL, 2));
244 E : EXPECT_TRUE(IsAligned64(0x1000000001ULL, 1));
245 E : EXPECT_FALSE(IsAligned64(0xCCCCCCCCABCDABCDULL, 16));
246 E : EXPECT_TRUE(IsAligned64(0xCCCCCCCCABCDABC0ULL, 16));
247 E : }
248 :
249 E : TEST(AlignTest, GetAlignment64) {
250 E : const uint64 max_alignment = 1ULL << 63;
251 :
252 E : EXPECT_EQ(max_alignment, GetAlignment64(0));
253 :
254 : // Try power of 2 values.
255 E : for (uint64 i = 1; i < max_alignment; i <<= 1)
256 E : EXPECT_EQ(i, GetAlignment64(i));
257 :
258 E : EXPECT_EQ(max_alignment, GetAlignment64(max_alignment));
259 :
260 : // Try non-power of 2 values.
261 E : EXPECT_EQ(0x800000000, GetAlignment64(0x1111111800000000));
262 E : EXPECT_EQ(16, GetAlignment64(0x1111111176543210));
263 E : EXPECT_EQ(8, GetAlignment64(0x11111111FFFFFFF8));
264 E : EXPECT_EQ(4, GetAlignment64(0x11111111BCDEF0F4));
265 E : EXPECT_EQ(2, GetAlignment64(0x11111111AAAAF122));
266 E : EXPECT_EQ(1, GetAlignment64(0x111111111212F123));
267 E : }
268 :
269 : } // namespace common
|