update changelog
[debian/iodine.git] / tests / base32.c
1 /*
2  * Copyright (c) 2006-2009 Bjorn Andersson <flex@kryo.se>, Erik Ekman <yarrick@kryo.se>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16
17 #include <check.h>
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <errno.h>
22
23 #include "encoding.h"
24 #include "base32.h"
25 #include "test.h"
26
27 #define TUPLES 5
28
29 static struct tuple
30 {
31         char *a;
32         char *b;
33 } testpairs[TUPLES] = {
34         { "iodinetestingtesting", "nfxwi0lomv0gk21unfxgo3dfon0gs1th" },
35         { "abc123", "mfrggmjsgm" },
36         { "test", "orsxg3a" },
37         { "tst", "orzxi" },
38         { "", "" },
39 };
40
41 START_TEST(test_base32_encode)
42 {
43         size_t len;
44         char buf[4096];
45         struct encoder *b32;
46         int val;
47
48         b32 = get_base32_encoder();
49
50         len = sizeof(buf);
51         val = b32->encode(buf, &len, testpairs[_i].a, strlen(testpairs[_i].a));
52
53         fail_unless(strcmp(buf, testpairs[_i].b) == 0,
54                         "'%s' != '%s'", buf, testpairs[_i].b);
55 }
56 END_TEST
57
58 START_TEST(test_base32_decode)
59 {
60         size_t len;
61         char buf[4096];
62         struct encoder *b32;
63         int val;
64         
65         b32 = get_base32_encoder();
66
67         len = sizeof(buf);
68         val = b32->decode(buf, &len, testpairs[_i].b, strlen(testpairs[_i].b));
69
70         fail_unless(buf != NULL, "buf == NULL");
71         fail_unless(strcmp(buf, testpairs[_i].a) == 0,
72                         "'%s' != '%s'", buf, testpairs[_i].a);
73 }
74 END_TEST
75
76 START_TEST(test_base32_5to8_8to5)
77 {
78         int i;
79         int c;
80
81         for (i = 0; i < 32; i++) {
82                 c = b32_5to8(i);        
83                 fail_unless(b32_8to5(c) == i);
84         }
85 }
86 END_TEST
87
88 START_TEST(test_base32_blksize)
89 {
90         size_t rawlen;
91         size_t enclen;
92         char *rawbuf;
93         char *encbuf;
94         struct encoder *b32;
95         int i;
96         int val;
97
98         b32 = get_base32_encoder();
99
100         rawlen = b32->blocksize_raw();
101         enclen = b32->blocksize_encoded();
102
103         rawbuf = malloc(rawlen + 16);
104         encbuf = malloc(enclen + 16);
105
106         for (i = 0; i < rawlen; i++) {
107                 rawbuf[i] = 'A';
108         }
109         rawbuf[i] = 0;
110
111         val = b32->encode(encbuf, &enclen, rawbuf, rawlen);
112
113         fail_unless(rawlen == 5, "raw length was %d not 5", rawlen);
114         fail_unless(enclen == 5, "encoded %d bytes, not 5", enclen);
115         fail_unless(val == 8, "encoded string %s was length %d", encbuf, val);
116
117         memset(rawbuf, 0, rawlen + 16);
118
119         enclen = val;
120         val = b32->decode(rawbuf, &rawlen, encbuf, enclen);
121
122         fail_unless(rawlen == 5, "raw length was %d not 5", rawlen);
123         fail_unless(val == 5, "val was not 5 but %d", val);
124         for (i = 0; i < rawlen; i++) {
125                 fail_unless(rawbuf[i] == 'A');
126         }
127 }
128 END_TEST
129
130 TCase *
131 test_base32_create_tests()
132 {
133         TCase *tc;
134
135         tc = tcase_create("Base32");
136         tcase_add_loop_test(tc, test_base32_encode, 0, TUPLES);
137         tcase_add_loop_test(tc, test_base32_decode, 0, TUPLES);
138         tcase_add_test(tc, test_base32_5to8_8to5);
139         tcase_add_test(tc, test_base32_blksize);
140
141         return tc;
142 }