Mercurial > libbase64
annotate test/base64.c @ 24:90760aa2e7ed
base64: support binary data
author | David Demelier <markand@malikania.fr> |
---|---|
date | Thu, 26 Mar 2020 08:41:12 +0100 |
parents | 9205a516264d |
children | 3172e43c9b43 |
rev | line source |
---|---|
22 | 1 /* |
2 * base64.c -- main test file for base64 (C version) | |
3 * | |
4 * Copyright (c) 2013-2020 David Demelier <markand@malikania.fr> | |
5 * | |
6 * Permission to use, copy, modify, and/or distribute this software for any | |
7 * purpose with or without fee is hereby granted, provided that the above | |
8 * copyright notice and this permission notice appear in all copies. | |
9 * | |
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | |
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | |
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
17 */ | |
18 | |
19 #include <errno.h> | |
20 | |
21 #define GREATEST_USE_ABBREVS 0 | |
22 #include <greatest.h> | |
23 | |
24 #include <base64.h> | |
25 | |
26 GREATEST_TEST | |
27 test_general_b64_lookup(void) | |
28 { | |
29 GREATEST_ASSERT(b64_lookup(0) == 'A'); | |
30 GREATEST_ASSERT(b64_lookup(1) == 'B'); | |
31 GREATEST_ASSERT(b64_lookup(2) == 'C'); | |
32 GREATEST_ASSERT(b64_lookup(3) == 'D'); | |
33 GREATEST_ASSERT(b64_lookup(4) == 'E'); | |
34 GREATEST_ASSERT(b64_lookup(5) == 'F'); | |
35 GREATEST_ASSERT(b64_lookup(6) == 'G'); | |
36 GREATEST_ASSERT(b64_lookup(7) == 'H'); | |
37 GREATEST_ASSERT(b64_lookup(8) == 'I'); | |
38 GREATEST_ASSERT(b64_lookup(9) == 'J'); | |
39 GREATEST_ASSERT(b64_lookup(10) == 'K'); | |
40 GREATEST_ASSERT(b64_lookup(11) == 'L'); | |
41 GREATEST_ASSERT(b64_lookup(12) == 'M'); | |
42 GREATEST_ASSERT(b64_lookup(13) == 'N'); | |
43 GREATEST_ASSERT(b64_lookup(14) == 'O'); | |
44 GREATEST_ASSERT(b64_lookup(15) == 'P'); | |
45 GREATEST_ASSERT(b64_lookup(16) == 'Q'); | |
46 GREATEST_ASSERT(b64_lookup(17) == 'R'); | |
47 GREATEST_ASSERT(b64_lookup(18) == 'S'); | |
48 GREATEST_ASSERT(b64_lookup(19) == 'T'); | |
49 GREATEST_ASSERT(b64_lookup(20) == 'U'); | |
50 GREATEST_ASSERT(b64_lookup(21) == 'V'); | |
51 GREATEST_ASSERT(b64_lookup(22) == 'W'); | |
52 GREATEST_ASSERT(b64_lookup(23) == 'X'); | |
53 GREATEST_ASSERT(b64_lookup(24) == 'Y'); | |
54 GREATEST_ASSERT(b64_lookup(25) == 'Z'); | |
55 GREATEST_ASSERT(b64_lookup(26) == 'a'); | |
56 GREATEST_ASSERT(b64_lookup(27) == 'b'); | |
57 GREATEST_ASSERT(b64_lookup(28) == 'c'); | |
58 GREATEST_ASSERT(b64_lookup(29) == 'd'); | |
59 GREATEST_ASSERT(b64_lookup(30) == 'e'); | |
60 GREATEST_ASSERT(b64_lookup(31) == 'f'); | |
61 GREATEST_ASSERT(b64_lookup(32) == 'g'); | |
62 GREATEST_ASSERT(b64_lookup(33) == 'h'); | |
63 GREATEST_ASSERT(b64_lookup(34) == 'i'); | |
64 GREATEST_ASSERT(b64_lookup(35) == 'j'); | |
65 GREATEST_ASSERT(b64_lookup(36) == 'k'); | |
66 GREATEST_ASSERT(b64_lookup(37) == 'l'); | |
67 GREATEST_ASSERT(b64_lookup(38) == 'm'); | |
68 GREATEST_ASSERT(b64_lookup(39) == 'n'); | |
69 GREATEST_ASSERT(b64_lookup(40) == 'o'); | |
70 GREATEST_ASSERT(b64_lookup(41) == 'p'); | |
71 GREATEST_ASSERT(b64_lookup(42) == 'q'); | |
72 GREATEST_ASSERT(b64_lookup(43) == 'r'); | |
73 GREATEST_ASSERT(b64_lookup(44) == 's'); | |
74 GREATEST_ASSERT(b64_lookup(45) == 't'); | |
75 GREATEST_ASSERT(b64_lookup(46) == 'u'); | |
76 GREATEST_ASSERT(b64_lookup(47) == 'v'); | |
77 GREATEST_ASSERT(b64_lookup(48) == 'w'); | |
78 GREATEST_ASSERT(b64_lookup(49) == 'x'); | |
79 GREATEST_ASSERT(b64_lookup(50) == 'y'); | |
80 GREATEST_ASSERT(b64_lookup(51) == 'z'); | |
81 GREATEST_ASSERT(b64_lookup(52) == '0'); | |
82 GREATEST_ASSERT(b64_lookup(53) == '1'); | |
83 GREATEST_ASSERT(b64_lookup(54) == '2'); | |
84 GREATEST_ASSERT(b64_lookup(55) == '3'); | |
85 GREATEST_ASSERT(b64_lookup(56) == '4'); | |
86 GREATEST_ASSERT(b64_lookup(57) == '5'); | |
87 GREATEST_ASSERT(b64_lookup(58) == '6'); | |
88 GREATEST_ASSERT(b64_lookup(59) == '7'); | |
89 GREATEST_ASSERT(b64_lookup(60) == '8'); | |
90 GREATEST_ASSERT(b64_lookup(61) == '9'); | |
91 GREATEST_ASSERT(b64_lookup(62) == '+'); | |
92 GREATEST_ASSERT(b64_lookup(63) == '/'); | |
93 GREATEST_PASS(); | |
94 } | |
95 | |
96 GREATEST_TEST | |
97 test_general_b64_rlookup(void) | |
98 { | |
99 GREATEST_ASSERT(b64_rlookup('A') == 0); | |
100 GREATEST_ASSERT(b64_rlookup('B') == 1); | |
101 GREATEST_ASSERT(b64_rlookup('C') == 2); | |
102 GREATEST_ASSERT(b64_rlookup('D') == 3); | |
103 GREATEST_ASSERT(b64_rlookup('E') == 4); | |
104 GREATEST_ASSERT(b64_rlookup('F') == 5); | |
105 GREATEST_ASSERT(b64_rlookup('G') == 6); | |
106 GREATEST_ASSERT(b64_rlookup('H') == 7); | |
107 GREATEST_ASSERT(b64_rlookup('I') == 8); | |
108 GREATEST_ASSERT(b64_rlookup('J') == 9); | |
109 GREATEST_ASSERT(b64_rlookup('K') == 10); | |
110 GREATEST_ASSERT(b64_rlookup('L') == 11); | |
111 GREATEST_ASSERT(b64_rlookup('M') == 12); | |
112 GREATEST_ASSERT(b64_rlookup('N') == 13); | |
113 GREATEST_ASSERT(b64_rlookup('O') == 14); | |
114 GREATEST_ASSERT(b64_rlookup('P') == 15); | |
115 GREATEST_ASSERT(b64_rlookup('Q') == 16); | |
116 GREATEST_ASSERT(b64_rlookup('R') == 17); | |
117 GREATEST_ASSERT(b64_rlookup('S') == 18); | |
118 GREATEST_ASSERT(b64_rlookup('T') == 19); | |
119 GREATEST_ASSERT(b64_rlookup('U') == 20); | |
120 GREATEST_ASSERT(b64_rlookup('V') == 21); | |
121 GREATEST_ASSERT(b64_rlookup('W') == 22); | |
122 GREATEST_ASSERT(b64_rlookup('X') == 23); | |
123 GREATEST_ASSERT(b64_rlookup('Y') == 24); | |
124 GREATEST_ASSERT(b64_rlookup('Z') == 25); | |
125 GREATEST_ASSERT(b64_rlookup('a') == 26); | |
126 GREATEST_ASSERT(b64_rlookup('b') == 27); | |
127 GREATEST_ASSERT(b64_rlookup('c') == 28); | |
128 GREATEST_ASSERT(b64_rlookup('d') == 29); | |
129 GREATEST_ASSERT(b64_rlookup('e') == 30); | |
130 GREATEST_ASSERT(b64_rlookup('f') == 31); | |
131 GREATEST_ASSERT(b64_rlookup('g') == 32); | |
132 GREATEST_ASSERT(b64_rlookup('h') == 33); | |
133 GREATEST_ASSERT(b64_rlookup('i') == 34); | |
134 GREATEST_ASSERT(b64_rlookup('j') == 35); | |
135 GREATEST_ASSERT(b64_rlookup('k') == 36); | |
136 GREATEST_ASSERT(b64_rlookup('l') == 37); | |
137 GREATEST_ASSERT(b64_rlookup('m') == 38); | |
138 GREATEST_ASSERT(b64_rlookup('n') == 39); | |
139 GREATEST_ASSERT(b64_rlookup('o') == 40); | |
140 GREATEST_ASSERT(b64_rlookup('p') == 41); | |
141 GREATEST_ASSERT(b64_rlookup('q') == 42); | |
142 GREATEST_ASSERT(b64_rlookup('r') == 43); | |
143 GREATEST_ASSERT(b64_rlookup('s') == 44); | |
144 GREATEST_ASSERT(b64_rlookup('t') == 45); | |
145 GREATEST_ASSERT(b64_rlookup('u') == 46); | |
146 GREATEST_ASSERT(b64_rlookup('v') == 47); | |
147 GREATEST_ASSERT(b64_rlookup('w') == 48); | |
148 GREATEST_ASSERT(b64_rlookup('x') == 49); | |
149 GREATEST_ASSERT(b64_rlookup('y') == 50); | |
150 GREATEST_ASSERT(b64_rlookup('z') == 51); | |
151 GREATEST_ASSERT(b64_rlookup('0') == 52); | |
152 GREATEST_ASSERT(b64_rlookup('1') == 53); | |
153 GREATEST_ASSERT(b64_rlookup('2') == 54); | |
154 GREATEST_ASSERT(b64_rlookup('3') == 55); | |
155 GREATEST_ASSERT(b64_rlookup('4') == 56); | |
156 GREATEST_ASSERT(b64_rlookup('5') == 57); | |
157 GREATEST_ASSERT(b64_rlookup('6') == 58); | |
158 GREATEST_ASSERT(b64_rlookup('7') == 59); | |
159 GREATEST_ASSERT(b64_rlookup('8') == 60); | |
160 GREATEST_ASSERT(b64_rlookup('9') == 61); | |
161 GREATEST_ASSERT(b64_rlookup('+') == 62); | |
162 GREATEST_ASSERT(b64_rlookup('/') == 63); | |
163 GREATEST_PASS(); | |
164 } | |
165 | |
166 GREATEST_SUITE(suite_general) | |
167 { | |
168 GREATEST_RUN_TEST(test_general_b64_lookup); | |
169 GREATEST_RUN_TEST(test_general_b64_rlookup); | |
170 } | |
171 | |
172 GREATEST_TEST | |
173 test_b64_encode_basic(void) | |
174 { | |
175 char buffer[BUFSIZ]; | |
176 size_t r; | |
177 | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
178 r = b64_encode("a", 0, buffer, sizeof (buffer)); |
22 | 179 GREATEST_ASSERT_EQ(r, 4U); |
180 GREATEST_ASSERT_STR_EQ(buffer, "YQ=="); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
181 r = b64_encode("ab", 0, buffer, sizeof (buffer)); |
22 | 182 GREATEST_ASSERT_EQ(r, 4U); |
183 GREATEST_ASSERT_STR_EQ(buffer, "YWI="); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
184 r = b64_encode("abc", 0, buffer, sizeof (buffer)); |
22 | 185 GREATEST_ASSERT_EQ(r, 4U); |
186 GREATEST_ASSERT_STR_EQ(buffer, "YWJj"); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
187 r = b64_encode("hello", 0, buffer, sizeof (buffer)); |
22 | 188 GREATEST_ASSERT_EQ(r, 8U); |
189 GREATEST_ASSERT_STR_EQ(buffer, "aGVsbG8="); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
190 r = b64_encode("this is a long sentence", 0, buffer, sizeof (buffer)); |
22 | 191 GREATEST_ASSERT_EQ(r, 32U); |
192 GREATEST_ASSERT_STR_EQ(buffer, "dGhpcyBpcyBhIGxvbmcgc2VudGVuY2U="); | |
193 GREATEST_PASS(); | |
194 } | |
195 | |
196 GREATEST_TEST | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
197 test_b64_encode_binary(void) |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
198 { |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
199 char buffer[BUFSIZ]; |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
200 size_t r; |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
201 |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
202 r = b64_encode("a\0bc", 4, buffer, sizeof (buffer)); |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
203 GREATEST_ASSERT_EQ(r, 8U); |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
204 GREATEST_ASSERT_STR_EQ(buffer, "YQBiYw=="); |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
205 GREATEST_PASS(); |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
206 } |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
207 |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
208 GREATEST_TEST |
22 | 209 test_b64_encode_toosmall(void) |
210 { | |
211 char buffer[10]; | |
212 size_t r; | |
213 | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
214 r = b64_encode("hello world", 0, buffer, sizeof (buffer)); |
22 | 215 GREATEST_ASSERT_EQ(r, (size_t)-1); |
216 GREATEST_ASSERT_EQ(errno, ERANGE); | |
217 GREATEST_PASS(); | |
218 } | |
219 | |
220 GREATEST_SUITE(suite_b64_encode) | |
221 { | |
222 GREATEST_RUN_TEST(test_b64_encode_basic); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
223 GREATEST_RUN_TEST(test_b64_encode_binary); |
22 | 224 GREATEST_RUN_TEST(test_b64_encode_toosmall); |
225 } | |
226 | |
227 GREATEST_TEST | |
228 test_b64_encode_length_basic(void) | |
229 { | |
230 GREATEST_ASSERT_EQ(b64_encode_length(0, 1), 4U); | |
231 GREATEST_ASSERT_EQ(b64_encode_length(0, 2), 4U); | |
232 GREATEST_ASSERT_EQ(b64_encode_length(0, 3), 8U); | |
233 GREATEST_ASSERT_EQ(b64_encode_length(0, 4), 8U); | |
234 GREATEST_ASSERT_EQ(b64_encode_length(0, 5), 8U); | |
235 GREATEST_ASSERT_EQ(b64_encode_length(0, 6), 12U); | |
236 GREATEST_ASSERT_EQ(b64_encode_length(0, 7), 12U); | |
237 GREATEST_ASSERT_EQ(b64_encode_length(0, 8), 12U); | |
238 GREATEST_ASSERT_EQ(b64_encode_length("a", 0), 4U); | |
239 GREATEST_ASSERT_EQ(b64_encode_length("ab", 0), 4U); | |
240 GREATEST_ASSERT_EQ(b64_encode_length("abc", 0), 8U); | |
241 GREATEST_ASSERT_EQ(b64_encode_length("abcd", 0), 8U); | |
242 GREATEST_ASSERT_EQ(b64_encode_length("abcde", 0), 8U); | |
243 GREATEST_ASSERT_EQ(b64_encode_length("abcdef", 0), 12U); | |
244 GREATEST_ASSERT_EQ(b64_encode_length("abcdefg", 0), 12U); | |
245 GREATEST_ASSERT_EQ(b64_encode_length("abcdefgh", 0), 12U); | |
246 GREATEST_PASS(); | |
247 } | |
248 | |
249 GREATEST_SUITE(suite_b64_encode_length) | |
250 { | |
251 GREATEST_RUN_TEST(test_b64_encode_length_basic); | |
252 } | |
253 | |
254 GREATEST_TEST | |
255 test_b64_decode_length_basic(void) | |
256 { | |
257 GREATEST_ASSERT_EQ(b64_decode_length(0, 4), 3U); | |
258 GREATEST_ASSERT_EQ(b64_decode_length(0, 8), 6U); | |
259 GREATEST_ASSERT_EQ(b64_decode_length(0, 12), 9U); | |
260 GREATEST_ASSERT_EQ(b64_decode_length(0, 16), 12U); | |
261 GREATEST_ASSERT_EQ(b64_decode_length(0, 20), 15U); | |
262 GREATEST_ASSERT_EQ(b64_decode_length("XXXX", 4), 3U); | |
263 GREATEST_ASSERT_EQ(b64_decode_length("XXXXXXXX", 8), 6U); | |
264 GREATEST_ASSERT_EQ(b64_decode_length("XXXXXXXXXXXX", 12), 9U); | |
265 GREATEST_ASSERT_EQ(b64_decode_length("XXXXXXXXXXXXXXXX", 16), 12U); | |
266 GREATEST_ASSERT_EQ(b64_decode_length("XXXXXXXXXXXXXXXXXXXX", 20), 15U); | |
267 GREATEST_PASS(); | |
268 } | |
269 | |
270 GREATEST_SUITE(suite_b64_decode_length) | |
271 { | |
272 GREATEST_RUN_TEST(test_b64_decode_length_basic); | |
273 } | |
274 | |
275 GREATEST_TEST | |
276 test_b64_decode_basic(void) | |
277 { | |
278 char buffer[BUFSIZ]; | |
279 size_t r; | |
280 | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
281 r = b64_decode("YQ==", 0, buffer, sizeof (buffer)); |
22 | 282 GREATEST_ASSERT_EQ(r, 1U); |
283 GREATEST_ASSERT_STR_EQ(buffer, "a"); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
284 r = b64_decode("YWI=", 0, buffer, sizeof (buffer)); |
22 | 285 GREATEST_ASSERT_EQ(r, 2U); |
286 GREATEST_ASSERT_STR_EQ(buffer, "ab"); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
287 r = b64_decode("YWJj", 0, buffer, sizeof (buffer)); |
22 | 288 GREATEST_ASSERT_EQ(r, 3U); |
289 GREATEST_ASSERT_STR_EQ(buffer, "abc"); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
290 r = b64_decode("aGVsbG8=", 0, buffer, sizeof (buffer)); |
22 | 291 GREATEST_ASSERT_EQ(r, 5U); |
292 GREATEST_ASSERT_STR_EQ(buffer, "hello"); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
293 r = b64_decode("dGhpcyBpcyBhIGxvbmcgc2VudGVuY2U=", 0, buffer, sizeof (buffer)); |
22 | 294 GREATEST_ASSERT_EQ(r, 23U); |
295 GREATEST_ASSERT_STR_EQ(buffer, "this is a long sentence"); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
296 r = b64_decode("V2VsY29tZSB0byBvdXIgc2VydmVyIGR1ZGU=", 0, buffer, sizeof (buffer)); |
22 | 297 GREATEST_ASSERT_EQ(r, 26U); |
298 GREATEST_ASSERT_STR_EQ(buffer, "Welcome to our server dude"); | |
299 GREATEST_PASS(); | |
300 } | |
301 | |
302 GREATEST_TEST | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
303 test_b64_decode_sized(void) |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
304 { |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
305 char buffer[BUFSIZ]; |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
306 size_t r; |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
307 |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
308 r = b64_decode("YQ== ", 4, buffer, sizeof (buffer)); |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
309 GREATEST_ASSERT_EQ(r, 1U); |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
310 GREATEST_ASSERT_STR_EQ(buffer, "a"); |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
311 GREATEST_PASS(); |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
312 } |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
313 |
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
314 GREATEST_TEST |
22 | 315 test_b64_decode_invalid(void) |
316 { | |
317 char buffer[BUFSIZ]; | |
318 size_t r; | |
319 | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
320 r = b64_decode("YW=", 0, buffer, sizeof (buffer)); |
22 | 321 GREATEST_ASSERT_EQ(r, (size_t)-1); |
322 GREATEST_ASSERT_EQ(errno, EILSEQ); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
323 r = b64_decode("?!", 0, buffer, sizeof (buffer)); |
22 | 324 GREATEST_ASSERT_EQ(r, (size_t)-1); |
325 GREATEST_ASSERT_EQ(errno, EILSEQ); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
326 r = b64_decode("=ABC", 0, buffer, sizeof (buffer)); |
22 | 327 GREATEST_ASSERT_EQ(r, (size_t)-1); |
328 GREATEST_ASSERT_EQ(errno, EILSEQ); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
329 r = b64_decode("A=BC", 0, buffer, sizeof (buffer)); |
22 | 330 GREATEST_ASSERT_EQ(r, (size_t)-1); |
331 GREATEST_ASSERT_EQ(errno, EILSEQ); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
332 r = b64_decode("==BC", 0, buffer, sizeof (buffer)); |
22 | 333 GREATEST_ASSERT_EQ(r, (size_t)-1); |
334 GREATEST_ASSERT_EQ(errno, EILSEQ); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
335 r = b64_decode("AB=C", 0, buffer, sizeof (buffer)); |
22 | 336 GREATEST_ASSERT_EQ(r, (size_t)-1); |
337 GREATEST_ASSERT_EQ(errno, EILSEQ); | |
338 GREATEST_PASS(); | |
339 } | |
340 | |
341 GREATEST_TEST | |
342 test_b64_decode_toosmall(void) | |
343 { | |
344 char buffer[10]; | |
345 size_t r; | |
346 | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
347 r = b64_decode("V2VsY29tZSB0byBvdXIgc2VydmVyIGR1ZGU=", 0, buffer, sizeof (buffer)); |
22 | 348 GREATEST_ASSERT_EQ(r, (size_t)-1); |
349 GREATEST_ASSERT_EQ(errno, ERANGE); | |
350 GREATEST_PASS(); | |
351 } | |
352 | |
353 GREATEST_SUITE(suite_b64_decode) | |
354 { | |
355 GREATEST_RUN_TEST(test_b64_decode_basic); | |
24
90760aa2e7ed
base64: support binary data
David Demelier <markand@malikania.fr>
parents:
22
diff
changeset
|
356 GREATEST_RUN_TEST(test_b64_decode_sized); |
22 | 357 GREATEST_RUN_TEST(test_b64_decode_invalid); |
358 GREATEST_RUN_TEST(test_b64_decode_toosmall); | |
359 } | |
360 | |
361 GREATEST_MAIN_DEFS(); | |
362 | |
363 int | |
364 main(int argc, char **argv) | |
365 { | |
366 GREATEST_MAIN_BEGIN(); | |
367 GREATEST_RUN_SUITE(suite_general); | |
368 GREATEST_RUN_SUITE(suite_b64_encode); | |
369 GREATEST_RUN_SUITE(suite_b64_encode_length); | |
370 GREATEST_RUN_SUITE(suite_b64_decode); | |
371 GREATEST_RUN_SUITE(suite_b64_decode_length); | |
372 GREATEST_MAIN_END(); | |
373 } |