Return to fletcher16_test.c CVS log

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

Annotation of embedaddon/bird2/lib/fletcher16_test.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  *     BIRD Library -- Fletcher-16 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 "lib/fletcher16.h"
                     11: 
                     12: static u16
                     13: straightforward_fletcher16_compute(const char *data)
                     14: {
                     15:   int count = strlen(data);
                     16: 
                     17:   u16 sum1 = 0;
                     18:   u16 sum2 = 0;
                     19:   int index;
                     20: 
                     21:   for (index = 0; index < count; ++index)
                     22:   {
                     23:     sum1 = (sum1 + data[index]) % 255;
                     24:     sum2 = (sum2 + sum1) % 255;
                     25:   }
                     26: 
                     27:   return (sum2 << 8) | sum1;
                     28: }
                     29: 
                     30: static u16
                     31: straightforward_fletcher16_checksum(const char *data)
                     32: {
                     33:   u16 csum;
                     34:   u8 c0,c1,f0,f1;
                     35: 
                     36:   csum = straightforward_fletcher16_compute(data);
                     37:   f0 = csum & 0xff;
                     38:   f1 = (csum >> 8) & 0xff;
                     39:   c0 = 0xff - ((f0 + f1) % 0xff);
                     40:   c1 = 0xff - ((f0 + c0) % 0xff);
                     41: 
                     42:   return (c1 << 8) | c0;
                     43: }
                     44: 
                     45: static int
                     46: test_fletcher16(void *out_, const void *in_, const void *expected_out_)
                     47: {
                     48:   u16 *out = out_;
                     49:   const char *in = in_;
                     50:   const u16 *expected_out = expected_out_;
                     51: 
                     52:   struct fletcher16_context ctxt;
                     53: 
                     54:   fletcher16_init(&ctxt);
                     55:   fletcher16_update(&ctxt, in, strlen(in));
                     56:   put_u16(out, fletcher16_compute(&ctxt));
                     57: 
                     58:   return *out == *expected_out;
                     59: }
                     60: 
                     61: static int
                     62: test_fletcher16_checksum(void *out_, const void *in_, const void *expected_out_)
                     63: {
                     64:   u16 *out = out_;
                     65:   const char *in = in_;
                     66:   const u16 *expected_out = expected_out_;
                     67: 
                     68:   struct fletcher16_context ctxt;
                     69:   int len = strlen(in);
                     70: 
                     71:   fletcher16_init(&ctxt);
                     72:   fletcher16_update(&ctxt, in, len);
                     73:   put_u16(out, fletcher16_final(&ctxt, len, len));
                     74: 
                     75:   return *out == *expected_out;
                     76: }
                     77: 
                     78: static int
                     79: t_fletcher16_compute(void)
                     80: {
                     81:   struct bt_pair test_vectors[] = {
                     82:     {
                     83:       .in  = "\001\002",
                     84:       .out = & (const u16) { 0x0403 },
                     85:     },
                     86:     {
                     87:       .in  = "",
                     88:       .out = & ((const u16) { straightforward_fletcher16_compute("") }),
                     89:     },
                     90:     {
                     91:       .in  = "a",
                     92:       .out = & ((const u16) { straightforward_fletcher16_compute("a") }),
                     93:     },
                     94:     {
                     95:       .in  = "abcd",
                     96:       .out = & ((const u16) { straightforward_fletcher16_compute("abcd") }),
                     97:     },
                     98:     {
                     99:       .in  = "message digest",
                    100:       .out = & ((const u16) { straightforward_fletcher16_compute("message digest") }),
                    101:     },
                    102:     {
                    103:       .in  = "abcdefghijklmnopqrstuvwxyz",
                    104:       .out = & ((const u16) { straightforward_fletcher16_compute("abcdefghijklmnopqrstuvwxyz") }),
                    105:     },
                    106:     {
                    107:       .in  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
                    108:       .out = & ((const u16) { straightforward_fletcher16_compute("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") }),
                    109:     },
                    110:     {
                    111:       .in  = "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
                    112:       .out = & ((const u16) { straightforward_fletcher16_compute("12345678901234567890123456789012345678901234567890123456789012345678901234567890") }),
                    113:     },
                    114:   };
                    115: 
                    116:   return bt_assert_batch(test_vectors, test_fletcher16, bt_fmt_str, bt_fmt_unsigned);
                    117: }
                    118: 
                    119: static int
                    120: t_fletcher16_checksum(void)
                    121: {
                    122:   struct bt_pair test_vectors[] = {
                    123:     {
                    124:       .in  = "\001\002",
                    125:       .out =  & ((const u16) { straightforward_fletcher16_checksum("\001\002") }),
                    126:     },
                    127:     {
                    128:       .in  = "",
                    129:       .out =  & ((const u16) { straightforward_fletcher16_checksum("") }),
                    130:     },
                    131:     {
                    132:       .in  = "a",
                    133:       .out =  & ((const u16) { straightforward_fletcher16_checksum("a") }),
                    134:     },
                    135:     {
                    136:       .in  = "abcd",
                    137:       .out =  & ((const u16) { straightforward_fletcher16_checksum("abcd") }),
                    138:     },
                    139:     {
                    140:       .in  = "message digest",
                    141:       .out =  & ((const u16) { straightforward_fletcher16_checksum("message digest") }),
                    142:     },
                    143:     {
                    144:       .in  = "abcdefghijklmnopqrstuvwxyz",
                    145:       .out =  & ((const u16) { straightforward_fletcher16_checksum("abcdefghijklmnopqrstuvwxyz") }),
                    146:     },
                    147:     {
                    148:       .in  = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
                    149:       .out =  & ((const u16) { straightforward_fletcher16_checksum("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") }),
                    150:     },
                    151:     {
                    152:       .in  = "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
                    153:       .out =  & ((const u16) { straightforward_fletcher16_checksum("12345678901234567890123456789012345678901234567890123456789012345678901234567890") }),
                    154:     },
                    155:   };
                    156: 
                    157:   return bt_assert_batch(test_vectors, test_fletcher16_checksum, bt_fmt_str, bt_fmt_unsigned);
                    158: }
                    159: 
                    160: int
                    161: main(int argc, char *argv[])
                    162: {
                    163:   bt_init(argc, argv);
                    164: 
                    165:   bt_test_suite(t_fletcher16_compute, "Fletcher-16 Compute Tests");
                    166:   bt_test_suite(t_fletcher16_checksum, "Fletcher-16 Checksum Tests");
                    167: 
                    168:   return bt_exit_value();
                    169: }