1 /*
2 * This testing program makes sure the bitops functions work
3 *
4 * Copyright (C) 2001 by Theodore Ts'o.
5 *
6 * %Begin-Header%
7 * This file may be redistributed under the terms of the GNU Library
8 * General Public License, version 2.
9 * %End-Header%
10 */
11
12 #include "config.h"
13 #include <stdio.h>
14 #include <string.h>
15 #if HAVE_UNISTD_H
16 #include <unistd.h>
17 #endif
18 #include <fcntl.h>
19 #include <time.h>
20 #include <sys/stat.h>
21 #include <sys/types.h>
22 #if HAVE_ERRNO_H
23 #include <errno.h>
24 #endif
25 #include <sys/time.h>
26 #include <sys/resource.h>
27
28 #include "ext2_fs.h"
29 #include "ext2fs.h"
30
31 unsigned char bitarray[] = {
32 0x80, 0xF0, 0x40, 0x40, 0x0, 0x0, 0x0, 0x0, 0x10, 0x20, 0x00, 0x00
33 };
34
35 int bits_list[] = {
36 7, 12, 13, 14,15, 22, 30, 68, 77, -1,
37 };
38
39 #define BIG_TEST_BIT (((unsigned) 1 << 31) + 42)
40
41
main(int argc,char ** argv)42 int main(int argc, char **argv)
43 {
44 int i, j, size;
45 unsigned char testarray[12];
46 unsigned char *bigarray;
47
48 size = sizeof(bitarray)*8;
49 #if 0
50 i = ext2fs_find_first_bit_set(bitarray, size);
51 while (i < size) {
52 printf("Bit set: %d\n", i);
53 i = ext2fs_find_next_bit_set(bitarray, size, i+1);
54 }
55 #endif
56
57 /* Test test_bit */
58 for (i=0,j=0; i < size; i++) {
59 if (ext2fs_test_bit(i, bitarray)) {
60 if (bits_list[j] == i) {
61 j++;
62 } else {
63 printf("Bit %d set, not expected\n", i);
64 exit(1);
65 }
66 } else {
67 if (bits_list[j] == i) {
68 printf("Expected bit %d to be clear.\n", i);
69 exit(1);
70 }
71 }
72 }
73 printf("ext2fs_test_bit appears to be correct\n");
74
75 /* Test ext2fs_set_bit */
76 memset(testarray, 0, sizeof(testarray));
77 for (i=0; bits_list[i] > 0; i++) {
78 ext2fs_set_bit(bits_list[i], testarray);
79 }
80 if (memcmp(testarray, bitarray, sizeof(testarray)) == 0) {
81 printf("ext2fs_set_bit test succeeded.\n");
82 } else {
83 printf("ext2fs_set_bit test failed.\n");
84 for (i=0; i < sizeof(testarray); i++) {
85 printf("%02x ", testarray[i]);
86 }
87 printf("\n");
88 exit(1);
89 }
90 for (i=0; bits_list[i] > 0; i++) {
91 ext2fs_clear_bit(bits_list[i], testarray);
92 }
93 for (i=0; i < sizeof(testarray); i++) {
94 if (testarray[i]) {
95 printf("ext2fs_clear_bit failed, "
96 "testarray[%d] is %d\n", i, testarray[i]);
97 exit(1);
98 }
99 }
100 printf("ext2fs_clear_bit test succeed.\n");
101
102
103 /* Do bigarray test */
104 bigarray = malloc(1 << 29);
105 if (!bigarray) {
106 fprintf(stderr, "Failed to allocate scratch memory!\n");
107 exit(0);
108 }
109
110 bigarray[BIG_TEST_BIT >> 3] = 0;
111
112 ext2fs_set_bit(BIG_TEST_BIT, bigarray);
113 printf("big bit number (%u) test: %d, expected %d\n", BIG_TEST_BIT,
114 bigarray[BIG_TEST_BIT >> 3], (1 << (BIG_TEST_BIT & 7)));
115 if (bigarray[BIG_TEST_BIT >> 3] != (1 << (BIG_TEST_BIT & 7)))
116 exit(1);
117
118 ext2fs_clear_bit(BIG_TEST_BIT, bigarray);
119
120 printf("big bit number (%u) test: %d, expected 0\n", BIG_TEST_BIT,
121 bigarray[BIG_TEST_BIT >> 3]);
122 if (bigarray[BIG_TEST_BIT >> 3] != 0)
123 exit(1);
124
125 printf("ext2fs_set_bit big_test successful\n");
126
127
128 /* Now test ext2fs_fast_set_bit */
129 memset(testarray, 0, sizeof(testarray));
130 for (i=0; bits_list[i] > 0; i++) {
131 ext2fs_fast_set_bit(bits_list[i], testarray);
132 }
133 if (memcmp(testarray, bitarray, sizeof(testarray)) == 0) {
134 printf("ext2fs_fast_set_bit test succeeded.\n");
135 } else {
136 printf("ext2fs_fast_set_bit test failed.\n");
137 for (i=0; i < sizeof(testarray); i++) {
138 printf("%02x ", testarray[i]);
139 }
140 printf("\n");
141 exit(1);
142 }
143 for (i=0; bits_list[i] > 0; i++) {
144 ext2fs_clear_bit(bits_list[i], testarray);
145 }
146 for (i=0; i < sizeof(testarray); i++) {
147 if (testarray[i]) {
148 printf("ext2fs_clear_bit failed, "
149 "testarray[%d] is %d\n", i, testarray[i]);
150 exit(1);
151 }
152 }
153 printf("ext2fs_clear_bit test succeed.\n");
154
155
156 bigarray[BIG_TEST_BIT >> 3] = 0;
157
158 ext2fs_fast_set_bit(BIG_TEST_BIT, bigarray);
159 printf("big bit number (%u) test: %d, expected %d\n", BIG_TEST_BIT,
160 bigarray[BIG_TEST_BIT >> 3], (1 << (BIG_TEST_BIT & 7)));
161 if (bigarray[BIG_TEST_BIT >> 3] != (1 << (BIG_TEST_BIT & 7)))
162 exit(1);
163
164 ext2fs_fast_clear_bit(BIG_TEST_BIT, bigarray);
165
166 printf("big bit number (%u) test: %d, expected 0\n", BIG_TEST_BIT,
167 bigarray[BIG_TEST_BIT >> 3]);
168 if (bigarray[BIG_TEST_BIT >> 3] != 0)
169 exit(1);
170
171 printf("ext2fs_fast_set_bit big_test successful\n");
172
173 /* Repeat foregoing tests for 64-bit bitops */
174
175 /* Test test_bit */
176 for (i=0,j=0; i < size; i++) {
177 if (ext2fs_test_bit64(i, bitarray)) {
178 if (bits_list[j] == i) {
179 j++;
180 } else {
181 printf("64-bit: Bit %d set, not expected\n",
182 i);
183 exit(1);
184 }
185 } else {
186 if (bits_list[j] == i) {
187 printf("64-bit: "
188 "Expected bit %d to be clear.\n", i);
189 exit(1);
190 }
191 }
192 }
193 printf("64-bit: ext2fs_test_bit appears to be correct\n");
194
195 /* Test ext2fs_set_bit */
196 memset(testarray, 0, sizeof(testarray));
197 for (i=0; bits_list[i] > 0; i++) {
198 ext2fs_set_bit64(bits_list[i], testarray);
199 }
200 if (memcmp(testarray, bitarray, sizeof(testarray)) == 0) {
201 printf("64-bit: ext2fs_set_bit test succeeded.\n");
202 } else {
203 printf("64-bit: ext2fs_set_bit test failed.\n");
204 for (i=0; i < sizeof(testarray); i++) {
205 printf("%02x ", testarray[i]);
206 }
207 printf("\n");
208 exit(1);
209 }
210 for (i=0; bits_list[i] > 0; i++) {
211 ext2fs_clear_bit64(bits_list[i], testarray);
212 }
213 for (i=0; i < sizeof(testarray); i++) {
214 if (testarray[i]) {
215 printf("64-bit: ext2fs_clear_bit failed, "
216 "testarray[%d] is %d\n", i, testarray[i]);
217 exit(1);
218 }
219 }
220 printf("64-bit: ext2fs_clear_bit test succeed.\n");
221
222 /* Do bigarray test */
223 bigarray[BIG_TEST_BIT >> 3] = 0;
224
225 ext2fs_set_bit64(BIG_TEST_BIT, bigarray);
226 printf("64-bit: big bit number (%u) test: %d, expected %d\n",
227 BIG_TEST_BIT, bigarray[BIG_TEST_BIT >> 3],
228 (1 << (BIG_TEST_BIT & 7)));
229 if (bigarray[BIG_TEST_BIT >> 3] != (1 << (BIG_TEST_BIT & 7)))
230 exit(1);
231
232 ext2fs_clear_bit64(BIG_TEST_BIT, bigarray);
233
234 printf("64-bit: big bit number (%u) test: %d, expected 0\n",
235 BIG_TEST_BIT,
236 bigarray[BIG_TEST_BIT >> 3]);
237 if (bigarray[BIG_TEST_BIT >> 3] != 0)
238 exit(1);
239
240 printf("64-bit: ext2fs_set_bit big_test successful\n");
241
242 /* Now test ext2fs_fast_set_bit */
243 memset(testarray, 0, sizeof(testarray));
244 for (i=0; bits_list[i] > 0; i++) {
245 ext2fs_fast_set_bit64(bits_list[i], testarray);
246 }
247 if (memcmp(testarray, bitarray, sizeof(testarray)) == 0) {
248 printf("64-bit: ext2fs_fast_set_bit test succeeded.\n");
249 } else {
250 printf("64-bit: ext2fs_fast_set_bit test failed.\n");
251 for (i=0; i < sizeof(testarray); i++) {
252 printf("%02x ", testarray[i]);
253 }
254 printf("\n");
255 exit(1);
256 }
257 for (i=0; bits_list[i] > 0; i++) {
258 ext2fs_clear_bit64(bits_list[i], testarray);
259 }
260 for (i=0; i < sizeof(testarray); i++) {
261 if (testarray[i]) {
262 printf("64-bit: ext2fs_clear_bit failed, "
263 "testarray[%d] is %d\n", i, testarray[i]);
264 exit(1);
265 }
266 }
267 printf("64-bit: ext2fs_clear_bit test succeed.\n");
268
269 bigarray[BIG_TEST_BIT >> 3] = 0;
270
271 ext2fs_fast_set_bit64(BIG_TEST_BIT, bigarray);
272 printf("64-bit: big bit number (%u) test: %d, expected %d\n",
273 BIG_TEST_BIT, bigarray[BIG_TEST_BIT >> 3],
274 (1 << (BIG_TEST_BIT & 7)));
275 if (bigarray[BIG_TEST_BIT >> 3] != (1 << (BIG_TEST_BIT & 7)))
276 exit(1);
277
278 ext2fs_fast_clear_bit64(BIG_TEST_BIT, bigarray);
279
280 printf("64-bit: big bit number (%u) test: %d, expected 0\n",
281 BIG_TEST_BIT, bigarray[BIG_TEST_BIT >> 3]);
282 if (bigarray[BIG_TEST_BIT >> 3] != 0)
283 exit(1);
284
285 printf("64-bit: ext2fs_fast_set_bit big_test successful\n");
286 free(bigarray);
287 exit(0);
288 }
289