lib/ext2fs/tst_bitops.c

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