Return to bitops_test.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / lib

Annotation of embedaddon/bird2/lib/bitops_test.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  *     BIRD Library -- Generic Bit Operations Tests
        !             3:  *
        !             4:  *     (c) 2015 CZ.NIC z.s.p.o.
        !             5:  *
        !             6:  *     Can be freely distributed and used under the terms of the GNU GPL.
        !             7:  */
        !             8: 
        !             9: #include "test/birdtest.h"
        !            10: #include "test/bt-utils.h" /* naive_pow() */
        !            11: 
        !            12: #include "lib/bitops.h"
        !            13: 
        !            14: #define MAX_NUM 1000
        !            15: #define CHECK_BIT(var,pos) ((var) & (u32)(1<<(pos)))
        !            16: 
        !            17: static int
        !            18: t_mkmask(void)
        !            19: {
        !            20:   int i;
        !            21:   u32 compute, expect;
        !            22: 
        !            23:   bt_assert(u32_mkmask(0) == 0x00000000);
        !            24:   for (i = 1; i <= 32; i++)
        !            25:   {
        !            26:     compute = u32_mkmask(i);
        !            27:     expect  = (u32) (0xffffffff << (32-i));
        !            28:     bt_assert_msg(compute == expect, "u32_mkmask(%d) = 0x%08X, expected 0x%08X", i, compute, expect);
        !            29:   }
        !            30: 
        !            31:   return 1;
        !            32: }
        !            33: 
        !            34: static int
        !            35: u32_masklen_expected(u32 mask)
        !            36: {
        !            37:   int j, expect = 0;
        !            38: 
        !            39:   int valid = 0;
        !            40:   for (j = 0; j <= 32; j++)
        !            41:     if (mask == (j ? (0xffffffff << (32-j)) : 0)) /* Shifting 32-bit value by 32 bits is undefined behavior */
        !            42:        valid = 1;
        !            43: 
        !            44:   if (!valid && mask != 0)
        !            45:     expect = 255;
        !            46:   else
        !            47:     for (j = 0; j <= 31; j++)
        !            48:       if (CHECK_BIT(mask, (31-j)))
        !            49:        expect = j+1;
        !            50:       else
        !            51:        break;
        !            52:   return expect;
        !            53: }
        !            54: 
        !            55: static void
        !            56: check_mask(u32 mask)
        !            57: {
        !            58:   int expected, masklen;
        !            59: 
        !            60:   expected = u32_masklen_expected(mask);
        !            61:   masklen = u32_masklen(mask);
        !            62:   int ok = (expected == masklen);
        !            63:   bt_debug("u32_masklen(Ox%08x) = %d, expected %d  %s\n", mask, masklen, expected, ok ? "OK" : "FAIL!");
        !            64:   bt_assert(ok);
        !            65: }
        !            66: 
        !            67: static int
        !            68: t_masklen(void)
        !            69: {
        !            70:   u32 i;
        !            71: 
        !            72:   check_mask(0x82828282);
        !            73:   check_mask(0x00000000);
        !            74: 
        !            75:   for (i = 0; i <= 32; i++)
        !            76:     check_mask(((u32) (i ? (0xffffffff << (32-i)) : 0)) & 0xffffffff); /* Shifting 32-bit value by 32 bits is undefined behavior */
        !            77: 
        !            78:   for (i = 0; i <= MAX_NUM; i++)
        !            79:     check_mask(bt_random());
        !            80: 
        !            81:   return 1;
        !            82: }
        !            83: 
        !            84: static void
        !            85: check_log2(u32 n)
        !            86: {
        !            87:   u32 log  = u32_log2(n);
        !            88:   u32 low  = bt_naive_pow(2, log);
        !            89:   u32 high = bt_naive_pow(2, log+1);
        !            90: 
        !            91:   bt_assert_msg(n >= low && n < high,
        !            92:                "u32_log2(%u) = %u, %u should be in the range <%u, %u)",
        !            93:                n, log, n, low, high);
        !            94: }
        !            95: 
        !            96: static int
        !            97: t_log2(void)
        !            98: {
        !            99:   u32 i;
        !           100: 
        !           101:   for (i = 0; i < 31; i++)
        !           102:     bt_assert(u32_log2(bt_naive_pow(2, i+1)) == i+1);
        !           103: 
        !           104:   for (i = 1; i < MAX_NUM; i++)
        !           105:     check_log2(i);
        !           106: 
        !           107:   for (i = 1; i < MAX_NUM; i++)
        !           108:     check_log2(((u32) bt_random()) % 0x0fffffff);
        !           109: 
        !           110:   return 1;
        !           111: }
        !           112: 
        !           113: int
        !           114: main(int argc, char *argv[])
        !           115: {
        !           116:   bt_init(argc, argv);
        !           117: 
        !           118:   bt_test_suite(t_mkmask, "u32_mkmask()");
        !           119:   bt_test_suite(t_masklen, "u32_masklen()");
        !           120:   bt_test_suite(t_log2, "u32_log2()");
        !           121: 
        !           122:   return bt_exit_value();
        !           123: }