Return to buffer_test.c CVS log

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

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

1.1     ! misho       1: /*
        !             2:  *     BIRD Library -- Buffer 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 <stdlib.h>
        !            10: 
        !            11: #include "test/birdtest.h"
        !            12: 
        !            13: #include "lib/buffer.h"
        !            14: 
        !            15: #define MAX_NUM 33
        !            16: 
        !            17: typedef BUFFER(int) buffer_int;
        !            18: static int expected[MAX_NUM];
        !            19: static buffer_int buf;
        !            20: static struct pool *buffer_pool;
        !            21: 
        !            22: static void
        !            23: show_buf(buffer_int *b)
        !            24: {
        !            25:   uint i;
        !            26:   bt_debug(".used = %d, .size = %d\n", b->used, b->size);
        !            27: 
        !            28:   for (i = 0; i < b->used; i++)
        !            29:     bt_debug("  .data[%3u] = %-16d  expected %-16d  %s\n", i, b->data[i], expected[i], (b->data[i] == expected[i] ? "OK" : "FAIL!"));
        !            30: }
        !            31: 
        !            32: static void
        !            33: fill_expected_array(void)
        !            34: {
        !            35:   int i;
        !            36: 
        !            37:   for (i = 0; i < MAX_NUM; i++)
        !            38:     expected[i] = bt_random();
        !            39: }
        !            40: 
        !            41: static void
        !            42: init_buffer(void)
        !            43: {
        !            44:   resource_init();
        !            45:   buffer_pool = &root_pool;
        !            46:   BUFFER_INIT(buf, buffer_pool, MAX_NUM);
        !            47: }
        !            48: 
        !            49: static int
        !            50: is_buffer_as_expected(buffer_int *b)
        !            51: {
        !            52:   show_buf(b);
        !            53: 
        !            54:   int i;
        !            55:   for (i = 0; i < MAX_NUM; i++)
        !            56:     bt_assert(b->data[i] == expected[i]);
        !            57:   return 1;
        !            58: }
        !            59: 
        !            60: static int
        !            61: t_buffer_push(void)
        !            62: {
        !            63:   int i;
        !            64: 
        !            65:   init_buffer();
        !            66:   fill_expected_array();
        !            67: 
        !            68:   for (i = 0; i < MAX_NUM; i++)
        !            69:     BUFFER_PUSH(buf) = expected[i];
        !            70:   is_buffer_as_expected(&buf);
        !            71: 
        !            72:   return 1;
        !            73: }
        !            74: 
        !            75: static int
        !            76: t_buffer_pop(void)
        !            77: {
        !            78:   int i;
        !            79: 
        !            80:   init_buffer();
        !            81:   fill_expected_array();
        !            82: 
        !            83:   /* POP a half of elements */
        !            84:   for (i = 0; i < MAX_NUM; i++)
        !            85:     BUFFER_PUSH(buf) = expected[i];
        !            86:   for (i = MAX_NUM-1; i >= MAX_NUM/2; i--)
        !            87:     BUFFER_POP(buf);
        !            88:   for (i = MAX_NUM/2; i < MAX_NUM; i++)
        !            89:     BUFFER_PUSH(buf) = expected[i] = bt_random();
        !            90:   is_buffer_as_expected(&buf);
        !            91: 
        !            92:   /* POP all of elements */
        !            93:   for (i = MAX_NUM-1; i >= 0; i--)
        !            94:     BUFFER_POP(buf);
        !            95:   bt_assert(buf.used == 0);
        !            96:   for (i = 0; i < MAX_NUM; i++)
        !            97:     BUFFER_PUSH(buf) = expected[i];
        !            98:   is_buffer_as_expected(&buf);
        !            99: 
        !           100:   return 1;
        !           101: }
        !           102: 
        !           103: static int
        !           104: t_buffer_resize(void)
        !           105: {
        !           106:   int i;
        !           107: 
        !           108:   init_buffer();
        !           109:   BUFFER_INIT(buf, buffer_pool, 0);
        !           110:   fill_expected_array();
        !           111: 
        !           112:   for (i = 0; i < MAX_NUM; i++)
        !           113:     BUFFER_PUSH(buf) = expected[i];
        !           114:   is_buffer_as_expected(&buf);
        !           115:   bt_assert(buf.size >= MAX_NUM);
        !           116: 
        !           117:   return 1;
        !           118: }
        !           119: 
        !           120: static int
        !           121: t_buffer_flush(void)
        !           122: {
        !           123:   int i;
        !           124: 
        !           125:   init_buffer();
        !           126:   fill_expected_array();
        !           127:   for (i = 0; i < MAX_NUM; i++)
        !           128:     BUFFER_PUSH(buf) = expected[i];
        !           129: 
        !           130:   BUFFER_FLUSH(buf);
        !           131:   bt_assert(buf.used == 0);
        !           132: 
        !           133:   return 1;
        !           134: }
        !           135: 
        !           136: static int
        !           137: t_buffer_walk(void)
        !           138: {
        !           139:   int i;
        !           140: 
        !           141:   init_buffer();
        !           142:   fill_expected_array();
        !           143:   for (i = 0; i < MAX_NUM; i++)
        !           144:     BUFFER_PUSH(buf) = expected[i];
        !           145: 
        !           146:   i = 0;
        !           147:   BUFFER_WALK(buf, v)
        !           148:     bt_assert(v == expected[i++]);
        !           149: 
        !           150:   bt_assert(i == MAX_NUM);
        !           151: 
        !           152:   return 1;
        !           153: }
        !           154: 
        !           155: int
        !           156: main(int argc, char *argv[])
        !           157: {
        !           158:   bt_init(argc, argv);
        !           159: 
        !           160:   bt_test_suite(t_buffer_push, "Pushing new elements");
        !           161:   bt_test_suite(t_buffer_pop, "Fill whole buffer (PUSH), a half of elements POP and PUSH new elements");
        !           162:   bt_test_suite(t_buffer_resize, "Init a small buffer and try overfill");
        !           163:   bt_test_suite(t_buffer_flush, "Fill and flush all elements");
        !           164:   bt_test_suite(t_buffer_walk, "Fill and walk through buffer");
        !           165: 
        !           166:   return bt_exit_value();
        !           167: }