1 /* Self tests for base32.
2 Copyright (C) 2004, 2008-2023 Free Software Foundation, Inc.
3 Based on the tests for base64 written by Simon Josefsson.
4 Adapted for base32 by Gijs van Tulder.
5
6 This program is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <https://www.gnu.org/licenses/>. */
18
19 #include <config.h>
20
21 #include "base32.h"
22
23 #include <stddef.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <stdint.h>
27
28 #include "macros.h"
29
30 int
31 main (void)
32 {
33 const char *in = "abcdefghijklmnop";
34 const char *b32in = "MFRGGZDFMZTWQ2LKNNWG23TPOA======";
35 char out[255];
36 idx_t len;
37 bool ok;
38 char *p;
39
40 memset (out, 0x42, sizeof (out));
41 base32_encode (in, 0, out, 0);
42 ASSERT (out[0] == '\x42');
43
44 memset (out, 0x42, sizeof (out));
45 base32_encode (in, 1, out, 10);
46 ASSERT (memcmp (out, "ME======", 1) == 0);
47
48 memset (out, 0x42, sizeof (out));
49 base32_encode (in, 1, out, 2);
50 ASSERT (memcmp (out, "ME======", 2) == 0);
51
52 memset (out, 0x42, sizeof (out));
53 base32_encode (in, 1, out, 3);
54 ASSERT (memcmp (out, "ME======", 3) == 0);
55
56 memset (out, 0x42, sizeof (out));
57 base32_encode (in, 1, out, 4);
58 ASSERT (memcmp (out, "ME======", 4) == 0);
59
60 memset (out, 0x42, sizeof (out));
61 base32_encode (in, 1, out, 8);
62 ASSERT (memcmp (out, "ME======", 8) == 0);
63
64 memset (out, 0x42, sizeof (out));
65 base32_encode (in, 2, out, 8);
66 ASSERT (memcmp (out, "MFRA====", 8) == 0);
67
68 memset (out, 0x42, sizeof (out));
69 base32_encode (in, 3, out, 8);
70 ASSERT (memcmp (out, "MFRGG===", 8) == 0);
71
72 memset (out, 0x42, sizeof (out));
73 base32_encode (in, 4, out, 8);
74 ASSERT (memcmp (out, "MFRGGZA=", 8) == 0);
75
76 memset (out, 0x42, sizeof (out));
77 base32_encode (in, 5, out, 8);
78 ASSERT (memcmp (out, "MFRGGZDF", 8) == 0);
79
80 memset (out, 0x42, sizeof (out));
81 base32_encode (in, 6, out, 16);
82 ASSERT (memcmp (out, "MFRGGZDFMY======", 16) == 0);
83
84 memset (out, 0x42, sizeof (out));
85 base32_encode (in, 6, out, 100);
86 ASSERT (memcmp (out, "MFRGGZDFMY======", 16) == 0);
87
88 /* Decode. */
89
90 memset (out, 0x42, sizeof (out));
91 len = 0;
92 ok = base32_decode (b32in, 8, out, &len);
93 ASSERT (ok);
94 ASSERT (len == 0);
95
96 memset (out, 0x42, sizeof (out));
97 len = 1;
98 ok = base32_decode (b32in, 8, out, &len);
99 ASSERT (ok);
100 ASSERT (len == 1);
101 ASSERT (memcmp (out, "abcdefghijklmnop", 1) == 0);
102
103 memset (out, 0x42, sizeof (out));
104 len = 2;
105 ok = base32_decode (b32in, 8, out, &len);
106 ASSERT (ok);
107 ASSERT (len == 2);
108 ASSERT (memcmp (out, "abcdefghijklmnop", 2) == 0);
109
110 memset (out, 0x42, sizeof (out));
111 len = 3;
112 ok = base32_decode (b32in, 8, out, &len);
113 ASSERT (ok);
114 ASSERT (len == 3);
115 ASSERT (memcmp (out, "abcdefghijklmnop", 3) == 0);
116
117 memset (out, 0x42, sizeof (out));
118 len = 4;
119 ok = base32_decode (b32in, 8, out, &len);
120 ASSERT (ok);
121 ASSERT (len == 4);
122 ASSERT (memcmp (out, "abcdefghijklmnop", 4) == 0);
123
124 memset (out, 0x42, sizeof (out));
125 len = 5;
126 ok = base32_decode (b32in, 8, out, &len);
127 ASSERT (ok);
128 ASSERT (len == 5);
129 ASSERT (memcmp (out, "abcdefghijklmnop", 5) == 0);
130
131 memset (out, 0x42, sizeof (out));
132 len = 6;
133 ok = base32_decode (b32in, 8, out, &len);
134 ASSERT (ok);
135 ASSERT (len == 5);
136 ASSERT (memcmp (out, "abcdefghijklmnop", 5) == 0);
137
138 memset (out, 0x42, sizeof (out));
139 len = 100;
140 ok = base32_decode (b32in, strlen (b32in), out, &len);
141 ASSERT (ok);
142 ASSERT (len == 16);
143 ASSERT (memcmp (out, "abcdefghijklmnop", 16) == 0);
144
145 /* Allocating encode */
146
147 len = base32_encode_alloc (in, strlen (in), &p);
148 ASSERT (len == 32);
149 ASSERT (strcmp (p, "MFRGGZDFMZTWQ2LKNNWG23TPOA======") == 0);
150 free (p);
151
152 len = base32_encode_alloc (in, IDX_MAX - 5, &p);
153 ASSERT (len == 0);
154
155 /* Decode context function */
156 {
157 struct base32_decode_context ctx;
158
159 base32_decode_ctx_init (&ctx);
160
161 len = sizeof (out);
162 ok = base32_decode_ctx (&ctx, b32in, strlen (b32in), out, &len);
163 ASSERT (ok);
164 ASSERT (len == 16);
165 ASSERT (memcmp (out, "abcdefghijklmnop", len) == 0);
166 }
167
168 /* Allocating decode context function */
169
170 ok = base32_decode_alloc_ctx (NULL, b32in, strlen (b32in), &p, &len);
171 ASSERT (ok);
172 ASSERT (len == 16);
173 ASSERT (memcmp (out, "abcdefghijklmnop", len) == 0);
174 free (p);
175
176 {
177 struct base32_decode_context ctx;
178 const char *newlineb32 = "MFRG\nGZDFMZTWQ2LKNNW\nG23TPOA======";
179
180 base32_decode_ctx_init (&ctx);
181
182 ok = base32_decode_alloc_ctx (&ctx, newlineb32, strlen (newlineb32), &p, &len);
183 ASSERT (ok);
184 ASSERT (len == strlen (in));
185 ASSERT (memcmp (p, in, len) == 0);
186 free (p);
187 }
188
189 {
190 struct base32_decode_context ctx;
191 base32_decode_ctx_init (&ctx);
192
193 ok = base32_decode_alloc_ctx (&ctx, "MFRGGZDFM\nZTWQ2LK", 17, &p, &len);
194 ASSERT (ok);
195 ASSERT (len == 10);
196 ASSERT (memcmp (p, "abcdefghij", len) == 0);
197 free (p);
198
199 base32_decode_ctx_init (&ctx);
200
201 ok = base32_decode_alloc_ctx (&ctx, "MF\n", 3, &p, &len);
202 ASSERT (ok);
203 ASSERT (len == 0);
204 free (p);
205
206 ok = base32_decode_alloc_ctx (&ctx, "RGGZDFMZ", 8, &p, &len);
207 ASSERT (ok);
208 ASSERT (len == 5);
209 ASSERT (memcmp (p, "abcde", len) == 0);
210 free (p);
211
212 ok = base32_decode_alloc_ctx (&ctx, "TWQ2LK", 6, &p, &len);
213 ASSERT (ok);
214 ASSERT (len == 5);
215 ASSERT (memcmp (p, "fghij", len) == 0);
216 free (p);
217
218 ok = base32_decode_alloc_ctx (&ctx, "", 0, &p, &len);
219 ASSERT (ok);
220 free (p);
221 }
222
223 {
224 struct base32_decode_context ctx;
225 const char *newlineb32 = "\n\n\n\n\n";
226
227 base32_decode_ctx_init (&ctx);
228
229 ok = base32_decode_alloc_ctx (&ctx, newlineb32, strlen (newlineb32), &p, &len);
230 ASSERT (ok);
231 ASSERT (len == 0);
232 free (p);
233 }
234
235 ok = base32_decode_alloc_ctx (NULL, " ! ", 3, &p, &len);
236 ASSERT (!ok);
237
238 ok = base32_decode_alloc_ctx (NULL, "ABC\nDEF", 7, &p, &len);
239 ASSERT (!ok);
240
241 ok = base32_decode_alloc_ctx (NULL, "AA", 2, &p, &len);
242 ASSERT (!ok);
243
244 ok = base32_decode_alloc_ctx (NULL, "AA=", 3, &p, &len);
245 ASSERT (!ok);
246
247 ok = base32_decode_alloc_ctx (NULL, "AABBAAxx", 8, &p, &len);
248 ASSERT (!ok);
249
250 ok = base32_decode_alloc_ctx (NULL, "AABBAA=X", 8, &p, &len);
251 ASSERT (!ok);
252
253 ok = base32_decode_alloc_ctx (NULL, "AABBAA=X", 8, &p, &len);
254 ASSERT (!ok);
255
256 ok = base32_decode_alloc_ctx (NULL, "AABBAA=A", 8, &p, &len);
257 ASSERT (!ok);
258
259 return 0;
260 }