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 : }
29 :
30 E : TEST(AlignTest, AlignUp) {
31 : // Try power of two alignments.
32 E : EXPECT_EQ(0, AlignUp(0, 1));
33 E : EXPECT_EQ(1, AlignUp(1, 1));
34 :
35 E : EXPECT_EQ(0, AlignUp(0, 2));
36 E : EXPECT_EQ(2, AlignUp(1, 2));
37 :
38 E : EXPECT_EQ(0x8000000, AlignUp(3, 0x8000000));
39 E : EXPECT_EQ(0x8000000, AlignUp(0x8000000, 0x8000000));
40 :
41 : // And non-power of two alignments.
42 E : EXPECT_EQ(0, AlignUp(0, 3));
43 E : EXPECT_EQ(3, AlignUp(1, 3));
44 :
45 E : EXPECT_EQ(0, AlignUp(0, 7));
46 E : EXPECT_EQ(7, AlignUp(1, 7));
47 :
48 E : EXPECT_EQ(0, AlignUp(0, 0x8000123));
49 E : EXPECT_EQ(0x8000123, AlignUp(3, 0x8000123));
50 E : }
51 :
52 E : TEST(AlignTest, AlignDown) {
53 : // Try power of two alignments.
54 E : EXPECT_EQ(0, AlignDown(0, 1));
55 E : EXPECT_EQ(1, AlignDown(1, 1));
56 :
57 E : EXPECT_EQ(0, AlignDown(0, 2));
58 E : EXPECT_EQ(0, AlignDown(1, 2));
59 :
60 E : EXPECT_EQ(0x8000000, AlignDown(0x8000000, 0x8000000));
61 E : EXPECT_EQ(0x8000000, AlignDown(0x8000003, 0x8000000));
62 :
63 : // And non-power of two alignments.
64 E : EXPECT_EQ(0, AlignDown(0, 3));
65 E : EXPECT_EQ(0, AlignDown(1, 3));
66 E : EXPECT_EQ(6, AlignDown(7, 3));
67 :
68 E : EXPECT_EQ(0, AlignDown(0, 7));
69 E : EXPECT_EQ(14, AlignDown(14, 7));
70 :
71 E : EXPECT_EQ(0, AlignDown(1234, 0x8000123));
72 E : EXPECT_EQ(0x8000123, AlignDown(0x8000123, 0x8000123));
73 E : EXPECT_EQ(0x8000123, AlignDown(0x8000124, 0x8000123));
74 E : }
75 :
76 E : TEST(AlignTest, IsAligned) {
77 : // Try power of two alignments.
78 E : EXPECT_TRUE(IsAligned(0, 1));
79 E : EXPECT_TRUE(IsAligned(1, 1));
80 :
81 E : EXPECT_TRUE(IsAligned(0, 2));
82 E : EXPECT_FALSE(IsAligned(1, 2));
83 :
84 E : EXPECT_TRUE(IsAligned(0x8000000, 0x8000000));
85 E : EXPECT_FALSE(IsAligned(0x8000003, 0x8000000));
86 :
87 : // And non-power of two alignments.
88 E : EXPECT_TRUE(IsAligned(0, 3));
89 E : EXPECT_FALSE(IsAligned(1, 3));
90 E : EXPECT_FALSE(IsAligned(7, 3));
91 E : EXPECT_TRUE(IsAligned(3, 3));
92 :
93 E : EXPECT_TRUE(IsAligned(0, 7));
94 E : EXPECT_TRUE(IsAligned(14, 7));
95 E : EXPECT_FALSE(IsAligned(13, 7));
96 :
97 E : EXPECT_FALSE(IsAligned(1234, 0x8000123));
98 E : EXPECT_TRUE(IsAligned(0x8000123, 0x8000123));
99 E : EXPECT_FALSE(IsAligned(0x8000124, 0x8000123));
100 E : }
101 :
102 E : TEST(AlignTest, IsPowerOfTwo64) {
103 E : EXPECT_FALSE(IsPowerOfTwo64(0));
104 E : EXPECT_TRUE(IsPowerOfTwo64(1));
105 E : EXPECT_TRUE(IsPowerOfTwo64(2));
106 E : EXPECT_FALSE(IsPowerOfTwo64(3));
107 E : EXPECT_TRUE(IsPowerOfTwo64(4));
108 E : EXPECT_TRUE(IsPowerOfTwo64(0x80000000ULL));
109 E : EXPECT_FALSE(IsPowerOfTwo64(0x80000001ULL));
110 E : EXPECT_FALSE(IsPowerOfTwo64(0x123000000000ULL));
111 E : EXPECT_FALSE(IsPowerOfTwo64(0x123000000001ULL));
112 E : EXPECT_TRUE(IsPowerOfTwo64(0x100000000000ULL));
113 E : EXPECT_TRUE(IsPowerOfTwo64(0x200000000000ULL));
114 E : EXPECT_FALSE(IsPowerOfTwo64(0x100000000001ULL));
115 E : EXPECT_FALSE(IsPowerOfTwo64(0x200000000002ULL));
116 E : EXPECT_TRUE(IsPowerOfTwo64(0x8000000000000000ULL));
117 E : EXPECT_FALSE(IsPowerOfTwo64(0x8000000000000001ULL));
118 E : }
119 :
120 E : TEST(AlignTest, AlignUp64) {
121 : // Try power of two alignments.
122 E : EXPECT_EQ(0, AlignUp64(0, 1));
123 E : EXPECT_EQ(1, AlignUp64(1, 1));
124 :
125 E : EXPECT_EQ(0, AlignUp64(0, 2));
126 E : EXPECT_EQ(2, AlignUp64(1, 2));
127 :
128 E : EXPECT_EQ(0x8000000, AlignUp64(3, 0x8000000));
129 E : EXPECT_EQ(0x8000000, AlignUp64(0x8000000, 0x8000000));
130 :
131 : // And non-power of two alignments.
132 E : EXPECT_EQ(0, AlignUp64(0, 3));
133 E : EXPECT_EQ(3, AlignUp64(1, 3));
134 :
135 E : EXPECT_EQ(0, AlignUp64(0, 7));
136 E : EXPECT_EQ(7, AlignUp64(1, 7));
137 :
138 E : EXPECT_EQ(0, AlignUp64(0, 0x8000123));
139 E : EXPECT_EQ(0x8000123, AlignUp64(3, 0x8000123));
140 :
141 : // Try alignments of huge values.
142 E : EXPECT_EQ(0x1000000004ULL, AlignUp64(0x1000000001ULL, 4));
143 E : EXPECT_EQ(0x1000000002ULL, AlignUp64(0x1000000001ULL, 2));
144 E : EXPECT_EQ(0x1000000001ULL, AlignUp64(0x1000000001ULL, 1));
145 E : EXPECT_EQ(0xCCCCCCCCABCDABD0ULL, AlignUp64(0xCCCCCCCCABCDABCDULL, 16));
146 E : }
147 :
148 E : TEST(AlignTest, AlignDown64) {
149 : // Try power of two alignments.
150 E : EXPECT_EQ(0, AlignDown64(0, 1));
151 E : EXPECT_EQ(1, AlignDown64(1, 1));
152 :
153 E : EXPECT_EQ(0, AlignDown64(0, 2));
154 E : EXPECT_EQ(0, AlignDown64(1, 2));
155 :
156 E : EXPECT_EQ(0x8000000, AlignDown64(0x8000000, 0x8000000));
157 E : EXPECT_EQ(0x8000000, AlignDown64(0x8000003, 0x8000000));
158 :
159 : // And non-power of two alignments.
160 E : EXPECT_EQ(0, AlignDown64(0, 3));
161 E : EXPECT_EQ(0, AlignDown64(1, 3));
162 E : EXPECT_EQ(6, AlignDown64(7, 3));
163 :
164 E : EXPECT_EQ(0, AlignDown64(0, 7));
165 E : EXPECT_EQ(14, AlignDown64(14, 7));
166 :
167 E : EXPECT_EQ(0, AlignDown64(1234, 0x8000123));
168 E : EXPECT_EQ(0x8000123, AlignDown64(0x8000123, 0x8000123));
169 E : EXPECT_EQ(0x8000123, AlignDown64(0x8000124, 0x8000123));
170 :
171 : // Try alignments of huge values.
172 E : EXPECT_EQ(0x1000000000ULL, AlignDown64(0x1000000001ULL, 4));
173 E : EXPECT_EQ(0x1000000000ULL, AlignDown64(0x1000000001ULL, 2));
174 E : EXPECT_EQ(0x1000000001ULL, AlignDown64(0x1000000001ULL, 1));
175 E : EXPECT_EQ(0xCCCCCCCCABCDABC0ULL, AlignDown64(0xCCCCCCCCABCDABCDULL, 16));
176 E : }
177 :
178 E : TEST(AlignTest, IsAligned64) {
179 : // Try power of two alignments.
180 E : EXPECT_TRUE(IsAligned64(0, 1));
181 E : EXPECT_TRUE(IsAligned64(1, 1));
182 :
183 E : EXPECT_TRUE(IsAligned64(0, 2));
184 E : EXPECT_FALSE(IsAligned64(1, 2));
185 :
186 E : EXPECT_TRUE(IsAligned64(0x8000000, 0x8000000));
187 E : EXPECT_FALSE(IsAligned64(0x8000003, 0x8000000));
188 :
189 : // And non-power of two alignments.
190 E : EXPECT_TRUE(IsAligned64(0, 3));
191 E : EXPECT_FALSE(IsAligned64(1, 3));
192 E : EXPECT_FALSE(IsAligned64(7, 3));
193 E : EXPECT_TRUE(IsAligned64(3, 3));
194 :
195 E : EXPECT_TRUE(IsAligned64(0, 7));
196 E : EXPECT_TRUE(IsAligned64(14, 7));
197 E : EXPECT_FALSE(IsAligned64(13, 7));
198 :
199 E : EXPECT_FALSE(IsAligned64(1234, 0x8000123));
200 E : EXPECT_TRUE(IsAligned64(0x8000123, 0x8000123));
201 E : EXPECT_FALSE(IsAligned64(0x8000124, 0x8000123));
202 :
203 : // Try alignments of huge values.
204 E : EXPECT_FALSE(IsAligned64(0x1000000001ULL, 4));
205 E : EXPECT_FALSE(IsAligned64(0x1000000001ULL, 2));
206 E : EXPECT_TRUE(IsAligned64(0x1000000002ULL, 2));
207 E : EXPECT_TRUE(IsAligned64(0x1000000001ULL, 1));
208 E : EXPECT_FALSE(IsAligned64(0xCCCCCCCCABCDABCDULL, 16));
209 E : EXPECT_TRUE(IsAligned64(0xCCCCCCCCABCDABC0ULL, 16));
210 E : }
211 :
212 : } // namespace common
|