libext2fs: require cluster size == block_size when opening a !bigalloc fs

[tools/e2fsprogs.git] / lib / ext2fs / tst_bitops.c

diff --git a/lib/ext2fs/tst_bitops.c b/lib/ext2fs/tst_bitops.c
index fb4d3ad..f57a2e4 100644 (file)
--- a/lib/ext2fs/tst_bitops.c
+++ b/lib/ext2fs/tst_bitops.c
@@ -2,15 +2,13 @@
  * This testing program makes sure the bitops functions work
  *
  * Copyright (C) 2001 by Theodore Ts'o.
- * 
+ *
  * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
+ * This file may be redistributed under the terms of the GNU Library
+ * General Public License, version 2.
  * %End-Header%
  */
 
-/* #define _EXT2_USE_C_VERSIONS_ */
-
 #include <stdio.h>
 #include <string.h>
 #if HAVE_UNISTD_H
@@ -23,6 +21,8 @@
 #if HAVE_ERRNO_H
 #include <errno.h>
 #endif
+#include <sys/time.h>
+#include <sys/resource.h>
 
 #include "ext2_fs.h"
 #include "ext2fs.h"
@@ -31,14 +31,143 @@ unsigned char bitarray[] = {
        0x80, 0xF0, 0x40, 0x40, 0x0, 0x0, 0x0, 0x0, 0x10, 0x20, 0x00, 0x00
        };
 
-main(int argc, char **argv)
+int bits_list[] = {
+       7, 12, 13, 14,15, 22, 30, 68, 77, -1,
+};
+
+#define BIG_TEST_BIT   (((unsigned) 1 << 31) + 42)
+
+
+int main(int argc, char **argv)
 {
-       int     i, size;
+       int     i, j, size;
+       unsigned char testarray[12];
+       unsigned char *bigarray;
 
        size = sizeof(bitarray)*8;
+#if 0
        i = ext2fs_find_first_bit_set(bitarray, size);
        while (i < size) {
                printf("Bit set: %d\n", i);
                i = ext2fs_find_next_bit_set(bitarray, size, i+1);
        }
+#endif
+
+       /* Test test_bit */
+       for (i=0,j=0; i < size; i++) {
+               if (ext2fs_test_bit(i, bitarray)) {
+                       if (bits_list[j] == i) {
+                               j++;
+                       } else {
+                               printf("Bit %d set, not expected\n", i);
+                               exit(1);
+                       }
+               } else {
+                       if (bits_list[j] == i) {
+                               printf("Expected bit %d to be clear.\n", i);
+                               exit(1);
+                       }
+               }
+       }
+       printf("ext2fs_test_bit appears to be correct\n");
+
+       /* Test ext2fs_set_bit */
+       memset(testarray, 0, sizeof(testarray));
+       for (i=0; bits_list[i] > 0; i++) {
+               ext2fs_set_bit(bits_list[i], testarray);
+       }
+       if (memcmp(testarray, bitarray, sizeof(testarray)) == 0) {
+               printf("ext2fs_set_bit test succeeded.\n");
+       } else {
+               printf("ext2fs_set_bit test failed.\n");
+               for (i=0; i < sizeof(testarray); i++) {
+                       printf("%02x ", testarray[i]);
+               }
+               printf("\n");
+               exit(1);
+       }
+       for (i=0; bits_list[i] > 0; i++) {
+               ext2fs_clear_bit(bits_list[i], testarray);
+       }
+       for (i=0; i < sizeof(testarray); i++) {
+               if (testarray[i]) {
+                       printf("ext2fs_clear_bit failed, "
+                              "testarray[%d] is %d\n", i, testarray[i]);
+                       exit(1);
+               }
+       }
+       printf("ext2fs_clear_bit test succeed.\n");
+
+
+       /* Do bigarray test */
+       bigarray = malloc(1 << 29);
+       if (!bigarray) {
+               fprintf(stderr, "Failed to allocate scratch memory!\n");
+               exit(1);
+       }
+
+        bigarray[BIG_TEST_BIT >> 3] = 0;
+
+       ext2fs_set_bit(BIG_TEST_BIT, bigarray);
+       printf("big bit number (%u) test: %d, expected %d\n", BIG_TEST_BIT,
+              bigarray[BIG_TEST_BIT >> 3], (1 << (BIG_TEST_BIT & 7)));
+       if (bigarray[BIG_TEST_BIT >> 3] != (1 << (BIG_TEST_BIT & 7)))
+               exit(1);
+
+       ext2fs_clear_bit(BIG_TEST_BIT, bigarray);
+
+       printf("big bit number (%u) test: %d, expected 0\n", BIG_TEST_BIT,
+              bigarray[BIG_TEST_BIT >> 3]);
+       if (bigarray[BIG_TEST_BIT >> 3] != 0)
+               exit(1);
+
+       printf("ext2fs_set_bit big_test successful\n");
+
+
+       /* Now test ext2fs_fast_set_bit */
+       memset(testarray, 0, sizeof(testarray));
+       for (i=0; bits_list[i] > 0; i++) {
+               ext2fs_fast_set_bit(bits_list[i], testarray);
+       }
+       if (memcmp(testarray, bitarray, sizeof(testarray)) == 0) {
+               printf("ext2fs_fast_set_bit test succeeded.\n");
+       } else {
+               printf("ext2fs_fast_set_bit test failed.\n");
+               for (i=0; i < sizeof(testarray); i++) {
+                       printf("%02x ", testarray[i]);
+               }
+               printf("\n");
+               exit(1);
+       }
+       for (i=0; bits_list[i] > 0; i++) {
+               ext2fs_clear_bit(bits_list[i], testarray);
+       }
+       for (i=0; i < sizeof(testarray); i++) {
+               if (testarray[i]) {
+                       printf("ext2fs_clear_bit failed, "
+                              "testarray[%d] is %d\n", i, testarray[i]);
+                       exit(1);
+               }
+       }
+       printf("ext2fs_clear_bit test succeed.\n");
+
+
+        bigarray[BIG_TEST_BIT >> 3] = 0;
+
+       ext2fs_fast_set_bit(BIG_TEST_BIT, bigarray);
+       printf("big bit number (%u) test: %d, expected %d\n", BIG_TEST_BIT,
+              bigarray[BIG_TEST_BIT >> 3], (1 << (BIG_TEST_BIT & 7)));
+       if (bigarray[BIG_TEST_BIT >> 3] != (1 << (BIG_TEST_BIT & 7)))
+               exit(1);
+
+       ext2fs_fast_clear_bit(BIG_TEST_BIT, bigarray);
+
+       printf("big bit number (%u) test: %d, expected 0\n", BIG_TEST_BIT,
+              bigarray[BIG_TEST_BIT >> 3]);
+       if (bigarray[BIG_TEST_BIT >> 3] != 0)
+               exit(1);
+
+       printf("ext2fs_fast_set_bit big_test successful\n");
+
+       exit(0);
 }