Annotation of embedaddon/strongswan/src/libstrongswan/tests/suites/test_enum.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2013 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 <utils/utils.h>
! 19:
! 20: /*******************************************************************************
! 21: * continuous enum
! 22: */
! 23: enum {
! 24: CONT1,
! 25: CONT2,
! 26: CONT3,
! 27: CONT4,
! 28: CONT5,
! 29: } test_enum_cont;
! 30:
! 31: ENUM_BEGIN(test_enum_cont_names, CONT1, CONT5,
! 32: "CONT1", "CONT2", "CONT3", "CONT4", "CONT5");
! 33: ENUM_END(test_enum_cont_names, CONT5);
! 34:
! 35: /*******************************************************************************
! 36: * split enum
! 37: */
! 38: enum {
! 39: SPLIT1 = 1,
! 40: SPLIT2,
! 41: SPLIT3 = 5,
! 42: SPLIT4,
! 43: SPLIT5 = 255,
! 44: } test_enum_split;
! 45:
! 46: ENUM_BEGIN(test_enum_split_names, SPLIT1, SPLIT2,
! 47: "SPLIT1", "SPLIT2");
! 48: ENUM_NEXT(test_enum_split_names, SPLIT3, SPLIT4, SPLIT2,
! 49: "SPLIT3", "SPLIT4");
! 50: ENUM_NEXT(test_enum_split_names, SPLIT5, SPLIT5, SPLIT4,
! 51: "SPLIT5");
! 52: ENUM_END(test_enum_split_names, SPLIT5);
! 53:
! 54: /*******************************************************************************
! 55: * enum flags
! 56: */
! 57: enum {
! 58: FLAG1 = (1 << 0),
! 59: FLAG2 = (1 << 1),
! 60: FLAG3 = (1 << 2),
! 61: FLAG4 = (1 << 3),
! 62: FLAG5 = (1 << 4),
! 63: FLAG6 = (1 << 5),
! 64: FLAG7 = (1 << 6),
! 65: FLAG8 = (1 << 7),
! 66: FLAG9 = (1 << 8),
! 67: FLAG10 = (1 << 9),
! 68: FLAG11 = (1 << 10),
! 69: FLAG12 = (1 << 11),
! 70: } test_enum_flags;
! 71:
! 72: ENUM_FLAGS(test_enum_flags_names, FLAG1, FLAG5,
! 73: "FLAG1", "FLAG2", "FLAG3", "FLAG4", "FLAG5");
! 74:
! 75: ENUM_FLAGS(test_enum_flags_incomplete_names, FLAG3, FLAG4,
! 76: "FLAG3", "FLAG4");
! 77:
! 78: ENUM_FLAGS(test_enum_flags_null_names, FLAG1, FLAG4,
! 79: "FLAG1", NULL, "FLAG3", NULL);
! 80:
! 81: ENUM_FLAGS(test_enum_flags_overflow_names, FLAG1, FLAG12,
! 82: "OVERFLOWFLAGLONGNAME1", "OVERFLOWFLAGLONGNAME2", "OVERFLOWFLAGLONGNAME3",
! 83: "OVERFLOWFLAGLONGNAME4", "OVERFLOWFLAGLONGNAME5", "OVERFLOWFLAGLONGNAME6",
! 84: "OVERFLOWFLAGLONGNAME7", "OVERFLOWFLAGLONGNAME8", "OVERFLOWFLAGLONGNAME9",
! 85: "OVERFLOWFLAGLONGNAME10", "OVERFLOWFLAGLONGNAME11", "OVERFLOWFLAGLONGNAME12");
! 86:
! 87: /*******************************************************************************
! 88: * enum_to_name
! 89: */
! 90:
! 91: static struct {
! 92: int val;
! 93: char *str;
! 94: } name_tests_cont[] = {
! 95: {-1, NULL},
! 96: {CONT1, "CONT1"},
! 97: {CONT2, "CONT2"},
! 98: {CONT3, "CONT3"},
! 99: {CONT4, "CONT4"},
! 100: {CONT5, "CONT5"},
! 101: {5, NULL},
! 102: }, name_tests_split[] = {
! 103: {-1, NULL},
! 104: {0, NULL},
! 105: {SPLIT1, "SPLIT1"},
! 106: {SPLIT2, "SPLIT2"},
! 107: {3, NULL},
! 108: {4, NULL},
! 109: {SPLIT3, "SPLIT3"},
! 110: {SPLIT4, "SPLIT4"},
! 111: {7, NULL},
! 112: {254, NULL},
! 113: {SPLIT5, "SPLIT5"},
! 114: {256, NULL},
! 115: };
! 116:
! 117: START_TEST(test_enum_to_name_cont)
! 118: {
! 119: char *str = enum_to_name(test_enum_cont_names, name_tests_cont[_i].val);
! 120: if (str)
! 121: {
! 122: ck_assert_str_eq(str, name_tests_cont[_i].str);
! 123: }
! 124: else
! 125: {
! 126: ck_assert(str == name_tests_cont[_i].str);
! 127: }
! 128: }
! 129: END_TEST
! 130:
! 131: START_TEST(test_enum_to_name_split)
! 132: {
! 133: char *str = enum_to_name(test_enum_split_names, name_tests_split[_i].val);
! 134: if (str)
! 135: {
! 136: ck_assert_str_eq(str, name_tests_split[_i].str);
! 137: }
! 138: else
! 139: {
! 140: ck_assert(str == name_tests_split[_i].str);
! 141: }
! 142: }
! 143: END_TEST
! 144:
! 145: /*******************************************************************************
! 146: * enum_from_name
! 147: */
! 148:
! 149: static struct {
! 150: bool found;
! 151: int val;
! 152: char *str;
! 153: } enum_tests_cont[] = {
! 154: {TRUE, CONT1, "CONT1"},
! 155: {TRUE, CONT2, "CONT2"},
! 156: {TRUE, CONT2, "CoNt2"},
! 157: {TRUE, CONT3, "CONT3"},
! 158: {TRUE, CONT4, "CONT4"},
! 159: {TRUE, CONT5, "CONT5"},
! 160: {FALSE, 0, "asdf"},
! 161: {FALSE, 0, ""},
! 162: {FALSE, 0, NULL},
! 163: }, enum_tests_split[] = {
! 164: {TRUE, SPLIT1, "SPLIT1"},
! 165: {TRUE, SPLIT1, "split1"},
! 166: {TRUE, SPLIT2, "SPLIT2"},
! 167: {TRUE, SPLIT2, "SpLiT2"},
! 168: {TRUE, SPLIT3, "SPLIT3"},
! 169: {TRUE, SPLIT4, "SPLIT4"},
! 170: {TRUE, SPLIT5, "SPLIT5"},
! 171: {FALSE, 0, "asdf"},
! 172: {FALSE, 0, ""},
! 173: {FALSE, 0, NULL},
! 174: };
! 175:
! 176: START_TEST(test_enum_from_name_cont)
! 177: {
! 178: int val = 0;
! 179: bool found;
! 180:
! 181: found = enum_from_name(test_enum_cont_names, enum_tests_cont[_i].str, &val);
! 182: ck_assert(enum_tests_cont[_i].found == found);
! 183: ck_assert_int_eq(val, enum_tests_cont[_i].val);
! 184: }
! 185: END_TEST
! 186:
! 187: START_TEST(test_enum_from_name_split)
! 188: {
! 189: int val = 0;
! 190: bool found;
! 191:
! 192: found = enum_from_name(test_enum_split_names, enum_tests_split[_i].str, &val);
! 193: ck_assert(enum_tests_split[_i].found == found);
! 194: ck_assert_int_eq(val, enum_tests_split[_i].val);
! 195: }
! 196: END_TEST
! 197:
! 198: /*******************************************************************************
! 199: * enum_printf_hook
! 200: */
! 201:
! 202: static struct {
! 203: int val;
! 204: char *str;
! 205: } printf_tests_cont[] = {
! 206: {-1, "(-1)"},
! 207: {CONT1, "CONT1"},
! 208: {CONT2, "CONT2"},
! 209: {CONT3, "CONT3"},
! 210: {CONT4, "CONT4"},
! 211: {CONT5, "CONT5"},
! 212: {5, "(5)"},
! 213: }, printf_tests_split[] = {
! 214: {-1, "(-1)"},
! 215: {0, "(0)"},
! 216: {SPLIT1, "SPLIT1"},
! 217: {SPLIT2, "SPLIT2"},
! 218: {3, "(3)"},
! 219: {4, "(4)"},
! 220: {SPLIT3, "SPLIT3"},
! 221: {SPLIT4, "SPLIT4"},
! 222: {7, "(7)"},
! 223: {254, "(254)"},
! 224: {SPLIT5, "SPLIT5"},
! 225: {256, "(256)"},
! 226: };
! 227:
! 228: /*******************************************************************************
! 229: * flag_to_name
! 230: */
! 231:
! 232: static struct {
! 233: int val;
! 234: char *str;
! 235: } printf_tests_flags[] = {
! 236: {0, "(unset)"},
! 237: {FLAG1, "FLAG1"},
! 238: {FLAG2, "FLAG2"},
! 239: {FLAG3, "FLAG3"},
! 240: {FLAG4, "FLAG4"},
! 241: {FLAG5, "FLAG5"},
! 242: {FLAG1 | FLAG3, "FLAG1 | FLAG3"},
! 243: {FLAG1 | FLAG3 | 32, "FLAG1 | FLAG3 | (0x20)"},
! 244: {FLAG1 | FLAG3 | 32 | 64, "FLAG1 | FLAG3 | (0x20) | (0x40)"},
! 245: {0x20, "(0x20)"},
! 246: {0x80000000, "(0x80000000)"},
! 247: {0xFFFFF, "FLAG1 | FLAG2 | FLAG3 | FLAG4 | "
! 248: "FLAG5 | (0x20) | (0x40) | (0x80) | "
! 249: "(0x100) | (0x200) | (0x400) | (0x800) | "
! 250: "(0x1000) | (0x2000) | (0x4000) | (0x8000) | "
! 251: "(0x10000) | (0x20000) | (0x40000) | (0x80000)"},
! 252: }, printf_tests_flags_incomplete[] = {
! 253: {FLAG1, "(0x1)"},
! 254: {FLAG1 | FLAG2 | FLAG3, "(0x1) | (0x2) | FLAG3"},
! 255: {FLAG3 | FLAG4 | FLAG5, "FLAG3 | FLAG4 | (0x10)"},
! 256: }, printf_tests_flags_null[] = {
! 257: {FLAG1 | FLAG2 | FLAG3 | FLAG4, "FLAG1 | FLAG3"},
! 258: }, printf_tests_flags_overflow[] = {
! 259: {0xFFFFFFFF, "(0xFFFFFFFF)"},
! 260: }, printf_tests_flags_noflagenum[] = {
! 261: {-1, "(-1)"},
! 262: {6435, "(6435)"},
! 263: }, enum_flags_to_string_tests[] = {
! 264: {-1, NULL},
! 265: {6435, NULL},
! 266: };
! 267:
! 268: START_TEST(test_enum_printf_hook_cont)
! 269: {
! 270: char buf[128];
! 271:
! 272: snprintf(buf, sizeof(buf), "%N",
! 273: test_enum_cont_names, printf_tests_cont[_i].val);
! 274: ck_assert_str_eq(printf_tests_cont[_i].str, buf);
! 275: }
! 276: END_TEST
! 277:
! 278: START_TEST(test_enum_printf_hook_split)
! 279: {
! 280: char buf[128];
! 281:
! 282: snprintf(buf, sizeof(buf), "%N",
! 283: test_enum_split_names, printf_tests_split[_i].val);
! 284: ck_assert_str_eq(printf_tests_split[_i].str, buf);
! 285: }
! 286: END_TEST
! 287:
! 288: START_TEST(test_enum_printf_hook_null)
! 289: {
! 290: char buf[16];
! 291:
! 292: snprintf(buf, sizeof(buf), "%N", NULL, 7);
! 293: ck_assert_str_eq("(7)", buf);
! 294: }
! 295: END_TEST
! 296:
! 297: START_TEST(test_enum_printf_hook_flags)
! 298: {
! 299: char buf[1024];
! 300:
! 301: snprintf(buf, sizeof(buf), "%N", test_enum_flags_names,
! 302: printf_tests_flags[_i].val);
! 303: ck_assert_str_eq(printf_tests_flags[_i].str, buf);
! 304: }
! 305: END_TEST
! 306:
! 307: START_TEST(test_enum_printf_hook_flags_incomplete)
! 308: {
! 309: char buf[1024];
! 310:
! 311: snprintf(buf, sizeof(buf), "%N", test_enum_flags_incomplete_names,
! 312: printf_tests_flags_incomplete[_i].val);
! 313: ck_assert_str_eq(printf_tests_flags_incomplete[_i].str, buf);
! 314: }
! 315: END_TEST
! 316:
! 317: START_TEST(test_enum_printf_hook_flags_null)
! 318: {
! 319: char buf[1024];
! 320:
! 321: snprintf(buf, sizeof(buf), "%N", test_enum_flags_null_names,
! 322: printf_tests_flags_null[_i].val);
! 323: ck_assert_str_eq(printf_tests_flags_null[_i].str, buf);
! 324: }
! 325: END_TEST
! 326:
! 327: START_TEST(test_enum_printf_hook_flags_overflow)
! 328: {
! 329: char buf[1024];
! 330:
! 331: snprintf(buf, sizeof(buf), "%N", test_enum_flags_overflow_names,
! 332: printf_tests_flags_overflow[_i].val);
! 333: ck_assert_str_eq(printf_tests_flags_overflow[_i].str, buf);
! 334: }
! 335: END_TEST
! 336:
! 337: START_TEST(test_enum_printf_hook_flags_noflagenum)
! 338: {
! 339: char buf[1024];
! 340:
! 341: snprintf(buf, sizeof(buf), "%N", test_enum_cont_names,
! 342: printf_tests_flags_noflagenum[_i].val);
! 343: ck_assert_str_eq(printf_tests_flags_noflagenum[_i].str, buf);
! 344: }
! 345: END_TEST
! 346:
! 347: START_TEST(test_enum_flags_to_string)
! 348: {
! 349: char buf[1], *str;
! 350:
! 351: str = enum_flags_to_string(test_enum_flags_names,
! 352: enum_flags_to_string_tests[_i].val, buf, sizeof(buf));
! 353: if (str)
! 354: {
! 355: ck_assert_str_eq(enum_flags_to_string_tests[_i].str, str);
! 356: }
! 357: else
! 358: {
! 359: ck_assert(str == enum_flags_to_string_tests[_i].str);
! 360: }
! 361: }
! 362: END_TEST
! 363:
! 364: START_TEST(test_enum_flags_to_string_noflagenum)
! 365: {
! 366: char buf[1024];
! 367:
! 368: enum_flags_to_string(test_enum_cont_names,
! 369: printf_tests_flags_noflagenum[_i].val, buf, sizeof(buf));
! 370: ck_assert_str_eq(printf_tests_flags_noflagenum[_i].str, buf);
! 371: }
! 372: END_TEST
! 373:
! 374: START_TEST(test_enum_printf_hook_width)
! 375: {
! 376: char buf[128];
! 377:
! 378: snprintf(buf, sizeof(buf), "%10N", test_enum_cont_names, CONT1);
! 379: ck_assert_str_eq(" CONT1", buf);
! 380: snprintf(buf, sizeof(buf), "%-*N", 10, test_enum_cont_names, CONT2);
! 381: ck_assert_str_eq("CONT2 ", buf);
! 382: snprintf(buf, sizeof(buf), "%3N", test_enum_cont_names, CONT3);
! 383: ck_assert_str_eq("CONT3", buf);
! 384: }
! 385: END_TEST
! 386:
! 387: Suite *enum_suite_create()
! 388: {
! 389: Suite *s;
! 390: TCase *tc;
! 391:
! 392: s = suite_create("enum");
! 393:
! 394: tc = tcase_create("enum_to_name");
! 395: tcase_add_loop_test(tc, test_enum_to_name_cont, 0, countof(name_tests_cont));
! 396: tcase_add_loop_test(tc, test_enum_to_name_split, 0, countof(name_tests_split));
! 397: suite_add_tcase(s, tc);
! 398:
! 399: tc = tcase_create("enum_from_name");
! 400: tcase_add_loop_test(tc, test_enum_from_name_cont, 0, countof(enum_tests_cont));
! 401: tcase_add_loop_test(tc, test_enum_from_name_split, 0, countof(enum_tests_split));
! 402: suite_add_tcase(s, tc);
! 403:
! 404: tc = tcase_create("enum_flags_to_string");
! 405: tcase_add_loop_test(tc, test_enum_flags_to_string, 0, countof(enum_flags_to_string_tests));
! 406: tcase_add_loop_test(tc, test_enum_flags_to_string_noflagenum, 0, countof(printf_tests_flags_noflagenum));
! 407: suite_add_tcase(s, tc);
! 408:
! 409: tc = tcase_create("enum_printf_hook");
! 410: tcase_add_loop_test(tc, test_enum_printf_hook_cont, 0, countof(printf_tests_cont));
! 411: tcase_add_loop_test(tc, test_enum_printf_hook_split, 0, countof(printf_tests_split));
! 412: tcase_add_test(tc, test_enum_printf_hook_null);
! 413: tcase_add_loop_test(tc, test_enum_printf_hook_flags, 0, countof(printf_tests_flags));
! 414: tcase_add_loop_test(tc, test_enum_printf_hook_flags_incomplete, 0, countof(printf_tests_flags_incomplete));
! 415: tcase_add_loop_test(tc, test_enum_printf_hook_flags_null, 0, countof(printf_tests_flags_null));
! 416: tcase_add_loop_test(tc, test_enum_printf_hook_flags_overflow, 0, countof(printf_tests_flags_overflow));
! 417: tcase_add_loop_test(tc, test_enum_printf_hook_flags_noflagenum, 0, countof(printf_tests_flags_noflagenum));
! 418: tcase_add_test(tc, test_enum_printf_hook_width);
! 419: suite_add_tcase(s, tc);
! 420:
! 421: return s;
! 422: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_enum.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