Branch data Line data Source code
1 : : /* Self tests for base64.
2 : : Copyright (C) 2004, 2008-2012 Free Software Foundation, Inc.
3 : : Written by Simon Josefsson.
4 : :
5 : : This program is free software: you can redistribute it and/or modify
6 : : it under the terms of the GNU General Public License as published by
7 : : the Free Software Foundation; either version 3 of the License, or
8 : : (at your option) any later version.
9 : :
10 : : This program is distributed in the hope that it will be useful,
11 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
12 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 : : GNU General Public License for more details.
14 : :
15 : : You should have received a copy of the GNU General Public License
16 : : along with this program. If not, see <http://www.gnu.org/licenses/>. */
17 : :
18 : : #include <config.h>
19 : :
20 : : #include "base64.h"
21 : :
22 : : #include <stddef.h>
23 : : #include <stdbool.h>
24 : : #include <stdlib.h>
25 : : #include <string.h>
26 : : #include <stdint.h>
27 : :
28 : : #include "macros.h"
29 : :
30 : : int
31 : 1 : main (void)
32 : : {
33 : 1 : const char *in = "abcdefghijklmnop";
34 : 1 : const char *b64in = "YWJjZGVmZw==";
35 : : char out[255];
36 : : size_t len;
37 : : bool ok;
38 : : char *p;
39 : :
40 : 1 : memset (out, 0x42, sizeof (out));
41 : 1 : base64_encode (in, 0, out, 0);
42 [ - + ]: 1 : ASSERT (out[0] == '\x42');
43 : :
44 : 1 : memset (out, 0x42, sizeof (out));
45 : 1 : base64_encode (in, 1, out, 1);
46 [ - + ]: 1 : ASSERT (memcmp (out, "YQ==", 1) == 0);
47 : :
48 : 1 : memset (out, 0x42, sizeof (out));
49 : 1 : base64_encode (in, 1, out, 2);
50 [ - + ]: 1 : ASSERT (memcmp (out, "YQ==", 2) == 0);
51 : :
52 : 1 : memset (out, 0x42, sizeof (out));
53 : 1 : base64_encode (in, 1, out, 3);
54 [ - + ]: 1 : ASSERT (memcmp (out, "YQ==", 3) == 0);
55 : :
56 : 1 : memset (out, 0x42, sizeof (out));
57 : 1 : base64_encode (in, 1, out, 4);
58 [ - + ]: 1 : ASSERT (memcmp (out, "YQ==", 4) == 0);
59 : :
60 : 1 : memset (out, 0x42, sizeof (out));
61 : 1 : base64_encode (in, 1, out, 8);
62 [ - + ]: 1 : ASSERT (memcmp (out, "YQ==", 4) == 0);
63 : :
64 : 1 : memset (out, 0x42, sizeof (out));
65 : 1 : base64_encode (in, 2, out, 4);
66 [ - + ]: 1 : ASSERT (memcmp (out, "YWI=", 4) == 0);
67 : :
68 : 1 : memset (out, 0x42, sizeof (out));
69 : 1 : base64_encode (in, 3, out, 4);
70 [ - + ]: 1 : ASSERT (memcmp (out, "YWJj", 4) == 0);
71 : :
72 : 1 : memset (out, 0x42, sizeof (out));
73 : 1 : base64_encode (in, 4, out, 5);
74 [ - + ]: 1 : ASSERT (memcmp (out, "YWJjZA==", 5) == 0);
75 : :
76 : 1 : memset (out, 0x42, sizeof (out));
77 : 1 : base64_encode (in, 4, out, 100);
78 [ - + ]: 1 : ASSERT (memcmp (out, "YWJjZA==", 6) == 0);
79 : :
80 : : /* Decode. */
81 : :
82 : 1 : memset (out, 0x42, sizeof (out));
83 : 1 : len = 0;
84 : 1 : ok = base64_decode (b64in, 4, out, &len);
85 [ - + ]: 1 : ASSERT (ok);
86 [ - + ]: 1 : ASSERT (len == 0);
87 : :
88 : 1 : memset (out, 0x42, sizeof (out));
89 : 1 : len = 1;
90 : 1 : ok = base64_decode (b64in, 4, out, &len);
91 [ - + ]: 1 : ASSERT (ok);
92 [ - + ]: 1 : ASSERT (len == 1);
93 [ - + ]: 1 : ASSERT (memcmp (out, "abcdefg", 1) == 0);
94 : :
95 : 1 : memset (out, 0x42, sizeof (out));
96 : 1 : len = 2;
97 : 1 : ok = base64_decode (b64in, 4, out, &len);
98 [ - + ]: 1 : ASSERT (ok);
99 [ - + ]: 1 : ASSERT (len == 2);
100 [ - + ]: 1 : ASSERT (memcmp (out, "abcdefg", 2) == 0);
101 : :
102 : 1 : memset (out, 0x42, sizeof (out));
103 : 1 : len = 3;
104 : 1 : ok = base64_decode (b64in, 4, out, &len);
105 [ - + ]: 1 : ASSERT (ok);
106 [ - + ]: 1 : ASSERT (len == 3);
107 [ - + ]: 1 : ASSERT (memcmp (out, "abcdefg", 3) == 0);
108 : :
109 : 1 : memset (out, 0x42, sizeof (out));
110 : 1 : len = 4;
111 : 1 : ok = base64_decode (b64in, 4, out, &len);
112 [ - + ]: 1 : ASSERT (ok);
113 [ - + ]: 1 : ASSERT (len == 3);
114 [ - + ]: 1 : ASSERT (memcmp (out, "abcdefg", 3) == 0);
115 : :
116 : 1 : memset (out, 0x42, sizeof (out));
117 : 1 : len = 100;
118 : 1 : ok = base64_decode (b64in, strlen (b64in), out, &len);
119 [ - + ]: 1 : ASSERT (ok);
120 [ - + ]: 1 : ASSERT (len == 7);
121 [ - + ]: 1 : ASSERT (memcmp (out, "abcdefg", 7) == 0);
122 : :
123 : : /* Allocating encode */
124 : :
125 : 1 : len = base64_encode_alloc (in, strlen (in), &p);
126 [ - + ]: 1 : ASSERT (len == 24);
127 [ - + ]: 1 : ASSERT (strcmp (p, "YWJjZGVmZ2hpamtsbW5vcA==") == 0);
128 : 1 : free (p);
129 : :
130 : 1 : len = base64_encode_alloc (in, SIZE_MAX - 5, &p);
131 [ - + ]: 1 : ASSERT (len == 0);
132 : :
133 : : /* Decode context function */
134 : : {
135 : : struct base64_decode_context ctx;
136 : :
137 : 1 : base64_decode_ctx_init (&ctx);
138 : :
139 : 1 : len = sizeof (out);
140 : 1 : ok = base64_decode_ctx (&ctx, b64in, strlen (b64in), out, &len);
141 [ - + ]: 1 : ASSERT (ok);
142 [ - + ]: 1 : ASSERT (len == 7);
143 [ - + ]: 1 : ASSERT (memcmp (out, "abcdefg", len) == 0);
144 : : }
145 : :
146 : : /* Allocating decode context function */
147 : :
148 : 1 : ok = base64_decode_alloc_ctx (NULL, b64in, strlen (b64in), &p, &len);
149 [ - + ]: 1 : ASSERT (ok);
150 [ - + ]: 1 : ASSERT (len == 7);
151 [ - + ]: 1 : ASSERT (memcmp (out, "abcdefg", len) == 0);
152 : 1 : free (p);
153 : :
154 : : {
155 : : struct base64_decode_context ctx;
156 : 1 : const char *newlineb64 = "YWJjZG\nVmZ2hp\namtsbW5vcA==";
157 : :
158 : 1 : base64_decode_ctx_init (&ctx);
159 : :
160 : 1 : ok = base64_decode_alloc_ctx (&ctx, newlineb64, strlen (newlineb64), &p, &len);
161 [ - + ]: 1 : ASSERT (ok);
162 [ - + ]: 1 : ASSERT (len == strlen (in));
163 [ - + ]: 1 : ASSERT (memcmp (p, in, len) == 0);
164 : 1 : free (p);
165 : : }
166 : :
167 : : {
168 : : struct base64_decode_context ctx;
169 : 1 : base64_decode_ctx_init (&ctx);
170 : :
171 : 1 : ok = base64_decode_alloc_ctx (&ctx, "YW\nJjZGVmZ2hp", 13, &p, &len);
172 [ - + ]: 1 : ASSERT (ok);
173 [ - + ]: 1 : ASSERT (len == 9);
174 [ - + ]: 1 : ASSERT (memcmp (p, "abcdefghi", len) == 0);
175 : 1 : free (p);
176 : :
177 : 1 : base64_decode_ctx_init (&ctx);
178 : :
179 : 1 : ok = base64_decode_alloc_ctx (&ctx, "YW\n", 3, &p, &len);
180 [ - + ]: 1 : ASSERT (ok);
181 [ - + ]: 1 : ASSERT (len == 0);
182 : 1 : free (p);
183 : :
184 : 1 : ok = base64_decode_alloc_ctx (&ctx, "JjZGVmZ2", 8, &p, &len);
185 [ - + ]: 1 : ASSERT (ok);
186 [ - + ]: 1 : ASSERT (len == 6);
187 [ - + ]: 1 : ASSERT (memcmp (p, "abcdef", len) == 0);
188 : 1 : free (p);
189 : :
190 : 1 : ok = base64_decode_alloc_ctx (&ctx, "hp", 2, &p, &len);
191 [ - + ]: 1 : ASSERT (ok);
192 [ - + ]: 1 : ASSERT (len == 3);
193 [ - + ]: 1 : ASSERT (memcmp (p, "ghi", len) == 0);
194 : 1 : free (p);
195 : :
196 : 1 : ok = base64_decode_alloc_ctx (&ctx, "", 0, &p, &len);
197 [ - + ]: 1 : ASSERT (ok);
198 : 1 : free (p);
199 : : }
200 : :
201 : : {
202 : : struct base64_decode_context ctx;
203 : 1 : const char *newlineb64 = "\n\n\n\n\n";
204 : :
205 : 1 : base64_decode_ctx_init (&ctx);
206 : :
207 : 1 : ok = base64_decode_alloc_ctx (&ctx, newlineb64, strlen (newlineb64), &p, &len);
208 [ - + ]: 1 : ASSERT (ok);
209 [ - + ]: 1 : ASSERT (len == 0);
210 : 1 : free (p);
211 : : }
212 : :
213 : 1 : ok = base64_decode_alloc_ctx (NULL, " ! ", 3, &p, &len);
214 [ - + ]: 1 : ASSERT (!ok);
215 : :
216 : 1 : ok = base64_decode_alloc_ctx (NULL, "abc\ndef", 7, &p, &len);
217 [ - + ]: 1 : ASSERT (!ok);
218 : :
219 : 1 : ok = base64_decode_alloc_ctx (NULL, "aa", 2, &p, &len);
220 [ - + ]: 1 : ASSERT (!ok);
221 : :
222 : 1 : ok = base64_decode_alloc_ctx (NULL, "aa=", 3, &p, &len);
223 [ - + ]: 1 : ASSERT (!ok);
224 : :
225 : 1 : ok = base64_decode_alloc_ctx (NULL, "aax", 3, &p, &len);
226 [ - + ]: 1 : ASSERT (!ok);
227 : :
228 : 1 : ok = base64_decode_alloc_ctx (NULL, "aa=X", 4, &p, &len);
229 [ - + ]: 1 : ASSERT (!ok);
230 : :
231 : 1 : ok = base64_decode_alloc_ctx (NULL, "aa=X", 4, &p, &len);
232 [ - + ]: 1 : ASSERT (!ok);
233 : :
234 : 1 : ok = base64_decode_alloc_ctx (NULL, "aax=X", 5, &p, &len);
235 [ - + ]: 1 : ASSERT (!ok);
236 : :
237 : 1 : return 0;
238 : : }
|
