Annotation of embedaddon/strongswan/src/libstrongswan/tests/suites/test_utils.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (C) 2013-2015 Tobias Brunner
3: * HSR Hochschule fuer Technik Rapperswil
4: *
5: * This program is free software; you can redistribute it and/or modify it
6: * under the terms of the GNU General Public License as published by the
7: * Free Software Foundation; either version 2 of the License, or (at your
8: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
9: *
10: * This program is distributed in the hope that it will be useful, but
11: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13: * for more details.
14: */
15:
16: #include "test_suite.h"
17:
18: #include <library.h>
19: #include <utils/utils.h>
20: #include <ipsec/ipsec_types.h>
21: #include <credentials/keys/public_key.h>
22:
23: #include <time.h>
24:
25: /*******************************************************************************
26: * object storage on lib
27: */
28:
29: START_TEST(test_objects)
30: {
31: char *k1 = "key1", *k2 = "key2";
32: char *v1 = "val1", *val;
33:
34: ck_assert(lib->get(lib, k1) == NULL);
35:
36: ck_assert(lib->set(lib, k1, v1));
37: ck_assert(!lib->set(lib, k1, v1));
38:
39: val = lib->get(lib, k1);
40: ck_assert(val != NULL);
41: ck_assert(streq(val, v1));
42:
43: ck_assert(lib->set(lib, k1, NULL));
44: ck_assert(!lib->set(lib, k2, NULL));
45:
46: ck_assert(lib->get(lib, k1) == NULL);
47: }
48: END_TEST
49:
50: /*******************************************************************************
51: * test return_... functions
52: */
53:
54: START_TEST(test_return_functions)
55: {
56: ck_assert(return_null() == NULL);
57: ck_assert(return_null("asdf", 5, NULL, 1, "qwer") == NULL);
58:
59: ck_assert(return_true() == TRUE);
60: ck_assert(return_true("asdf", 5, NULL, 1, "qwer") == TRUE);
61:
62: ck_assert(return_false() == FALSE);
63: ck_assert(return_false("asdf", 5, NULL, 1, "qwer") == FALSE);
64:
65: ck_assert(return_failed() == FAILED);
66: ck_assert(return_failed("asdf", 5, NULL, 1, "qwer") == FAILED);
67:
68: ck_assert(return_success() == SUCCESS);
69: ck_assert(return_success("asdf", 5, NULL, 1, "qwer") == SUCCESS);
70:
71: /* just make sure this works */
72: nop();
73: nop("asdf", 5, NULL, 1, "qwer");
74: }
75: END_TEST
76:
77: /*******************************************************************************
78: * timeval_add_ms
79: */
80:
81: START_TEST(test_timeval_add_ms)
82: {
83: timeval_t tv;
84:
85: tv.tv_sec = 0;
86: tv.tv_usec = 0;
87: timeval_add_ms(&tv, 0);
88: ck_assert_int_eq(tv.tv_sec, 0);
89: ck_assert_int_eq(tv.tv_usec, 0);
90:
91: timeval_add_ms(&tv, 1);
92: ck_assert_int_eq(tv.tv_sec, 0);
93: ck_assert_int_eq(tv.tv_usec, 1000);
94:
95: timeval_add_ms(&tv, 0);
96: ck_assert_int_eq(tv.tv_sec, 0);
97: ck_assert_int_eq(tv.tv_usec, 1000);
98:
99: timeval_add_ms(&tv, 999);
100: ck_assert_int_eq(tv.tv_sec, 1);
101: ck_assert_int_eq(tv.tv_usec, 0);
102:
103: timeval_add_ms(&tv, 0);
104: ck_assert_int_eq(tv.tv_sec, 1);
105: ck_assert_int_eq(tv.tv_usec, 0);
106:
107: timeval_add_ms(&tv, 1000);
108: ck_assert_int_eq(tv.tv_sec, 2);
109: ck_assert_int_eq(tv.tv_usec, 0);
110:
111: timeval_add_ms(&tv, 1500);
112: ck_assert_int_eq(tv.tv_sec, 3);
113: ck_assert_int_eq(tv.tv_usec, 500000);
114: }
115: END_TEST
116:
117: /*******************************************************************************
118: * timespan_from_string
119: */
120:
121: static struct {
122: char *s;
123: char *u;
124: bool v;
125: time_t t;
126: } ts_data[] = {
127: {NULL, NULL, FALSE, 0},
128: {"", NULL, FALSE, 0},
129: {"a", NULL, FALSE, 0},
130: {"0", NULL, TRUE, 0},
131: {"5", NULL, TRUE, 5},
132: {"5s", NULL, TRUE, 5},
133: {"5m", NULL, TRUE, 300},
134: {"5ms", NULL, TRUE, 300},
135: {"5h", NULL, TRUE, 18000},
136: {"5d", NULL, TRUE, 432000},
137: {"5x", NULL, FALSE, 0},
138: {"5", "", TRUE, 5},
139: {"5", "m", TRUE, 300},
140: {"5", "ms", TRUE, 300},
141: {"5", "x", FALSE, 0},
142: {"5x", "m", FALSE, 0},
143: {"18446744073709551616", NULL, FALSE, 0},
144: };
145:
146: START_TEST(test_timespan_from_string)
147: {
148: time_t val = 42;
149:
150: ck_assert(timespan_from_string(ts_data[_i].s, ts_data[_i].u,
151: NULL) == ts_data[_i].v);
152: ck_assert(timespan_from_string(ts_data[_i].s, ts_data[_i].u,
153: &val) == ts_data[_i].v);
154: if (ts_data[_i].v)
155: {
156: ck_assert_int_eq(val, ts_data[_i].t);
157: }
158: else
159: {
160: ck_assert_int_eq(val, 42);
161: }
162: }
163: END_TEST
164:
165: /*******************************************************************************
166: * htoun/untoh
167: */
168:
169: START_TEST(test_htoun)
170: {
171: chunk_t net64, expected;
172: uint16_t host16 = 513;
173: uint32_t net16 = 0, host32 = 67305985;
174: uint64_t net32 = 0, host64 = 578437695752307201ULL;
175:
176: net64 = chunk_alloca(16);
177: memset(net64.ptr, 0, net64.len);
178:
179: expected = chunk_from_chars(0x00, 0x02, 0x01, 0x00);
180: htoun16((char*)&net16 + 1, host16);
181: ck_assert(chunk_equals(expected, chunk_from_thing(net16)));
182:
183: expected = chunk_from_chars(0x00, 0x00, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00);
184: htoun32((uint16_t*)&net32 + 1, host32);
185: ck_assert(chunk_equals(expected, chunk_from_thing(net32)));
186:
187: expected = chunk_from_chars(0x00, 0x00, 0x00, 0x00,
188: 0x08, 0x07, 0x06, 0x05,
189: 0x04, 0x03, 0x02, 0x01,
190: 0x00, 0x00, 0x00, 0x00);
191: htoun64((uint32_t*)net64.ptr + 1, host64);
192: ck_assert(chunk_equals(expected, net64));
193: }
194: END_TEST
195:
196: START_TEST(test_untoh)
197: {
198: chunk_t net;
199: uint16_t host16;
200: uint32_t host32;
201: uint64_t host64;
202:
203: net = chunk_from_chars(0x00, 0x02, 0x01, 0x00);
204: host16 = untoh16(net.ptr + 1);
205: ck_assert(host16 == 513);
206:
207: net = chunk_from_chars(0x00, 0x00, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00);
208: host32 = untoh32(net.ptr + 2);
209: ck_assert(host32 == 67305985);
210:
211: net = chunk_from_chars(0x00, 0x00, 0x00, 0x00, 0x08, 0x07, 0x06, 0x05,
212: 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00);
213: host64 = untoh64(net.ptr + 4);
214: ck_assert(host64 == 578437695752307201ULL);
215: }
216: END_TEST
217:
218: /*******************************************************************************
219: * pad_len/round_up/down
220: */
221:
222: START_TEST(test_round)
223: {
224: ck_assert_int_eq(pad_len(0, 4), 0);
225: ck_assert_int_eq(pad_len(1, 4), 3);
226: ck_assert_int_eq(pad_len(2, 4), 2);
227: ck_assert_int_eq(pad_len(3, 4), 1);
228: ck_assert_int_eq(pad_len(4, 4), 0);
229: ck_assert_int_eq(pad_len(5, 4), 3);
230:
231: ck_assert_int_eq(round_up(0, 4), 0);
232: ck_assert_int_eq(round_up(1, 4), 4);
233: ck_assert_int_eq(round_up(2, 4), 4);
234: ck_assert_int_eq(round_up(3, 4), 4);
235: ck_assert_int_eq(round_up(4, 4), 4);
236: ck_assert_int_eq(round_up(5, 4), 8);
237:
238: ck_assert_int_eq(round_down(0, 4), 0);
239: ck_assert_int_eq(round_down(1, 4), 0);
240: ck_assert_int_eq(round_down(2, 4), 0);
241: ck_assert_int_eq(round_down(3, 4), 0);
242: ck_assert_int_eq(round_down(4, 4), 4);
243: ck_assert_int_eq(round_down(5, 4), 4);
244: }
245: END_TEST
246:
247: /*******************************************************************************
248: * streq
249: */
250:
251: static struct {
252: char *a;
253: char *b;
254: bool eq;
255: bool case_eq;
256: } streq_data[] = {
257: {NULL, NULL, TRUE, TRUE},
258: {NULL, "", FALSE, FALSE},
259: {"", NULL, FALSE, FALSE},
260: {"abc", "", FALSE, FALSE},
261: {"abc", "abc", TRUE, TRUE},
262: {"abc", "ABC", FALSE, TRUE},
263: };
264:
265: START_TEST(test_streq)
266: {
267: bool eq;
268:
269: ck_assert(streq(streq_data[_i].a, streq_data[_i].a));
270: ck_assert(streq(streq_data[_i].b, streq_data[_i].b));
271: eq = streq(streq_data[_i].a, streq_data[_i].b);
272: ck_assert(eq == streq_data[_i].eq);
273:
274: ck_assert(strcaseeq(streq_data[_i].a, streq_data[_i].a));
275: ck_assert(strcaseeq(streq_data[_i].b, streq_data[_i].b));
276: eq = strcaseeq(streq_data[_i].a, streq_data[_i].b);
277: ck_assert(eq == streq_data[_i].case_eq);
278: }
279: END_TEST
280:
281: /*******************************************************************************
282: * strneq
283: */
284:
285: static struct {
286: char *a;
287: char *b;
288: size_t n;
289: bool eq;
290: bool case_eq;
291: } strneq_data[] = {
292: {NULL, NULL, 0, TRUE, TRUE},
293: {NULL, NULL, 10, TRUE, TRUE},
294: {NULL, "", 0, FALSE, FALSE},
295: {"", NULL, 0, FALSE, FALSE},
296: {"abc", "", 0, TRUE, TRUE},
297: {"abc", "", 1, FALSE, FALSE},
298: {"abc", "ab", 1, TRUE, TRUE},
299: {"abc", "ab", 2, TRUE, TRUE},
300: {"abc", "ab", 3, FALSE, FALSE},
301: {"abc", "abc", 3, TRUE, TRUE},
302: {"abc", "abc", 4, TRUE, TRUE},
303: {"abc", "abC", 2, TRUE, TRUE},
304: {"abc", "abC", 3, FALSE, TRUE},
305: };
306:
307: START_TEST(test_strneq)
308: {
309: bool eq;
310:
311: ck_assert(strneq(strneq_data[_i].a, strneq_data[_i].a, strneq_data[_i].n));
312: ck_assert(strneq(strneq_data[_i].b, strneq_data[_i].b, strneq_data[_i].n));
313: eq = strneq(strneq_data[_i].a, strneq_data[_i].b, strneq_data[_i].n);
314: ck_assert(eq == strneq_data[_i].eq);
315:
316: ck_assert(strncaseeq(strneq_data[_i].a, strneq_data[_i].a, strneq_data[_i].n));
317: ck_assert(strncaseeq(strneq_data[_i].b, strneq_data[_i].b, strneq_data[_i].n));
318: eq = strncaseeq(strneq_data[_i].a, strneq_data[_i].b, strneq_data[_i].n);
319: ck_assert(eq == strneq_data[_i].case_eq);
320: }
321: END_TEST
322:
323: /*******************************************************************************
324: * strpfx
325: */
326:
327: static struct {
328: char *str;
329: char *pfx;
330: bool prefix;
331: bool case_prefix;
332: } strpfx_data[] = {
333: {"", "", TRUE, TRUE},
334: {"abc", "", TRUE, TRUE},
335: {"abc", "a", TRUE, TRUE},
336: {"abc", "ab", TRUE, TRUE},
337: {"abc", "abc", TRUE, TRUE},
338: {"abc", "abcd", FALSE, FALSE},
339: {"abc", "AB", FALSE, TRUE},
340: {"ABC", "ab", FALSE, TRUE},
341: {" abc", "abc", FALSE, FALSE},
342: };
343:
344: START_TEST(test_strpfx)
345: {
346: bool prefix;
347:
348: prefix = strpfx(strpfx_data[_i].str, strpfx_data[_i].pfx);
349: ck_assert(prefix == strpfx_data[_i].prefix);
350: prefix = strcasepfx(strpfx_data[_i].str, strpfx_data[_i].pfx);
351: ck_assert(prefix == strpfx_data[_i].case_prefix);
352: }
353: END_TEST
354:
355: /*******************************************************************************
356: * malloc_align/free_align
357: */
358:
359: START_TEST(test_malloc_align)
360: {
361: void *ptr[128][256];
362: int size, align;
363:
364: for (size = 0; size < countof(ptr); size++)
365: {
366: for (align = 0; align < countof(ptr[0]); align++)
367: {
368: ptr[size][align] = malloc_align(size, align);
369: if (align)
370: {
371: ck_assert((uintptr_t)ptr[size][align] % align == 0);
372: }
373: if (size)
374: {
375: ck_assert(ptr[size][align]);
376: memset(ptr[size][align], 0xEF, size);
377: }
378: }
379: }
380: for (size = 0; size < countof(ptr); size++)
381: {
382: for (align = 0; align < countof(ptr[0]); align++)
383: {
384: free_align(ptr[size][align]);
385: }
386: }
387: }
388: END_TEST
389:
390: /*******************************************************************************
391: * memxor
392: */
393:
394: static void do_memxor(chunk_t a, chunk_t b, chunk_t exp)
395: {
396: chunk_t dst;
397:
398: dst = chunk_clonea(a);
399: dst.len = b.len;
400: memxor(dst.ptr, b.ptr, b.len);
401: ck_assert(chunk_equals(dst, exp));
402: }
403:
404: START_TEST(test_memxor)
405: {
406: chunk_t a, b, dst;
407: int i;
408:
409: a = chunk_alloca(64);
410: memset(a.ptr, 0, a.len);
411: b = chunk_alloca(64);
412: for (i = 0; i < 64; i++)
413: {
414: b.ptr[i] = i;
415: b.len = i;
416: do_memxor(a, b, b);
417: }
418: b.len = 64;
419: do_memxor(a, b, b);
420:
421: dst = chunk_clonea(a);
422: memxor(dst.ptr, b.ptr, b.len);
423: ck_assert(chunk_equals(dst, b));
424:
425: memxor(dst.ptr, b.ptr, 0);
426: memxor(dst.ptr, b.ptr, 1);
427: memxor(dst.ptr + 1, b.ptr + 1, 1);
428: memxor(dst.ptr + 2, b.ptr + 2, b.len - 2);
429: ck_assert(chunk_equals(dst, a));
430: }
431: END_TEST
432:
433: START_TEST(test_memxor_aligned)
434: {
435: uint64_t a = 0, b = 0;
436: chunk_t ca, cb;
437: int i;
438:
439: ca = chunk_from_thing(a);
440: cb = chunk_from_thing(b);
441:
442: for (i = 0; i < 8; i++)
443: {
444: cb.ptr[i] = i + 1;
445: }
446:
447: /* 64-bit aligned */
448: memxor(ca.ptr, cb.ptr, 8);
449: ck_assert(a == b);
450: /* 32-bit aligned source */
451: a = 0;
452: memxor(ca.ptr, cb.ptr + 4, 4);
453: ck_assert(chunk_equals(ca, chunk_from_chars(0x05, 0x06, 0x07, 0x08,
454: 0x00, 0x00, 0x00, 0x00)));
455: /* 16-bit aligned source */
456: a = 0;
457: memxor(ca.ptr, cb.ptr + 2, 6);
458: ck_assert(chunk_equals(ca, chunk_from_chars(0x03, 0x04, 0x05, 0x06,
459: 0x07, 0x08, 0x00, 0x00)));
460: /* 8-bit aligned source */
461: a = 0;
462: memxor(ca.ptr, cb.ptr + 1, 7);
463: ck_assert(chunk_equals(ca, chunk_from_chars(0x02, 0x03, 0x04, 0x05,
464: 0x06, 0x07, 0x08, 0x00)));
465: }
466: END_TEST
467:
468: /*******************************************************************************
469: * memeq/const
470: */
471:
472: static struct {
473: char *a;
474: char *b;
475: size_t n;
476: bool res;
477: } memeq_data[] = {
478: {NULL, NULL, 0, TRUE},
479: {"a", "b", 0, TRUE},
480: {"", "", 1, TRUE},
481: {"abcdefgh", "abcdefgh", 8, TRUE},
482: {"a", "b", 1, FALSE},
483: {"A", "a", 1, FALSE},
484: {"\0a", "\0b", 2, FALSE},
485: {"abc", "abd", 3, FALSE},
486: {"abc", "dbd", 3, FALSE},
487: {"abcdefgh", "abcdffgh", 8, FALSE},
488: {"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz",
489: "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz", 52, TRUE},
490: {"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz",
491: "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyy", 52, FALSE},
492: {"bbcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz",
493: "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz", 52, FALSE},
494: };
495:
496: START_TEST(test_memeq)
497: {
498: ck_assert(memeq(memeq_data[_i].a, memeq_data[_i].b,
499: memeq_data[_i].n) == memeq_data[_i].res);
500: }
501: END_TEST
502:
503: START_TEST(test_memeq_const)
504: {
505: ck_assert(memeq_const(memeq_data[_i].a, memeq_data[_i].b,
506: memeq_data[_i].n) == memeq_data[_i].res);
507: }
508: END_TEST
509:
510: /*******************************************************************************
511: * memstr
512: */
513:
514: static struct {
515: char *haystack;
516: char *needle;
517: size_t n;
518: int offset;
519: } memstr_data[] = {
520: {NULL, NULL, 0, -1},
521: {NULL, NULL, 3, -1},
522: {NULL, "abc", 0, -1},
523: {NULL, "abc", 3, -1},
524: {"", "", 0, -1},
525: {"abc", NULL, 3, -1},
526: {"abc", "", 3, -1},
527: {"abc", "abc", 3, 0},
528: {" abc", "abc", 4, 1},
529: {" abc", "abc", 3, -1},
530: {"abcabc", "abc", 6, 0},
531: {" abc ", "abc", 5, 1},
532: };
533:
534: START_TEST(test_memstr)
535: {
536: char *ret;
537:
538: ret = memstr(memstr_data[_i].haystack, memstr_data[_i].needle, memstr_data[_i].n);
539: if (memstr_data[_i].offset >= 0)
540: {
541: ck_assert(ret == memstr_data[_i].haystack + memstr_data[_i].offset);
542: }
543: else
544: {
545: ck_assert(ret == NULL);
546: }
547: }
548: END_TEST
549:
550: /*******************************************************************************
551: * memwipe
552: */
553:
554: START_TEST(test_memwipe_null)
555: {
556: memwipe(NULL, 16);
557: }
558: END_TEST
559:
560: static inline bool test_wiped_memory(char *buf, size_t len)
561: {
562: int i;
563:
564: /* comparing two bytes at once reduces the chances of conflicts if memory
565: * got overwritten already */
566: for (i = 0; i < len; i += 2)
567: {
568: if (buf[i] != 0 && buf[i] == i &&
569: buf[i+1] != 0 && buf[i+1] == i+1)
570: {
571: return FALSE;
572: }
573: }
574: return TRUE;
575: }
576:
577: START_TEST(test_memwipe_stack)
578: {
579: char buf[64];
580: int i;
581:
582: for (i = 0; i < sizeof(buf); i++)
583: {
584: buf[i] = i;
585: }
586: memwipe(buf, sizeof(buf));
587: ck_assert(test_wiped_memory(buf, sizeof(buf)));
588: }
589: END_TEST
590:
591: START_TEST(test_memwipe_heap)
592: {
593: size_t len = 64;
594: char *buf = malloc(len);
595: int i;
596:
597: for (i = 0; i < len; i++)
598: {
599: buf[i] = i;
600: }
601: memwipe(buf, len);
602: ck_assert(test_wiped_memory(buf, len));
603: free(buf);
604: }
605: END_TEST
606:
607: /*******************************************************************************
608: * utils_memrchr
609: */
610:
611: static struct {
612: char *s;
613: int c;
614: size_t n;
615: int offset;
616: } memrchr_data[] = {
617: {NULL, 'f', 0, -1},
618: {NULL, 'f', 3, -1},
619: {"", 'f', 0, -1},
620: {"", '\0', 1, 0},
621: {"foo", '\0', 3, -1},
622: {"foo", '\0', 4, 3},
623: {"foo", 'f', 3, 0},
624: {"foo", 'o', 3, 2},
625: {"foo", 'o', 2, 1},
626: {"foo", 'o', 1, -1},
627: {"foo", 'o', 0, -1},
628: {"foo", 'x', 3, -1},
629: };
630:
631: START_TEST(test_utils_memrchr)
632: {
633: void *ret;
634:
635: ret = utils_memrchr(memrchr_data[_i].s, memrchr_data[_i].c, memrchr_data[_i].n);
636: if (memrchr_data[_i].offset >= 0)
637: {
638: ck_assert(ret == memrchr_data[_i].s + memrchr_data[_i].offset);
639: }
640: else
641: {
642: ck_assert(ret == NULL);
643: }
644: }
645: END_TEST
646:
647: /*******************************************************************************
648: * translate
649: */
650:
651: static struct {
652: char *in;
653: char *from;
654: char *to;
655: char *out;
656: } translate_data[] = {
657: {NULL, "", "", NULL},
658: {"abc", "", "", "abc"},
659: {"abc", "", "x", "abc"},
660: {"abc", "x", "", "abc"},
661: {"abc", "abc", "xyz", "xyz"},
662: {"aabbcc", "abc", "xyz", "xxyyzz"},
663: {"abbaccb", "abc", "xyz", "xyyxzzy"},
664: {"abxyzc", "abc", "xyz", "xyxyzz"},
665: {"abcdef", "abc", "xyz", "xyzdef"},
666: {"aaa", "abc", "xyz", "xxx"},
667: {"abc", "aaa", "xyz", "xbc"},
668: {"abc", "abc", "xxx", "xxx"},
669: };
670:
671: START_TEST(test_translate)
672: {
673: char *str, *ret;
674:
675: str = strdupnull(translate_data[_i].in);
676: ret = translate(str, translate_data[_i].from, translate_data[_i].to);
677: ck_assert(ret == str);
678: if (ret != translate_data[_i].out)
679: {
680: ck_assert_str_eq(str, translate_data[_i].out);
681: }
682: free(str);
683: }
684: END_TEST
685:
686: /*******************************************************************************
687: * strreplace
688: */
689:
690: static struct {
691: char *in;
692: char *out;
693: char *search;
694: char *replace;
695: bool allocated;
696: } strreplace_data[] = {
697: /* invalid arguments */
698: {NULL, NULL, NULL, NULL, FALSE},
699: {"", "", NULL, NULL, FALSE},
700: {"", "", "", NULL, FALSE},
701: {"", "", NULL, "", FALSE},
702: {"", "", "", "", FALSE},
703: {"", "", "", "asdf", FALSE},
704: {"", "", "asdf", "", FALSE},
705: {"asdf", "asdf", NULL, NULL, FALSE},
706: {"asdf", "asdf", "", NULL, FALSE},
707: {"asdf", "asdf", NULL, "", FALSE},
708: {"asdf", "asdf", "", "", FALSE},
709: {"asdf", "asdf", "", "asdf", FALSE},
710: {"asdf", "asdf", "asdf", NULL, FALSE},
711: {"qwer", "qwer", "", "asdf", FALSE},
712: /* replacement shorter */
713: {"asdf", "", "asdf", "", TRUE},
714: {"asdfasdf", "", "asdf", "", TRUE},
715: {"asasdfdf", "asdf", "asdf", "", TRUE},
716: {"asdf", "df", "as", "", TRUE},
717: {"asdf", "as", "df", "", TRUE},
718: {"qwer", "qwer", "asdf", "", FALSE},
719: /* replacement same length */
720: {"a", "b", "a", "b", TRUE},
721: {"aaa", "bbb", "a", "b", TRUE},
722: {"aaa", "bbb", "aaa", "bbb", TRUE},
723: {"asdf", "asdf", "asdf", "asdf", TRUE},
724: {"qwer", "qwer", "asdf", "asdf", FALSE},
725: /* replacement longer */
726: {"asdf", "asdf", "", "asdf", FALSE},
727: {"asdf", "asdfasdf", "asdf", "asdfasdf", TRUE},
728: {"asdf", "asdfsdf", "a", "asdf", TRUE},
729: {"asdf", "asdasdf", "f", "asdf", TRUE},
730: {"aaa", "asdfasdfasdf", "a", "asdf", TRUE},
731: {"qwer", "qwer", "asdf", "asdfasdf", FALSE},
732: /* real examples */
733: {"http://x.org/no/spaces", "http://x.org/no/spaces", " ", "%20", FALSE},
734: {"http://x.org/end ", "http://x.org/end%20", " ", "%20", TRUE},
735: {" http://x.org/start", "%20http://x.org/start", " ", "%20", TRUE},
736: {" http://x.org/both ", "%20http://x.org/both%20", " ", "%20", TRUE},
737: {"http://x.org/ /slash", "http://x.org/%20/slash", " ", "%20", TRUE},
738: {"http://x.org/ /three", "http://x.org/%20%20%20/three", " ", "%20", TRUE},
739: {"http://x.org/ ", "http://x.org/%20%20%20%20%20%20", " ", "%20", TRUE},
740: {"http://x.org/%20/encoded", "http://x.org/%20/encoded", " ", "%20", FALSE},
741: };
742:
743: START_TEST(test_strreplace)
744: {
745: char *ret;
746:
747: ret = strreplace(strreplace_data[_i].in, strreplace_data[_i].search,
748: strreplace_data[_i].replace);
749: if (ret && strreplace_data[_i].out)
750: {
751: ck_assert_str_eq(ret, strreplace_data[_i].out);
752: }
753: else
754: {
755: ck_assert(ret == strreplace_data[_i].out);
756: }
757: if (strreplace_data[_i].allocated)
758: {
759: ck_assert(ret != strreplace_data[_i].in);
760: free(ret);
761: }
762: else
763: {
764: ck_assert(ret == strreplace_data[_i].in);
765: }
766: }
767: END_TEST
768:
769: /*******************************************************************************
770: * path_dirname/basename/absolute
771: */
772:
773: static struct {
774: char *path;
775: char *dir;
776: char *base;
777: bool absolute;
778: } path_data[] = {
779: {NULL, ".", ".", FALSE},
780: {"", ".", ".", FALSE},
781: {".", ".", ".", FALSE},
782: {"..", ".", "..", FALSE},
783: #ifdef WIN32
784: {"C:\\", "C:", "C:", TRUE},
785: {"X:\\\\", "X:", "X:", TRUE},
786: {"foo", ".", "foo", FALSE},
787: {"f\\", ".", "f", FALSE},
788: {"foo\\", ".", "foo", FALSE},
789: {"foo\\\\", ".", "foo", FALSE},
790: {"d:\\f", "d:", "f", TRUE},
791: {"C:\\f\\", "C:", "f", TRUE},
792: {"C:\\foo", "C:", "foo", TRUE},
793: {"C:\\foo\\", "C:", "foo", TRUE},
794: {"foo\\bar", "foo", "bar", FALSE},
795: {"foo\\\\bar", "foo", "bar", FALSE},
796: {"C:\\foo\\bar", "C:\\foo", "bar", TRUE},
797: {"C:\\foo\\bar\\", "C:\\foo", "bar", TRUE},
798: {"C:\\foo\\bar\\baz", "C:\\foo\\bar", "baz", TRUE},
799: {"\\foo\\bar", "\\foo", "bar", FALSE},
800: {"\\\\foo\\bar", "\\\\foo", "bar", TRUE},
801: #else /* !WIN32 */
802: {"/", "/", "/", TRUE},
803: {"//", "/", "/", TRUE},
804: {"foo", ".", "foo", FALSE},
805: {"f/", ".", "f", FALSE},
806: {"foo/", ".", "foo", FALSE},
807: {"foo//", ".", "foo", FALSE},
808: {"/f", "/", "f", TRUE},
809: {"/f/", "/", "f", TRUE},
810: {"/foo", "/", "foo", TRUE},
811: {"/foo/", "/", "foo", TRUE},
812: {"//foo/", "/", "foo", TRUE},
813: {"foo/bar", "foo", "bar", FALSE},
814: {"foo//bar", "foo", "bar", FALSE},
815: {"/foo/bar", "/foo", "bar", TRUE},
816: {"/foo/bar/", "/foo", "bar", TRUE},
817: {"/foo/bar/baz", "/foo/bar", "baz", TRUE},
818: #endif
819: };
820:
821: START_TEST(test_path_dirname)
822: {
823: char *dir;
824:
825: dir = path_dirname(path_data[_i].path);
826: ck_assert_str_eq(path_data[_i].dir, dir);
827: free(dir);
828: }
829: END_TEST
830:
831: START_TEST(test_path_basename)
832: {
833: char *base;
834:
835: base = path_basename(path_data[_i].path);
836: ck_assert_str_eq(path_data[_i].base, base);
837: free(base);
838: }
839: END_TEST
840:
841: START_TEST(test_path_absolute)
842: {
843: ck_assert(path_data[_i].absolute == path_absolute(path_data[_i].path));
844: }
845: END_TEST
846:
847: /*******************************************************************************
848: * time_printf_hook
849: */
850:
851: static struct {
852: time_t in;
853: bool utc;
854: char *out;
855: } time_data[] = {
856: {UNDEFINED_TIME, FALSE, "--- -- --:--:-- ----"},
857: {UNDEFINED_TIME, TRUE , "--- -- --:--:-- UTC ----"},
858: {1, FALSE, "Jan 01 01:00:01 1970"},
859: {1, TRUE , "Jan 01 00:00:01 UTC 1970"},
860: {1341150196, FALSE, "Jul 01 15:43:16 2012"},
861: {1341150196, TRUE , "Jul 01 13:43:16 UTC 2012"},
862: };
863:
864: START_TEST(test_time_printf_hook)
865: {
866: char buf[32];
867: int len;
868:
869: len = snprintf(buf, sizeof(buf), "%T", &time_data[_i].in, time_data[_i].utc);
870: ck_assert(len >= 0 && len < sizeof(buf));
871: ck_assert_str_eq(buf, time_data[_i].out);
872: }
873: END_TEST
874:
875: /*******************************************************************************
876: * time_delta_printf_hook
877: */
878:
879: static struct {
880: time_t a;
881: time_t b;
882: char *out;
883: } time_delta_data[] = {
884: {0, 0, "0 seconds"},
885: {0, 1, "1 second"},
886: {0, -1, "1 second"},
887: {1, 0, "1 second"},
888: {0, 2, "2 seconds"},
889: {2, 0, "2 seconds"},
890: {0, 60, "60 seconds"},
891: {0, 120, "120 seconds"},
892: {0, 121, "2 minutes"},
893: {0, 3600, "60 minutes"},
894: {0, 7200, "120 minutes"},
895: {0, 7201, "2 hours"},
896: {0, 86400, "24 hours"},
897: {0, 172800, "48 hours"},
898: {0, 172801, "2 days"},
899: {172801, 86400, "24 hours"},
900: };
901:
902: START_TEST(test_time_delta_printf_hook)
903: {
904: char buf[16];
905: int len;
906:
907: len = snprintf(buf, sizeof(buf), "%V", &time_delta_data[_i].a, &time_delta_data[_i].b);
908: ck_assert(len >= 0 && len < sizeof(buf));
909: ck_assert_str_eq(buf, time_delta_data[_i].out);
910: }
911: END_TEST
912:
913: /*******************************************************************************
914: * mark_from_string
915: */
916:
917: static struct {
918: char *s;
919: bool ok;
920: mark_op_t ops;
921: mark_t m;
922: } mark_data[] = {
923: {NULL, FALSE, MARK_OP_NONE, { 0 }},
924: {"", TRUE, MARK_OP_NONE, { 0, 0xffffffff }},
925: {"/", TRUE, MARK_OP_NONE, { 0, 0 }},
926: {"42", TRUE, MARK_OP_NONE, { 42, 0xffffffff }},
927: {"0x42", TRUE, MARK_OP_NONE, { 0x42, 0xffffffff }},
928: {"x", FALSE, MARK_OP_NONE, { 0 }},
929: {"42/", TRUE, MARK_OP_NONE, { 0, 0 }},
930: {"42/0", TRUE, MARK_OP_NONE, { 0, 0 }},
931: {"42/x", FALSE, MARK_OP_NONE, { 0 }},
932: {"42/42", TRUE, MARK_OP_NONE, { 42, 42 }},
933: {"42/0xff", TRUE, MARK_OP_NONE, { 42, 0xff }},
934: {"0x42/0xff", TRUE, MARK_OP_NONE, { 0x42, 0xff }},
935: {"/0xff", TRUE, MARK_OP_NONE, { 0, 0xff }},
936: {"/x", FALSE, MARK_OP_NONE, { 0 }},
937: {"x/x", FALSE, MARK_OP_NONE, { 0 }},
938: {"0xfffffff0/0x0000ffff", TRUE, MARK_OP_UNIQUE,
939: { 0x0000fff0, 0x0000ffff }},
940: {"%unique", TRUE, MARK_OP_UNIQUE,
941: { MARK_UNIQUE, 0xffffffff }},
942: {"%unique/", TRUE, MARK_OP_UNIQUE,
943: { MARK_UNIQUE, 0 }},
944: {"%unique", FALSE, MARK_OP_NONE,
945: { 0, 0 }},
946: {"%unique/0x0000ffff", TRUE, MARK_OP_UNIQUE,
947: { MARK_UNIQUE, 0x0000ffff }},
948: {"%unique/0xffffffff", TRUE, MARK_OP_UNIQUE,
949: { MARK_UNIQUE, 0xffffffff }},
950: {"%unique0xffffffffff", FALSE, MARK_OP_UNIQUE,
951: { 0, 0 }},
952: {"0xffffffff/0x0000ffff", TRUE, MARK_OP_UNIQUE,
953: { MARK_UNIQUE, 0x0000ffff }},
954: {"0xffffffff/0xffffffff", TRUE, MARK_OP_UNIQUE,
955: { MARK_UNIQUE, 0xffffffff }},
956: {"%unique-dir", TRUE, MARK_OP_UNIQUE,
957: { MARK_UNIQUE_DIR, 0xffffffff }},
958: {"%unique-dir/", TRUE, MARK_OP_UNIQUE,
959: { MARK_UNIQUE_DIR, 0 }},
960: {"%unique-dir", FALSE, MARK_OP_NONE,
961: { 0, 0 }},
962: {"%unique-dir/0x0000ffff", TRUE, MARK_OP_UNIQUE,
963: { MARK_UNIQUE_DIR, 0x0000ffff }},
964: {"%unique-dir/0xffffffff", TRUE, MARK_OP_UNIQUE,
965: { MARK_UNIQUE_DIR, 0xffffffff }},
966: {"%unique-dir0xffffffff", FALSE, MARK_OP_UNIQUE,
967: { 0, 0 }},
968: {"0xfffffffe/0x0000ffff", TRUE, MARK_OP_UNIQUE,
969: { MARK_UNIQUE_DIR, 0x0000ffff }},
970: {"0xfffffffe/0xffffffff", TRUE, MARK_OP_UNIQUE,
971: { MARK_UNIQUE_DIR, 0xffffffff }},
972: {"%unique-/0xffffffff", FALSE, MARK_OP_UNIQUE,
973: { 0, 0 }},
974: {"%unique-foo/0xffffffff", FALSE, MARK_OP_UNIQUE,
975: { 0, 0 }},
976: {"%same", TRUE, MARK_OP_SAME,
977: { MARK_SAME, 0xffffffff }},
978: {"%same/0x0000ffff", TRUE, MARK_OP_SAME,
979: { MARK_SAME, 0x0000ffff }},
980: {"%%same", FALSE, MARK_OP_NONE,
981: { 0, 0 }},
982: };
983:
984: START_TEST(test_mark_from_string)
985: {
986: mark_t mark;
987:
988: if (mark_from_string(mark_data[_i].s, mark_data[_i].ops, &mark))
989: {
990: ck_assert_int_eq(mark.value, mark_data[_i].m.value);
991: ck_assert_int_eq(mark.mask, mark_data[_i].m.mask);
992: }
993: else
994: {
995: ck_assert(!mark_data[_i].ok);
996: }
997: }
998: END_TEST
999:
1000: /*******************************************************************************
1001: * if_id_from_string
1002: */
1003:
1004: static struct {
1005: char *s;
1006: bool ok;
1007: uint32_t i;
1008: } if_id_data[] = {
1009: {NULL, FALSE, 0 },
1010: {"", TRUE, 0 },
1011: {"/", FALSE, 0 },
1012: {"42", TRUE, 42 },
1013: {"0x42", TRUE, 0x42 },
1014: {"x", FALSE, 0 },
1015: {"42/", FALSE, 0 },
1016: {"42/0", FALSE, 0 },
1017: {"%unique", TRUE, IF_ID_UNIQUE },
1018: {"%unique/", FALSE, 0},
1019: {"%unique0xffffffffff", FALSE, 0},
1020: {"0xffffffff", TRUE, IF_ID_UNIQUE},
1021: {"%unique-dir", TRUE, IF_ID_UNIQUE_DIR},
1022: {"%unique-dir/",FALSE, 0},
1023: {"0xfffffffe", TRUE, IF_ID_UNIQUE_DIR},
1024: {"%unique-", FALSE, 0},
1025: {"%unique-foo", FALSE, 0},
1026: };
1027:
1028: START_TEST(test_if_id_from_string)
1029: {
1030: uint32_t if_id;
1031:
1032: if (if_id_from_string(if_id_data[_i].s, &if_id))
1033: {
1034: ck_assert_int_eq(if_id, if_id_data[_i].i);
1035: }
1036: else
1037: {
1038: ck_assert(!if_id_data[_i].ok);
1039: }
1040: }
1041: END_TEST
1042:
1043: /*******************************************************************************
1044: * allocate_unique_if_ids
1045: */
1046:
1047: static struct {
1048: uint32_t in;
1049: uint32_t out;
1050: uint32_t exp_in;
1051: uint32_t exp_out;
1052: } unique_if_id_data[] = {
1053: {0, 0, 0, 0 },
1054: {42, 42, 42, 42 },
1055: {42, 1337, 42, 1337 },
1056: /* each call increases the internal counter by 1 or 2*/
1057: {IF_ID_UNIQUE, 42, 1, 42 },
1058: {42, IF_ID_UNIQUE, 42, 2 },
1059: {IF_ID_UNIQUE_DIR, 42, 3, 42 },
1060: {42, IF_ID_UNIQUE_DIR, 42, 4 },
1061: {IF_ID_UNIQUE, IF_ID_UNIQUE, 5, 5 },
1062: {IF_ID_UNIQUE_DIR, IF_ID_UNIQUE, 6, 7 },
1063: {IF_ID_UNIQUE, IF_ID_UNIQUE_DIR, 8, 9 },
1064: {IF_ID_UNIQUE_DIR, IF_ID_UNIQUE_DIR, 10, 11 },
1065: };
1066:
1067: START_TEST(test_allocate_unique_if_ids)
1068: {
1069: uint32_t if_id_in = unique_if_id_data[_i].in,
1070: if_id_out = unique_if_id_data[_i].out;
1071:
1072: allocate_unique_if_ids(&if_id_in, &if_id_out);
1073: ck_assert_int_eq(if_id_in, unique_if_id_data[_i].exp_in);
1074: ck_assert_int_eq(if_id_out, unique_if_id_data[_i].exp_out);
1075: }
1076: END_TEST
1077:
1078: /*******************************************************************************
1079: * signature_schemes_for_key
1080: */
1081:
1082: static struct {
1083: key_type_t type;
1084: int size;
1085: signature_scheme_t expected[7];
1086: } scheme_data[] = {
1087: {KEY_RSA, 1024, { SIGN_RSA_EMSA_PSS, SIGN_RSA_EMSA_PSS,
1088: SIGN_RSA_EMSA_PSS, SIGN_RSA_EMSA_PKCS1_SHA2_256,
1089: SIGN_RSA_EMSA_PKCS1_SHA2_384, SIGN_RSA_EMSA_PKCS1_SHA2_512,
1090: SIGN_UNKNOWN }},
1091: {KEY_RSA, 2048, { SIGN_RSA_EMSA_PSS, SIGN_RSA_EMSA_PSS,
1092: SIGN_RSA_EMSA_PSS, SIGN_RSA_EMSA_PKCS1_SHA2_256,
1093: SIGN_RSA_EMSA_PKCS1_SHA2_384, SIGN_RSA_EMSA_PKCS1_SHA2_512,
1094: SIGN_UNKNOWN }},
1095: {KEY_RSA, 4096, { SIGN_RSA_EMSA_PSS, SIGN_RSA_EMSA_PSS,
1096: SIGN_RSA_EMSA_PKCS1_SHA2_384, SIGN_RSA_EMSA_PKCS1_SHA2_512,
1097: SIGN_UNKNOWN }},
1098: {KEY_RSA, 8192, { SIGN_RSA_EMSA_PSS, SIGN_RSA_EMSA_PKCS1_SHA2_512, SIGN_UNKNOWN }},
1099: {KEY_ECDSA, 256, { SIGN_ECDSA_WITH_SHA256_DER, SIGN_ECDSA_WITH_SHA384_DER,
1100: SIGN_ECDSA_WITH_SHA512_DER, SIGN_UNKNOWN }},
1101: {KEY_ECDSA, 384, { SIGN_ECDSA_WITH_SHA384_DER, SIGN_ECDSA_WITH_SHA512_DER,
1102: SIGN_UNKNOWN }},
1103: {KEY_ECDSA, 512, { SIGN_ECDSA_WITH_SHA512_DER, SIGN_UNKNOWN }},
1104: {KEY_BLISS, 128, { SIGN_BLISS_WITH_SHA2_256, SIGN_BLISS_WITH_SHA2_384,
1105: SIGN_BLISS_WITH_SHA2_512, SIGN_UNKNOWN }},
1106: {KEY_BLISS, 192, { SIGN_BLISS_WITH_SHA2_384, SIGN_BLISS_WITH_SHA2_512,
1107: SIGN_UNKNOWN }},
1108: {KEY_BLISS, 256, { SIGN_BLISS_WITH_SHA2_512, SIGN_UNKNOWN }},
1109: };
1110:
1111: START_TEST(test_signature_schemes_for_key)
1112: {
1113: enumerator_t *enumerator;
1114: signature_params_t *params;
1115: int i;
1116:
1117: enumerator = signature_schemes_for_key(scheme_data[_i].type, scheme_data[_i].size);
1118: for (i = 0; scheme_data[_i].expected[i] != SIGN_UNKNOWN; i++)
1119: {
1120: ck_assert(enumerator->enumerate(enumerator, ¶ms));
1121: ck_assert_int_eq(scheme_data[_i].expected[i], params->scheme);
1122: }
1123: ck_assert(!enumerator->enumerate(enumerator, ¶ms));
1124: enumerator->destroy(enumerator);
1125: }
1126: END_TEST
1127:
1128: Suite *utils_suite_create()
1129: {
1130: Suite *s;
1131: TCase *tc;
1132:
1133: /* force a timezone to match non-UTC conversions */
1134: #ifdef WIN32
1135: _putenv("TZ=GST-1GDT");
1136: #else
1137: setenv("TZ", "Europe/Zurich", 1);
1138: #endif
1139: tzset();
1140:
1141: s = suite_create("utils");
1142:
1143: tc = tcase_create("objects");
1144: tcase_add_test(tc, test_objects);
1145: suite_add_tcase(s, tc);
1146:
1147: tc = tcase_create("return functions");
1148: tcase_add_test(tc, test_return_functions);
1149: suite_add_tcase(s, tc);
1150:
1151: tc = tcase_create("timeval_add_ms");
1152: tcase_add_test(tc, test_timeval_add_ms);
1153: suite_add_tcase(s, tc);
1154:
1155: tc = tcase_create("timespan_from_string");
1156: tcase_add_loop_test(tc, test_timespan_from_string, 0, countof(ts_data));
1157: suite_add_tcase(s, tc);
1158:
1159: tc = tcase_create("htoun,untoh");
1160: tcase_add_test(tc, test_htoun);
1161: tcase_add_test(tc, test_untoh);
1162: suite_add_tcase(s, tc);
1163:
1164: tc = tcase_create("round");
1165: tcase_add_test(tc, test_round);
1166: suite_add_tcase(s, tc);
1167:
1168: tc = tcase_create("string helper");
1169: tcase_add_loop_test(tc, test_streq, 0, countof(streq_data));
1170: tcase_add_loop_test(tc, test_strneq, 0, countof(strneq_data));
1171: tcase_add_loop_test(tc, test_strpfx, 0, countof(strpfx_data));
1172: suite_add_tcase(s, tc);
1173:
1174: tc = tcase_create("malloc_align");
1175: tcase_add_test(tc, test_malloc_align);
1176: suite_add_tcase(s, tc);
1177:
1178: tc = tcase_create("memxor");
1179: tcase_add_test(tc, test_memxor);
1180: tcase_add_test(tc, test_memxor_aligned);
1181: suite_add_tcase(s, tc);
1182:
1183: tc = tcase_create("memeq");
1184: tcase_add_loop_test(tc, test_memeq, 0, countof(memeq_data));
1185: tcase_add_loop_test(tc, test_memeq_const, 0, countof(memeq_data));
1186: suite_add_tcase(s, tc);
1187:
1188: tc = tcase_create("memstr");
1189: tcase_add_loop_test(tc, test_memstr, 0, countof(memstr_data));
1190: suite_add_tcase(s, tc);
1191:
1192: tc = tcase_create("memwipe");
1193: tcase_add_test(tc, test_memwipe_null);
1194: tcase_add_test(tc, test_memwipe_stack);
1195: tcase_add_test(tc, test_memwipe_heap);
1196: suite_add_tcase(s, tc);
1197:
1198: tc = tcase_create("utils_memrchr");
1199: tcase_add_loop_test(tc, test_utils_memrchr, 0, countof(memrchr_data));
1200: suite_add_tcase(s, tc);
1201:
1202: tc = tcase_create("translate");
1203: tcase_add_loop_test(tc, test_translate, 0, countof(translate_data));
1204: suite_add_tcase(s, tc);
1205:
1206: tc = tcase_create("strreplace");
1207: tcase_add_loop_test(tc, test_strreplace, 0, countof(strreplace_data));
1208: suite_add_tcase(s, tc);
1209:
1210: tc = tcase_create("path_dirname");
1211: tcase_add_loop_test(tc, test_path_dirname, 0, countof(path_data));
1212: suite_add_tcase(s, tc);
1213:
1214: tc = tcase_create("path_basename");
1215: tcase_add_loop_test(tc, test_path_basename, 0, countof(path_data));
1216: suite_add_tcase(s, tc);
1217:
1218: tc = tcase_create("path_absolute");
1219: tcase_add_loop_test(tc, test_path_absolute, 0, countof(path_data));
1220: suite_add_tcase(s, tc);
1221:
1222: tc = tcase_create("printf_hooks");
1223: tcase_add_loop_test(tc, test_time_printf_hook, 0, countof(time_data));
1224: tcase_add_loop_test(tc, test_time_delta_printf_hook, 0, countof(time_delta_data));
1225: suite_add_tcase(s, tc);
1226:
1227: tc = tcase_create("mark_from_string");
1228: tcase_add_loop_test(tc, test_mark_from_string, 0, countof(mark_data));
1229: suite_add_tcase(s, tc);
1230:
1231: tc = tcase_create("if_id_from_string");
1232: tcase_add_loop_test(tc, test_if_id_from_string, 0, countof(if_id_data));
1233: suite_add_tcase(s, tc);
1234:
1235: tc = tcase_create("allocate_unique_if_ids");
1236: tcase_add_loop_test(tc, test_allocate_unique_if_ids, 0, countof(unique_if_id_data));
1237: suite_add_tcase(s, tc);
1238:
1239: tc = tcase_create("signature_schemes_for_key");
1240: tcase_add_loop_test(tc, test_signature_schemes_for_key, 0, countof(scheme_data));
1241: suite_add_tcase(s, tc);
1242:
1243: return s;
1244: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_utils.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / tests / suites