Apache HTTPD
testencode.c
Go to the documentation of this file.
1/* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements. See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License. You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <assert.h>
18#include <stdio.h>
19#include <stdlib.h>
20
21#include "apr_encode.h"
22#include "apr_strings.h"
23
24#include "abts.h"
25#include "testutil.h"
26
27static const unsigned char ufoobar[] = { 'f', 'o', 'o', 'b', 'a', 'r' };
28
29static void test_encode_base64(abts_case * tc, void *data)
30{
31 apr_pool_t *pool;
32 const char *src, *target;
33 const char *dest;
34 apr_size_t len;
35
36 apr_pool_create(&pool, NULL);
37
38 /*
39 * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
40 */
41 src = "";
42 target = "";
43 dest = apr_pencode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
44 ABTS_STR_EQUAL(tc, target, dest);
45
46 src = "f";
47 target = "Zg==";
48 dest = apr_pencode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
49 ABTS_STR_EQUAL(tc, target, dest);
50
51 src = "f";
52 target = "Zg";
53 dest = apr_pencode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
54 ABTS_STR_EQUAL(tc, target, dest);
55
56 src = "fo";
57 target = "Zm8=";
58 dest = apr_pencode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
59 ABTS_STR_EQUAL(tc, target, dest);
60
61 src = "fo";
62 target = "Zm8";
63 dest = apr_pencode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
64 ABTS_STR_EQUAL(tc, target, dest);
65
66 src = "foo";
67 target = "Zm9v";
68 dest = apr_pencode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
69 ABTS_STR_EQUAL(tc, target, dest);
70
71 src = "foo";
72 target = "Zm9v";
73 dest = apr_pencode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
74 ABTS_STR_EQUAL(tc, target, dest);
75
76 apr_pool_destroy(pool);
77}
78
79static void test_encode_base64_binary(abts_case * tc, void *data)
80{
81 apr_pool_t *pool;
82 const char *target;
83 const char *dest;
84 apr_size_t len;
85
86 apr_pool_create(&pool, NULL);
87
88 /*
89 * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
90 */
91 target = "";
92 dest = apr_pencode_base64_binary(pool, ufoobar, 0, APR_ENCODE_NONE, &len);
93 ABTS_STR_EQUAL(tc, target, dest);
94
95 target = "Zg==";
96 dest = apr_pencode_base64_binary(pool, ufoobar, 1, APR_ENCODE_NONE, &len);
97 ABTS_STR_EQUAL(tc, target, dest);
98
99 target = "Zg";
100 dest = apr_pencode_base64_binary(pool, ufoobar, 1, APR_ENCODE_NOPADDING, &len);
101 ABTS_STR_EQUAL(tc, target, dest);
102
103 target = "Zm8=";
104 dest = apr_pencode_base64_binary(pool, ufoobar, 2, APR_ENCODE_NONE, &len);
105 ABTS_STR_EQUAL(tc, target, dest);
106
107 target = "Zm8";
108 dest = apr_pencode_base64_binary(pool, ufoobar, 2, APR_ENCODE_NOPADDING, &len);
109 ABTS_STR_EQUAL(tc, target, dest);
110
111 target = "Zm9v";
112 dest = apr_pencode_base64_binary(pool, ufoobar, 3, APR_ENCODE_NONE, &len);
113 ABTS_STR_EQUAL(tc, target, dest);
114
115 target = "Zm9v";
116 dest = apr_pencode_base64_binary(pool, ufoobar, 3, APR_ENCODE_NOPADDING, &len);
117 ABTS_STR_EQUAL(tc, target, dest);
118
119 apr_pool_destroy(pool);
120}
121
122static void test_decode_base64(abts_case * tc, void *data)
123{
124 apr_pool_t *pool;
125 const char *target, *src;
126 const char *dest;
127 apr_size_t len;
128
129 apr_pool_create(&pool, NULL);
130
131 /*
132 * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
133 */
134 src = "";
135 target = "";
136 dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
137 ABTS_STR_EQUAL(tc, target, dest);
138
139 src = "Zg==";
140 target = "f";
141 dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
142 ABTS_STR_EQUAL(tc, target, dest);
143
144 src = "Zg=";
145 target = "f";
146 dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
147 ABTS_STR_EQUAL(tc, target, dest);
148
149 src = "Zg";
150 target = "f";
151 dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
152 ABTS_STR_EQUAL(tc, target, dest);
153
154 src = "Zm8=";
155 target = "fo";
156 dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
157 ABTS_STR_EQUAL(tc, target, dest);
158
159 src = "Zm8";
160 target = "fo";
161 dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
162 ABTS_STR_EQUAL(tc, target, dest);
163
164 src = "Zm9v";
165 target = "foo";
166 dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
167 ABTS_STR_EQUAL(tc, target, dest);
168
169 src = "Zm9v";
170 target = "foo";
171 dest = apr_pdecode_base64(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
172 ABTS_STR_EQUAL(tc, target, dest);
173
174 apr_pool_destroy(pool);
175}
176
177static void test_decode_base64_binary(abts_case * tc, void *data)
178{
179 apr_pool_t *pool;
180 const char *src;
181 const unsigned char *udest;
182 apr_size_t len;
183
184 apr_pool_create(&pool, NULL);
185
186 /*
187 * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
188 */
189 src = "";
190 udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
191 ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 0) == 0);
192 ABTS_SIZE_EQUAL(tc, len, 0);
193
194 src = "Zg==";
195 udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
196 ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 1) == 0);
197 ABTS_SIZE_EQUAL(tc, len, 1);
198
199 src = "Zg=";
200 udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
201 ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 1) == 0);
202 ABTS_SIZE_EQUAL(tc, len, 1);
203
204 src = "Zg";
205 udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
206 ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 1) == 0);
207 ABTS_SIZE_EQUAL(tc, len, 1);
208
209 src = "Zm8=";
210 udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
211 ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 2) == 0);
212 ABTS_SIZE_EQUAL(tc, len, 2);
213
214 src = "Zm8";
215 udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
216 ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 2) == 0);
217 ABTS_SIZE_EQUAL(tc, len, 2);
218
219 src = "Zm9v";
220 udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
221 ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 3) == 0);
222 ABTS_SIZE_EQUAL(tc, len, 3);
223
224 src = "Zm9v";
225 udest = apr_pdecode_base64_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
226 ABTS_ASSERT(tc, "apr_pdecode_base64_binary target!=dest", memcmp(ufoobar, udest, 3) == 0);
227 ABTS_SIZE_EQUAL(tc, len, 3);
228
229 apr_pool_destroy(pool);
230}
231
232static void test_encode_base32(abts_case * tc, void *data)
233{
234 apr_pool_t *pool;
235 const char *src, *target;
236 const char *dest;
237 apr_size_t len;
238
239 apr_pool_create(&pool, NULL);
240
241 /*
242 * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
243 */
244 src = "";
245 target = "";
246 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
247 ABTS_STR_EQUAL(tc, target, dest);
248
249 src = "f";
250 target = "MY======";
251 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
252 ABTS_STR_EQUAL(tc, target, dest);
253
254 src = "f";
255 target = "MY";
256 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
257 ABTS_STR_EQUAL(tc, target, dest);
258
259 src = "f";
260 target = "CO======";
261 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
262 ABTS_STR_EQUAL(tc, target, dest);
263
264 src = "f";
265 target = "CO";
266 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
267 ABTS_STR_EQUAL(tc, target, dest);
268
269 src = "fo";
270 target = "MZXQ====";
271 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
272 ABTS_STR_EQUAL(tc, target, dest);
273
274 src = "fo";
275 target = "MZXQ";
276 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
277 ABTS_STR_EQUAL(tc, target, dest);
278
279 src = "fo";
280 target = "CPNG====";
281 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
282 ABTS_STR_EQUAL(tc, target, dest);
283
284 src = "fo";
285 target = "CPNG";
286 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
287 ABTS_STR_EQUAL(tc, target, dest);
288
289 src = "foo";
290 target = "MZXW6===";
291 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
292 ABTS_STR_EQUAL(tc, target, dest);
293
294 src = "foo";
295 target = "MZXW6";
296 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
297 ABTS_STR_EQUAL(tc, target, dest);
298
299 src = "foo";
300 target = "CPNMU===";
301 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
302 ABTS_STR_EQUAL(tc, target, dest);
303
304 src = "foo";
305 target = "CPNMU";
306 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
307 ABTS_STR_EQUAL(tc, target, dest);
308
309 src = "foob";
310 target = "MZXW6YQ=";
311 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
312 ABTS_STR_EQUAL(tc, target, dest);
313
314 src = "foob";
315 target = "MZXW6YQ";
316 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
317 ABTS_STR_EQUAL(tc, target, dest);
318
319 src = "foob";
320 target = "CPNMUOG=";
321 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
322 ABTS_STR_EQUAL(tc, target, dest);
323
324 src = "foob";
325 target = "CPNMUOG";
326 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
327 ABTS_STR_EQUAL(tc, target, dest);
328
329 src = "fooba";
330 target = "MZXW6YTB";
331 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
332 ABTS_STR_EQUAL(tc, target, dest);
333
334 src = "fooba";
335 target = "MZXW6YTB";
336 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
337 ABTS_STR_EQUAL(tc, target, dest);
338
339 src = "fooba";
340 target = "CPNMUOJ1";
341 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
342 ABTS_STR_EQUAL(tc, target, dest);
343
344 src = "fooba";
345 target = "CPNMUOJ1";
346 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
347 ABTS_STR_EQUAL(tc, target, dest);
348
349 src = "foobar";
350 target = "MZXW6YTBOI======";
351 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
352 ABTS_STR_EQUAL(tc, target, dest);
353
354 src = "foobar";
355 target = "MZXW6YTBOI";
356 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NOPADDING, &len);
357 ABTS_STR_EQUAL(tc, target, dest);
358
359 src = "foobar";
360 target = "CPNMUOJ1E8======";
361 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
362 ABTS_STR_EQUAL(tc, target, dest);
363
364 src = "foobar";
365 target = "CPNMUOJ1E8";
366 dest = apr_pencode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
367 ABTS_STR_EQUAL(tc, target, dest);
368
369 apr_pool_destroy(pool);
370}
371
372static void test_encode_base32_binary(abts_case * tc, void *data)
373{
374 apr_pool_t *pool;
375 const char *target;
376 const char *dest;
377 apr_size_t len;
378
379 apr_pool_create(&pool, NULL);
380
381 /*
382 * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
383 */
384 target = "";
385 dest = apr_pencode_base32_binary(pool, ufoobar, 0, APR_ENCODE_NONE, &len);
386 ABTS_STR_EQUAL(tc, target, dest);
387
388 target = "MY======";
389 dest = apr_pencode_base32_binary(pool, ufoobar, 1, APR_ENCODE_NONE, &len);
390 ABTS_STR_EQUAL(tc, target, dest);
391
392 target = "MY";
393 dest = apr_pencode_base32_binary(pool, ufoobar, 1, APR_ENCODE_NOPADDING, &len);
394 ABTS_STR_EQUAL(tc, target, dest);
395
396 target = "CO======";
397 dest = apr_pencode_base32_binary(pool, ufoobar, 1, APR_ENCODE_BASE32HEX, &len);
398 ABTS_STR_EQUAL(tc, target, dest);
399
400 target = "CO";
401 dest = apr_pencode_base32_binary(pool, ufoobar, 1, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
402 ABTS_STR_EQUAL(tc, target, dest);
403
404 target = "MZXQ====";
405 dest = apr_pencode_base32_binary(pool, ufoobar, 2, APR_ENCODE_NONE, &len);
406 ABTS_STR_EQUAL(tc, target, dest);
407
408 target = "MZXQ";
409 dest = apr_pencode_base32_binary(pool, ufoobar, 2, APR_ENCODE_NOPADDING, &len);
410 ABTS_STR_EQUAL(tc, target, dest);
411
412 target = "CPNG====";
413 dest = apr_pencode_base32_binary(pool, ufoobar, 2, APR_ENCODE_BASE32HEX, &len);
414 ABTS_STR_EQUAL(tc, target, dest);
415
416 target = "CPNG";
417 dest = apr_pencode_base32_binary(pool, ufoobar, 2, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
418 ABTS_STR_EQUAL(tc, target, dest);
419
420 target = "MZXW6===";
421 dest = apr_pencode_base32_binary(pool, ufoobar, 3, APR_ENCODE_NONE, &len);
422 ABTS_STR_EQUAL(tc, target, dest);
423
424 target = "MZXW6";
425 dest = apr_pencode_base32_binary(pool, ufoobar, 3, APR_ENCODE_NOPADDING, &len);
426 ABTS_STR_EQUAL(tc, target, dest);
427
428 target = "CPNMU===";
429 dest = apr_pencode_base32_binary(pool, ufoobar, 3, APR_ENCODE_BASE32HEX, &len);
430 ABTS_STR_EQUAL(tc, target, dest);
431
432 target = "CPNMU";
433 dest = apr_pencode_base32_binary(pool, ufoobar, 3, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
434 ABTS_STR_EQUAL(tc, target, dest);
435
436 target = "MZXW6YQ=";
437 dest = apr_pencode_base32_binary(pool, ufoobar, 4, APR_ENCODE_NONE, &len);
438 ABTS_STR_EQUAL(tc, target, dest);
439
440 target = "MZXW6YQ";
441 dest = apr_pencode_base32_binary(pool, ufoobar, 4, APR_ENCODE_NOPADDING, &len);
442 ABTS_STR_EQUAL(tc, target, dest);
443
444 target = "CPNMUOG=";
445 dest = apr_pencode_base32_binary(pool, ufoobar, 4, APR_ENCODE_BASE32HEX, &len);
446 ABTS_STR_EQUAL(tc, target, dest);
447
448 target = "CPNMUOG";
449 dest = apr_pencode_base32_binary(pool, ufoobar, 4, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
450 ABTS_STR_EQUAL(tc, target, dest);
451
452 target = "MZXW6YTB";
453 dest = apr_pencode_base32_binary(pool, ufoobar, 5, APR_ENCODE_NONE, &len);
454 ABTS_STR_EQUAL(tc, target, dest);
455
456 target = "MZXW6YTB";
457 dest = apr_pencode_base32_binary(pool, ufoobar, 5, APR_ENCODE_NOPADDING, &len);
458 ABTS_STR_EQUAL(tc, target, dest);
459
460 target = "CPNMUOJ1";
461 dest = apr_pencode_base32_binary(pool, ufoobar, 5, APR_ENCODE_BASE32HEX, &len);
462 ABTS_STR_EQUAL(tc, target, dest);
463
464 target = "CPNMUOJ1";
465 dest = apr_pencode_base32_binary(pool, ufoobar, 5, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
466 ABTS_STR_EQUAL(tc, target, dest);
467
468 target = "MZXW6YTBOI======";
469 dest = apr_pencode_base32_binary(pool, ufoobar, 6, APR_ENCODE_NONE, &len);
470 ABTS_STR_EQUAL(tc, target, dest);
471
472 target = "MZXW6YTBOI";
473 dest = apr_pencode_base32_binary(pool, ufoobar, 6, APR_ENCODE_NOPADDING, &len);
474 ABTS_STR_EQUAL(tc, target, dest);
475
476 target = "CPNMUOJ1E8======";
477 dest = apr_pencode_base32_binary(pool, ufoobar, 6, APR_ENCODE_BASE32HEX, &len);
478 ABTS_STR_EQUAL(tc, target, dest);
479
480 target = "CPNMUOJ1E8";
481 dest = apr_pencode_base32_binary(pool, ufoobar, 6, APR_ENCODE_BASE32HEX | APR_ENCODE_NOPADDING, &len);
482 ABTS_STR_EQUAL(tc, target, dest);
483
484 apr_pool_destroy(pool);
485}
486
487static void test_decode_base32(abts_case * tc, void *data)
488{
489 apr_pool_t *pool;
490 const char *target, *src;
491 const char *dest;
492 apr_size_t len;
493
494 apr_pool_create(&pool, NULL);
495
496 /*
497 * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
498 */
499 src = "";
500 target = "";
501 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
502 ABTS_STR_EQUAL(tc, target, dest);
503
504 src = "MY======";
505 target = "f";
506 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
507 ABTS_STR_EQUAL(tc, target, dest);
508
509 src = "MY";
510 target = "f";
511 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
512 ABTS_STR_EQUAL(tc, target, dest);
513
514 src = "CO======";
515 target = "f";
516 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
517 ABTS_STR_EQUAL(tc, target, dest);
518
519 src = "CO";
520 target = "f";
521 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
522 ABTS_STR_EQUAL(tc, target, dest);
523
524 src = "MZXQ====";
525 target = "fo";
526 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
527 ABTS_STR_EQUAL(tc, target, dest);
528
529 src = "MZXQ";
530 target = "fo";
531 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
532 ABTS_STR_EQUAL(tc, target, dest);
533
534 src = "CPNG====";
535 target = "fo";
536 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
537 ABTS_STR_EQUAL(tc, target, dest);
538
539 src = "CPNG";
540 target = "fo";
541 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
542 ABTS_STR_EQUAL(tc, target, dest);
543
544 src = "MZXW6===";
545 target = "foo";
546 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
547 ABTS_STR_EQUAL(tc, target, dest);
548
549 src = "MZXW6";
550 target = "foo";
551 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
552 ABTS_STR_EQUAL(tc, target, dest);
553
554 src = "CPNMU===";
555 target = "foo";
556 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
557 ABTS_STR_EQUAL(tc, target, dest);
558
559 src = "CPNMU";
560 target = "foo";
561 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
562 ABTS_STR_EQUAL(tc, target, dest);
563
564 src = "MZXW6YQ=";
565 target = "foob";
566 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
567 ABTS_STR_EQUAL(tc, target, dest);
568
569 src = "MZXW6YQ=";
570 target = "foob";
571 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
572 ABTS_STR_EQUAL(tc, target, dest);
573
574 src = "CPNMUOG=";
575 target = "foob";
576 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
577 ABTS_STR_EQUAL(tc, target, dest);
578
579 src = "CPNMUOG";
580 target = "foob";
581 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
582 ABTS_STR_EQUAL(tc, target, dest);
583
584 src = "MZXW6YTB";
585 target = "fooba";
586 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
587 ABTS_STR_EQUAL(tc, target, dest);
588
589 src = "MZXW6YTB";
590 target = "fooba";
591 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
592 ABTS_STR_EQUAL(tc, target, dest);
593
594 src = "CPNMUOJ1";
595 target = "fooba";
596 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
597 ABTS_STR_EQUAL(tc, target, dest);
598
599 src = "CPNMUOJ1";
600 target = "fooba";
601 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
602 ABTS_STR_EQUAL(tc, target, dest);
603
604 src = "MZXW6YTBOI======";
605 target = "foobar";
606 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
607 ABTS_STR_EQUAL(tc, target, dest);
608
609 src = "MZXW6YTBOI";
610 target = "foobar";
611 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
612 ABTS_STR_EQUAL(tc, target, dest);
613
614 src = "CPNMUOJ1E8======";
615 target = "foobar";
616 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
617 ABTS_STR_EQUAL(tc, target, dest);
618
619 src = "CPNMUOJ1E8";
620 target = "foobar";
621 dest = apr_pdecode_base32(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
622 ABTS_STR_EQUAL(tc, target, dest);
623
624 apr_pool_destroy(pool);
625}
626
627static void test_decode_base32_binary(abts_case * tc, void *data)
628{
629 apr_pool_t *pool;
630 const char *src;
631 const unsigned char *udest;
632 apr_size_t len;
633
634 apr_pool_create(&pool, NULL);
635
636 /*
637 * Test vectors from https://tools.ietf.org/html/rfc4648#section-10
638 */
639 src = "";
640 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
641 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 0) == 0);
642 ABTS_SIZE_EQUAL(tc, 0, len);
643
644 src = "MY======";
645 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
646 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 1) == 0);
647 ABTS_SIZE_EQUAL(tc, 1, len);
648
649 src = "MY";
650 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
651 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 1) == 0);
652 ABTS_SIZE_EQUAL(tc, 1, len);
653
654 src = "CO======";
655 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
656 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 1) == 0);
657 ABTS_SIZE_EQUAL(tc, 1, len);
658
659 src = "CO";
660 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
661 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 1) == 0);
662 ABTS_SIZE_EQUAL(tc, 1, len);
663
664 src = "MZXQ====";
665 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
666 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 2) == 0);
667 ABTS_SIZE_EQUAL(tc, 2, len);
668
669 src = "MZXQ";
670 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
671 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 2) == 0);
672 ABTS_SIZE_EQUAL(tc, 2, len);
673
674 src = "CPNG====";
675 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
676 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 2) == 0);
677 ABTS_SIZE_EQUAL(tc, 2, len);
678
679 src = "CPNG";
680 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
681 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 2) == 0);
682 ABTS_SIZE_EQUAL(tc, 2, len);
683
684 src = "MZXW6===";
685 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
686 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 3) == 0);
687 ABTS_SIZE_EQUAL(tc, 3, len);
688
689 src = "MZXW6";
690 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
691 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 3) == 0);
692 ABTS_SIZE_EQUAL(tc, 3, len);
693
694 src = "CPNMU===";
695 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
696 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 3) == 0);
697 ABTS_SIZE_EQUAL(tc, 3, len);
698
699 src = "CPNMU";
700 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
701 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 3) == 0);
702 ABTS_SIZE_EQUAL(tc, 3, len);
703
704 src = "MZXW6YQ=";
705 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
706 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 4) == 0);
707 ABTS_SIZE_EQUAL(tc, 4, len);
708
709 src = "MZXW6YQ=";
710 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
711 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 4) == 0);
712 ABTS_SIZE_EQUAL(tc, 4, len);
713
714 src = "CPNMUOG=";
715 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
716 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 4) == 0);
717 ABTS_SIZE_EQUAL(tc, 4, len);
718
719 src = "CPNMUOG";
720 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
721 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 4) == 0);
722 ABTS_SIZE_EQUAL(tc, 4, len);
723
724 src = "MZXW6YTB";
725 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
726 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 5) == 0);
727 ABTS_SIZE_EQUAL(tc, 5, len);
728
729 src = "MZXW6YTB";
730 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
731 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 5) == 0);
732 ABTS_SIZE_EQUAL(tc, 5, len);
733
734 src = "CPNMUOJ1";
735 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
736 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 5) == 0);
737 ABTS_SIZE_EQUAL(tc, 5, len);
738
739 src = "CPNMUOJ1";
740 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
741 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 5) == 0);
742 ABTS_SIZE_EQUAL(tc, 5, len);
743
744 src = "MZXW6YTBOI======";
745 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
746 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 6) == 0);
747 ABTS_SIZE_EQUAL(tc, 6, len);
748
749 src = "MZXW6YTBOI";
750 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
751 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 6) == 0);
752 ABTS_SIZE_EQUAL(tc, 6, len);
753
754 src = "CPNMUOJ1E8======";
755 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
756 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 6) == 0);
757 ABTS_SIZE_EQUAL(tc, 6, len);
758
759 src = "CPNMUOJ1E8";
760 udest = apr_pdecode_base32_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_BASE32HEX, &len);
761 ABTS_ASSERT(tc, "apr_pdecode_base32_binary target!=dest", memcmp(ufoobar, udest, 6) == 0);
762 ABTS_SIZE_EQUAL(tc, 6, len);
763
764 apr_pool_destroy(pool);
765}
766
767static void test_encode_base16(abts_case * tc, void *data)
768{
769 apr_pool_t *pool;
770 const char *src, *target;
771 const char *dest;
772 apr_size_t len;
773
774 apr_pool_create(&pool, NULL);
775
776 src = "foobar";
777 target = "666f6f626172";
778 dest = apr_pencode_base16(pool, src, APR_ENCODE_STRING, APR_ENCODE_LOWER, &len);
779 ABTS_STR_EQUAL(tc, target, dest);
780 apr_encode_base16(NULL, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
781 ABTS_ASSERT(tc,
782 apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
783 (len == strlen(dest) + 1));
784
785 src = "foobar";
786 target = "666F6F626172";
787 dest = apr_pencode_base16(pool, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
788 ABTS_STR_EQUAL(tc, target, dest);
789 apr_encode_base16(NULL, src, APR_ENCODE_STRING, APR_ENCODE_NONE, &len);
790 ABTS_ASSERT(tc,
791 apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
792 (len == strlen(dest) + 1));
793
794 src = "foobar";
795 target = "66:6f:6f:62:61:72";
796 dest = apr_pencode_base16(pool, src, APR_ENCODE_STRING, APR_ENCODE_COLON | APR_ENCODE_LOWER, &len);
797 ABTS_STR_EQUAL(tc, target, dest);
798 apr_encode_base16(NULL, src, APR_ENCODE_STRING, APR_ENCODE_COLON, &len);
799 ABTS_ASSERT(tc,
800 apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
801 (len == strlen(dest) + 1));
802
803 src = "foobar";
804 target = "66:6F:6F:62:61:72";
805 dest = apr_pencode_base16(pool, src, APR_ENCODE_STRING, APR_ENCODE_COLON, &len);
806 ABTS_STR_EQUAL(tc, target, dest);
807 apr_encode_base16(NULL, src, APR_ENCODE_STRING, APR_ENCODE_COLON, &len);
808 ABTS_ASSERT(tc,
809 apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
810 (len == strlen(dest) + 1));
811
812 apr_pool_destroy(pool);
813}
814
815static void test_encode_base16_binary(abts_case * tc, void *data)
816{
817 apr_pool_t *pool;
818 const char *target;
819 const unsigned char usrc[] = {
820 0xFF, 0x00, 0xFF, 0x00
821 };
822 const char *dest;
823 apr_size_t len;
824
825 apr_pool_create(&pool, NULL);
826
827 target = "ff00ff00";
828 dest = apr_pencode_base16_binary(pool, usrc, 4, APR_ENCODE_LOWER, &len);
829 ABTS_STR_EQUAL(tc, target, dest);
830 apr_encode_base16_binary(NULL, usrc, 4, APR_ENCODE_NONE, &len);
831 ABTS_ASSERT(tc,
832 apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
833 (len == strlen(dest) + 1));
834
835 target = "FF00FF00";
836 dest = apr_pencode_base16_binary(pool, usrc, 4, APR_ENCODE_NONE, &len);
837 ABTS_STR_EQUAL(tc, target, dest);
838 apr_encode_base16_binary(NULL, usrc, 4, APR_ENCODE_NONE, &len);
839 ABTS_ASSERT(tc,
840 apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
841 (len == strlen(dest) + 1));
842
843 target = "ff:00:ff:00";
844 dest = apr_pencode_base16_binary(pool, usrc, 4, APR_ENCODE_COLON | APR_ENCODE_LOWER, &len);
845 ABTS_STR_EQUAL(tc, target, dest);
846 apr_encode_base16_binary(NULL, usrc, 4, APR_ENCODE_COLON, &len);
847 ABTS_ASSERT(tc,
848 apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
849 (len == strlen(dest) + 1));
850
851 target = "FF:00:FF:00";
852 dest = apr_pencode_base16_binary(pool, usrc, 4, APR_ENCODE_COLON, &len);
853 ABTS_STR_EQUAL(tc, target, dest);
854 apr_encode_base16_binary(NULL, usrc, 4, APR_ENCODE_COLON, &len);
855 ABTS_ASSERT(tc,
856 apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
857 (len == strlen(dest) + 1));
858
859 apr_pool_destroy(pool);
860}
861
862static void test_decode_base16(abts_case * tc, void *data)
863{
864 apr_pool_t *pool;
865 const char *src, *target;
866 const char *dest;
867 apr_size_t len;
868
869 apr_pool_create(&pool, NULL);
870
871 src = "3A:3B:3C:3D";
872 target = ":;<=";
873 dest = apr_pdecode_base16(pool, src, APR_ENCODE_STRING, APR_ENCODE_COLON, &len);
874 ABTS_STR_EQUAL(tc, target, dest);
875 ABTS_SIZE_EQUAL(tc, 4, len);
876 apr_decode_base16(NULL, src, APR_ENCODE_STRING, APR_ENCODE_COLON, &len);
877 ABTS_ASSERT(tc,
878 apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, (apr_size_t) 5),
879 (len == 5));
880
881 apr_pool_destroy(pool);
882}
883
884static void test_decode_base16_binary(abts_case * tc, void *data)
885{
886 apr_pool_t *pool;
887 const char *src;
888 const unsigned char utarget[] = {
889 0xFF, 0x00, 0xFF, 0x00
890 };
891 const unsigned char *udest;
892 apr_size_t len, vlen;
893
894 apr_pool_create(&pool, NULL);
895
896 src = "ff:00:ff:00";
897 udest = apr_pdecode_base16_binary(pool, src, APR_ENCODE_STRING, APR_ENCODE_COLON, &vlen);
898 ABTS_ASSERT(tc, "apr_pdecode_base16_binary target!=dest", memcmp(utarget, udest, 4) == 0);
899 ABTS_SIZE_EQUAL(tc, vlen, 4);
900 apr_decode_base16_binary(NULL, src, APR_ENCODE_STRING, APR_ENCODE_COLON, &len);
901 ABTS_ASSERT(tc,
902 apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, (apr_size_t) 4),
903 (len == 4));
904
905 apr_pool_destroy(pool);
906}
907
908static void test_encode_errors(abts_case * tc, void *data)
909{
910 char dest[64];
911 apr_size_t len;
912 apr_status_t rv;
913
914 /* Can't test APR_ENOSPC without a NUL terminated buffer of
915 * length APR_SIZE_MAX / 4 * 3 and passing APR_ENCODE_STRING,
916 * which we won't even think about :)
917 */
918
919 /* base64 */
920 rv = apr_encode_base64(dest, "", -2, 0, &len);
921 ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
922 rv = apr_encode_base64(dest, NULL, APR_ENCODE_STRING, 0, &len);
923 ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
924
925 /* base64_binary */
926 rv = apr_encode_base64_binary(dest, (const unsigned char *)"", -2, 0, &len);
927 ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
928 rv = apr_encode_base64_binary(dest, NULL, APR_ENCODE_STRING, 0, &len);
929 ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
930
931 /* base32 */
932 rv = apr_encode_base32(dest, "", -2, 0, &len);
933 ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
934 rv = apr_encode_base32(dest, NULL, APR_ENCODE_STRING, 0, &len);
935 ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
936
937 /* base32_binary */
938 rv = apr_encode_base32_binary(dest, (const unsigned char *)"", -2, 0, &len);
939 ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
940 rv = apr_encode_base32_binary(dest, NULL, APR_ENCODE_STRING, 0, &len);
941 ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
942
943 /* base16 */
944 rv = apr_encode_base16(dest, "", -2, 0, &len);
945 ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
946 rv = apr_encode_base16(dest, NULL, APR_ENCODE_STRING, 0, &len);
947 ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
948
949 /* base16_binary */
950 rv = apr_encode_base16_binary(dest, (const unsigned char *)"", -2, 0, &len);
951 ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
952 rv = apr_encode_base16_binary(dest, NULL, APR_ENCODE_STRING, 0, &len);
953 ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
954}
955
956static void test_decode_errors(abts_case * tc, void *data)
957{
958 char dest[64];
959 apr_size_t len;
960 apr_status_t rv;
961 unsigned char *udest = (unsigned char *)dest;
962
963 /* base64 */
964 rv = apr_decode_base64(dest, "", -2, 0, &len);
965 ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
966 rv = apr_decode_base64(dest, NULL, APR_ENCODE_STRING, 0, &len);
967 ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
968 rv = apr_decode_base64(NULL, NULL, 5, 0, &len);
969 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
970 rv = apr_decode_base64(dest, "ABCDE", APR_ENCODE_STRING, 0, &len);
971 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
972 rv = apr_decode_base64(dest, "ABCD*EF", APR_ENCODE_STRING, 0, &len);
973 ABTS_INT_EQUAL(tc, APR_BADCH, rv);
974 rv = apr_decode_base64(dest, "ABCD*EF", APR_ENCODE_STRING,
975 APR_ENCODE_RELAXED, &len);
976 ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
977 ABTS_SIZE_EQUAL(tc, 3, len);
978
979 /* base64_binary */
980 rv = apr_decode_base64_binary(udest, "", -2, 0, &len);
981 ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
982 rv = apr_decode_base64_binary(udest, NULL, APR_ENCODE_STRING, 0, &len);
983 ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
984 rv = apr_decode_base64_binary(NULL, NULL, 5, 0, &len);
985 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
986 rv = apr_decode_base64_binary(udest, "ABCDE", APR_ENCODE_STRING, 0, &len);
987 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
988 rv = apr_decode_base64_binary(udest, "ABCD*EF", APR_ENCODE_STRING, 0, &len);
989 ABTS_INT_EQUAL(tc, APR_BADCH, rv);
990 rv = apr_decode_base64_binary(udest, "ABCD*EF", APR_ENCODE_STRING,
991 APR_ENCODE_RELAXED, &len);
992 ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
993 ABTS_SIZE_EQUAL(tc, 3, len);
994
995 /* base32 */
996 rv = apr_decode_base32(dest, "", -2, 0, &len);
997 ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
998 rv = apr_decode_base32(dest, NULL, APR_ENCODE_STRING, 0, &len);
999 ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
1000 rv = apr_decode_base32(NULL, NULL, 9, 0, &len);
1001 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1002 rv = apr_decode_base32(NULL, NULL, 11, 0, &len);
1003 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1004 rv = apr_decode_base32(NULL, NULL, 14, 0, &len);
1005 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1006 rv = apr_decode_base32(dest, "ABCDEFGHI", APR_ENCODE_STRING, 0, &len);
1007 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1008 rv = apr_decode_base32(dest, "ABCDEFGHIJK", APR_ENCODE_STRING, 0, &len);
1009 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1010 rv = apr_decode_base32(dest, "ABCDEFGHIJKLMN", APR_ENCODE_STRING, 0, &len);
1011 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1012 rv = apr_decode_base32(dest, "ABCDEFGH*IJ", APR_ENCODE_STRING, 0, &len);
1013 ABTS_INT_EQUAL(tc, APR_BADCH, rv);
1014 rv = apr_decode_base32(dest, "ABCEEFGH*IJ", APR_ENCODE_STRING,
1015 APR_ENCODE_RELAXED, &len);
1016 ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
1017 ABTS_SIZE_EQUAL(tc, 5, len);
1018
1019 /* base32_binary */
1020 rv = apr_decode_base32_binary(udest, "", -2, 0, &len);
1021 ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
1022 rv = apr_decode_base32_binary(udest, NULL, APR_ENCODE_STRING, 0, &len);
1023 ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
1024 rv = apr_decode_base32_binary(NULL, NULL, 9, 0, &len);
1025 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1026 rv = apr_decode_base32_binary(NULL, NULL, 11, 0, &len);
1027 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1028 rv = apr_decode_base32_binary(NULL, NULL, 14, 0, &len);
1029 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1030 rv = apr_decode_base32_binary(udest, "ABCDEFGHI", APR_ENCODE_STRING, 0, &len);
1031 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1032 rv = apr_decode_base32_binary(udest, "ABCDEFGHIJK", APR_ENCODE_STRING, 0, &len);
1033 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1034 rv = apr_decode_base32_binary(udest, "ABCDEFGHIJKLMN", APR_ENCODE_STRING, 0, &len);
1035 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1036 rv = apr_decode_base32_binary(udest, "ABCDEFGH*IJ", APR_ENCODE_STRING, 0, &len);
1037 ABTS_INT_EQUAL(tc, APR_BADCH, rv);
1038 rv = apr_decode_base32_binary(udest, "ABCEEFGH*IJ", APR_ENCODE_STRING,
1039 APR_ENCODE_RELAXED, &len);
1040 ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
1041 ABTS_SIZE_EQUAL(tc, 5, len);
1042
1043 /* base16 */
1044 rv = apr_decode_base16(dest, "", -2, 0, &len);
1045 ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
1046 rv = apr_decode_base16(dest, NULL, APR_ENCODE_STRING, 0, &len);
1047 ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
1048 rv = apr_decode_base16(NULL, NULL, 3, 0, &len);
1049 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1050 rv = apr_decode_base16(dest, "ABC", APR_ENCODE_STRING, 0, &len);
1051 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1052 rv = apr_decode_base16(dest, "ABCD*EF", APR_ENCODE_STRING, 0, &len);
1053 ABTS_INT_EQUAL(tc, APR_BADCH, rv);
1054 rv = apr_decode_base16(dest, "ABCD*EF", APR_ENCODE_STRING,
1055 APR_ENCODE_RELAXED, &len);
1056 ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
1057 ABTS_SIZE_EQUAL(tc, 2, len);
1058 /* base16 with colon */
1059 rv = apr_decode_base16(dest, "AB:", APR_ENCODE_STRING,
1060 APR_ENCODE_COLON, &len);
1061 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1062 rv = apr_decode_base16(dest, "AB:C", APR_ENCODE_STRING,
1063 APR_ENCODE_COLON, &len);
1064 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1065 rv = apr_decode_base16(dest, "AB:CD*EF", APR_ENCODE_STRING,
1066 APR_ENCODE_COLON, &len);
1067 ABTS_INT_EQUAL(tc, APR_BADCH, rv);
1068 rv = apr_decode_base16(dest, "AB:CD*EF", APR_ENCODE_STRING,
1069 APR_ENCODE_COLON|APR_ENCODE_RELAXED, &len);
1070 ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
1071 ABTS_SIZE_EQUAL(tc, 2, len);
1072
1073 /* base16_binary */
1074 rv = apr_decode_base16_binary(udest, "", -2, 0, &len);
1075 ABTS_INT_EQUAL(tc, APR_EINVAL, rv);
1076 rv = apr_decode_base16_binary(udest, NULL, APR_ENCODE_STRING, 0, &len);
1077 ABTS_INT_EQUAL(tc, APR_NOTFOUND, rv);
1078 rv = apr_decode_base16_binary(NULL, NULL, 3, 0, &len);
1079 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1080 rv = apr_decode_base16_binary(udest, "ABC", APR_ENCODE_STRING, 0, &len);
1081 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1082 rv = apr_decode_base16_binary(udest, "ABCD*EF", APR_ENCODE_STRING, 0, &len);
1083 ABTS_INT_EQUAL(tc, APR_BADCH, rv);
1084 rv = apr_decode_base16_binary(udest, "ABCD*EF", APR_ENCODE_STRING,
1085 APR_ENCODE_RELAXED, &len);
1086 ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
1087 ABTS_SIZE_EQUAL(tc, 2, len);
1088 /* base16_binary with colon */
1089 rv = apr_decode_base16_binary(udest, "AB:", APR_ENCODE_STRING,
1090 APR_ENCODE_COLON, &len);
1091 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1092 rv = apr_decode_base16_binary(udest, "AB:C", APR_ENCODE_STRING,
1093 APR_ENCODE_COLON, &len);
1094 ABTS_INT_EQUAL(tc, APR_EINCOMPLETE, rv);
1095 rv = apr_decode_base16_binary(udest, "AB:CD*EF", APR_ENCODE_STRING,
1096 APR_ENCODE_COLON, &len);
1097 ABTS_INT_EQUAL(tc, APR_BADCH, rv);
1098 rv = apr_decode_base16_binary(udest, "AB:CD*EF", APR_ENCODE_STRING,
1099 APR_ENCODE_COLON|APR_ENCODE_RELAXED, &len);
1100 ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
1101 ABTS_SIZE_EQUAL(tc, 2, len);
1102}
1103
len
const char apr_size_t len
Definition ap_regex.h:187
abts_run_test
void abts_run_test(abts_suite *ts, test_func f, void *value)
Definition abts.c:175
ABTS_SIZE_EQUAL
#define ABTS_SIZE_EQUAL(a, b, c)
Definition abts.h:121
ADD_SUITE
#define ADD_SUITE(suite)
Definition abts.h:67
ABTS_STR_EQUAL
#define ABTS_STR_EQUAL(a, b, c)
Definition abts.h:123
ABTS_ASSERT
#define ABTS_ASSERT(a, b, c)
Definition abts.h:130
ABTS_INT_EQUAL
#define ABTS_INT_EQUAL(a, b, c)
Definition abts.h:109
apr_encode.h
APR-UTIL Encoding.
apr_strings.h
APR Strings library.
APR_BADCH
#define APR_BADCH
Definition apr_errno.h:457
APR_NOTFOUND
#define APR_NOTFOUND
Definition apr_errno.h:463
APR_EINCOMPLETE
#define APR_EINCOMPLETE
Definition apr_errno.h:328
APR_EINVAL
#define APR_EINVAL
Definition apr_errno.h:711
APR_ENCODE_BASE32HEX
#define APR_ENCODE_BASE32HEX
Definition apr_encode.h:135
APR_ENCODE_COLON
#define APR_ENCODE_COLON
Definition apr_encode.h:140
src
const char * src
Definition apr_encode.h:167
APR_ENCODE_RELAXED
#define APR_ENCODE_RELAXED
Definition apr_encode.h:115
APR_ENCODE_LOWER
#define APR_ENCODE_LOWER
Definition apr_encode.h:145
APR_ENCODE_NONE
#define APR_ENCODE_NONE
Definition apr_encode.h:110
APR_ENCODE_NOPADDING
#define APR_ENCODE_NOPADDING
Definition apr_encode.h:120
APR_ENCODE_STRING
#define APR_ENCODE_STRING
Definition apr_encode.h:105
size
apr_size_t size
Definition apr_allocator.h:115
pool
const char int apr_pool_t * pool
Definition apr_cstr.h:84
APR_SUCCESS
#define APR_SUCCESS
Definition apr_errno.h:225
apr_status_t
int apr_status_t
Definition apr_errno.h:44
data
void * data
Definition apr_file_io.h:832
apr_pool_create
#define apr_pool_create(newpool, parent)
Definition apr_pools.h:322
NULL
return NULL
Definition mod_so.c:359
abts_case
Definition abts.h:58
abts_suite
Definition abts.h:52
apr_pool_t
Definition apr_pools.c:562
testencode
abts_suite * testencode(abts_suite *suite)
Definition testencode.c:1104
test_encode_base64_binary
static void test_encode_base64_binary(abts_case *tc, void *data)
Definition testencode.c:79
test_encode_errors
static void test_encode_errors(abts_case *tc, void *data)
Definition testencode.c:908
test_encode_base16_binary
static void test_encode_base16_binary(abts_case *tc, void *data)
Definition testencode.c:815
test_decode_base64
static void test_decode_base64(abts_case *tc, void *data)
Definition testencode.c:122
test_encode_base32
static void test_encode_base32(abts_case *tc, void *data)
Definition testencode.c:232
test_decode_base32
static void test_decode_base32(abts_case *tc, void *data)
Definition testencode.c:487
test_decode_errors
static void test_decode_errors(abts_case *tc, void *data)
Definition testencode.c:956
test_decode_base64_binary
static void test_decode_base64_binary(abts_case *tc, void *data)
Definition testencode.c:177
test_encode_base64
static void test_encode_base64(abts_case *tc, void *data)
Definition testencode.c:29
test_decode_base16
static void test_decode_base16(abts_case *tc, void *data)
Definition testencode.c:862
test_decode_base16_binary
static void test_decode_base16_binary(abts_case *tc, void *data)
Definition testencode.c:884
ufoobar
static const unsigned char ufoobar[]
Definition testencode.c:27
test_decode_base32_binary
static void test_decode_base32_binary(abts_case *tc, void *data)
Definition testencode.c:627
test_encode_base32_binary
static void test_encode_base32_binary(abts_case *tc, void *data)
Definition testencode.c:372
test_encode_base16
static void test_encode_base16(abts_case *tc, void *data)
Definition testencode.c:767
Generated by doxygen 1.9.8