Annotation of embedaddon/strongswan/src/starter/tests/suites/test_parser.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2014 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 <unistd.h>
! 17:
! 18: #include <test_suite.h>
! 19:
! 20: #include "../../parser/conf_parser.h"
! 21:
! 22: static char *path = "/tmp/strongswan-starter-parser-test";
! 23: static conf_parser_t *parser;
! 24:
! 25: static void create_parser(chunk_t contents)
! 26: {
! 27: ck_assert(chunk_write(contents, path, 0022, TRUE));
! 28: parser = conf_parser_create(path);
! 29: }
! 30:
! 31: START_TEARDOWN(teardown_parser)
! 32: {
! 33: parser->destroy(parser);
! 34: unlink(path);
! 35: }
! 36: END_TEARDOWN
! 37:
! 38: START_TEST(test_get_sections_config_setup)
! 39: {
! 40: enumerator_t *enumerator;
! 41:
! 42: create_parser(chunk_from_str(""));
! 43: ck_assert(parser->parse(parser));
! 44: enumerator = parser->get_sections(parser, CONF_PARSER_CONFIG_SETUP);
! 45: ck_assert(enumerator);
! 46: ck_assert(!enumerator->enumerate(enumerator, NULL));
! 47: enumerator->destroy(enumerator);
! 48: parser->destroy(parser);
! 49:
! 50: create_parser(chunk_from_str("config setup\n\tfoo=bar"));
! 51: ck_assert(parser->parse(parser));
! 52: enumerator = parser->get_sections(parser, CONF_PARSER_CONFIG_SETUP);
! 53: ck_assert(enumerator);
! 54: ck_assert(!enumerator->enumerate(enumerator, NULL));
! 55: enumerator->destroy(enumerator);
! 56: }
! 57: END_TEST
! 58:
! 59: START_TEST(test_get_sections_conn)
! 60: {
! 61: enumerator_t *enumerator;
! 62: char *name;
! 63:
! 64: create_parser(chunk_from_str(""));
! 65: ck_assert(parser->parse(parser));
! 66: enumerator = parser->get_sections(parser, CONF_PARSER_CONN);
! 67: ck_assert(enumerator);
! 68: ck_assert(!enumerator->enumerate(enumerator, NULL));
! 69: enumerator->destroy(enumerator);
! 70: parser->destroy(parser);
! 71:
! 72: create_parser(chunk_from_str(
! 73: "conn foo\n"
! 74: "conn bar\n"
! 75: "conn foo\n"));
! 76: ck_assert(parser->parse(parser));
! 77: enumerator = parser->get_sections(parser, CONF_PARSER_CONN);
! 78: ck_assert(enumerator);
! 79: ck_assert(enumerator->enumerate(enumerator, &name));
! 80: ck_assert_str_eq("foo", name);
! 81: ck_assert(enumerator->enumerate(enumerator, &name));
! 82: ck_assert_str_eq("bar", name);
! 83: ck_assert(!enumerator->enumerate(enumerator, &name));
! 84: enumerator->destroy(enumerator);
! 85: }
! 86: END_TEST
! 87:
! 88: START_TEST(test_get_section_config_setup)
! 89: {
! 90: dictionary_t *dict;
! 91:
! 92: create_parser(chunk_from_str(""));
! 93: ck_assert(parser->parse(parser));
! 94: dict = parser->get_section(parser, CONF_PARSER_CONFIG_SETUP, "foo");
! 95: ck_assert(dict);
! 96: dict->destroy(dict);
! 97: parser->destroy(parser);
! 98:
! 99: create_parser(chunk_from_str("config setup\n\tfoo=bar"));
! 100: ck_assert(parser->parse(parser));
! 101: dict = parser->get_section(parser, CONF_PARSER_CONFIG_SETUP, NULL);
! 102: ck_assert(dict);
! 103: dict->destroy(dict);
! 104: parser->destroy(parser);
! 105:
! 106: create_parser(chunk_from_str("config setup\n\tfoo=bar"));
! 107: ck_assert(parser->parse(parser));
! 108: dict = parser->get_section(parser, CONF_PARSER_CONFIG_SETUP, "foo");
! 109: ck_assert(dict);
! 110: dict->destroy(dict);
! 111: }
! 112: END_TEST
! 113:
! 114: START_TEST(test_get_section_conn)
! 115: {
! 116: dictionary_t *dict;
! 117:
! 118: create_parser(chunk_from_str(""));
! 119: ck_assert(parser->parse(parser));
! 120: dict = parser->get_section(parser, CONF_PARSER_CONN, "foo");
! 121: ck_assert(!dict);
! 122: parser->destroy(parser);
! 123:
! 124: create_parser(chunk_from_str("conn foo\n"));
! 125: ck_assert(parser->parse(parser));
! 126: dict = parser->get_section(parser, CONF_PARSER_CONN, "foo");
! 127: ck_assert(!parser->get_section(parser, CONF_PARSER_CONN, "bar"));
! 128: ck_assert(dict);
! 129: dict->destroy(dict);
! 130: parser->destroy(parser);
! 131:
! 132: create_parser(chunk_from_str("conn foo\n\tfoo=bar"));
! 133: ck_assert(parser->parse(parser));
! 134: dict = parser->get_section(parser, CONF_PARSER_CONN, "foo");
! 135: ck_assert(dict);
! 136: dict->destroy(dict);
! 137: }
! 138: END_TEST
! 139:
! 140: START_TEST(test_enumerate_values)
! 141: {
! 142: enumerator_t *enumerator;
! 143: dictionary_t *dict;
! 144: char *key, *value;
! 145: int i;
! 146:
! 147: create_parser(chunk_from_str(
! 148: "conn foo\n"
! 149: " foo=bar\n"
! 150: " bar=baz"));
! 151: ck_assert(parser->parse(parser));
! 152: dict = parser->get_section(parser, CONF_PARSER_CONN, "foo");
! 153: ck_assert(dict);
! 154: ck_assert_str_eq("bar", dict->get(dict, "foo"));
! 155: ck_assert_str_eq("baz", dict->get(dict, "bar"));
! 156: enumerator = dict->create_enumerator(dict);
! 157: for (i = 0; enumerator->enumerate(enumerator, &key, &value); i++)
! 158: {
! 159: if ((streq(key, "foo") && !streq(value, "bar")) ||
! 160: (streq(key, "bar") && !streq(value, "baz")))
! 161: {
! 162: fail("unexpected setting %s=%s", key, value);
! 163: }
! 164: }
! 165: enumerator->destroy(enumerator);
! 166: ck_assert_int_eq(i, 2);
! 167: dict->destroy(dict);
! 168: }
! 169: END_TEST
! 170:
! 171: #define extensibility_config(section) \
! 172: section "\n" \
! 173: " foo=bar\n" \
! 174: " dup=one\n" \
! 175: " dup=two\n" \
! 176: "\n" \
! 177: " nope=val\n" \
! 178: "\n" \
! 179: section "\n" \
! 180: " foo=baz\n" \
! 181: section "\n" \
! 182: " answer=42\n" \
! 183: " nope=\n"
! 184:
! 185: static struct {
! 186: char *conf;
! 187: conf_parser_section_t type;
! 188: char *name;
! 189: } extensibility_data[] = {
! 190: { extensibility_config("config setup"), CONF_PARSER_CONFIG_SETUP, NULL },
! 191: { extensibility_config("ca ca-foo"), CONF_PARSER_CA, "ca-foo" },
! 192: { extensibility_config("conn conn-foo"), CONF_PARSER_CONN, "conn-foo" },
! 193: };
! 194:
! 195: START_TEST(test_extensibility)
! 196: {
! 197: dictionary_t *dict;
! 198:
! 199: create_parser(chunk_from_str(extensibility_data[_i].conf));
! 200: ck_assert(parser->parse(parser));
! 201:
! 202: dict = parser->get_section(parser, extensibility_data[_i].type,
! 203: extensibility_data[_i].name);
! 204: ck_assert(dict);
! 205: ck_assert_str_eq("baz", dict->get(dict, "foo"));
! 206: ck_assert_str_eq("two", dict->get(dict, "dup"));
! 207: ck_assert_str_eq("42", dict->get(dict, "answer"));
! 208: ck_assert(!dict->get(dict, "nope"));
! 209: ck_assert(!dict->get(dict, "anything"));
! 210: dict->destroy(dict);
! 211: }
! 212: END_TEST
! 213:
! 214: static struct {
! 215: char *conf;
! 216: bool check_section;
! 217: char *value;
! 218: } comments_data[] = {
! 219: { "# conn foo", FALSE, NULL },
! 220: { "# conn foo\n", FALSE, NULL },
! 221: { "conn foo # asdf", TRUE, NULL },
! 222: { "conn foo # asdf", TRUE, NULL },
! 223: { "conn foo# asdf\n", TRUE, NULL },
! 224: { "conn foo # asdf\n\tkey=val", TRUE, "val" },
! 225: { "conn foo # asdf\n#\tkey=val", TRUE, NULL },
! 226: { "conn foo # asdf\n\t#key=val", TRUE, NULL },
! 227: { "conn foo # asdf\n\tkey=@#keyid", TRUE, "@#keyid" },
! 228: { "conn foo # asdf\n\tkey=\"@#keyid\"", TRUE, "@#keyid" },
! 229: { "conn foo # asdf\n\tkey=asdf@#keyid", TRUE, "asdf@" },
! 230: { "conn foo # asdf\n\tkey=#val", TRUE, NULL },
! 231: { "conn foo # asdf\n\tkey=val#asdf", TRUE, "val" },
! 232: { "conn foo # asdf\n\tkey=\"val#asdf\"", TRUE, "val#asdf" },
! 233: { "conn foo # asdf\n\tkey=val # asdf\n", TRUE, "val" },
! 234: { "conn foo # asdf\n# asdf\n\tkey=val\n", TRUE, "val" },
! 235: { "conn foo # asdf\n\t# asdf\n\tkey=val\n", TRUE, "val" },
! 236: };
! 237:
! 238: START_TEST(test_comments)
! 239: {
! 240: dictionary_t *dict;
! 241:
! 242: create_parser(chunk_from_str(comments_data[_i].conf));
! 243: ck_assert(parser->parse(parser));
! 244: if (comments_data[_i].check_section)
! 245: {
! 246: dict = parser->get_section(parser, CONF_PARSER_CONN, "foo");
! 247: ck_assert(dict);
! 248: if (comments_data[_i].value)
! 249: {
! 250: ck_assert_str_eq(comments_data[_i].value, dict->get(dict, "key"));
! 251: }
! 252: else
! 253: {
! 254: ck_assert(!dict->get(dict, "key"));
! 255: }
! 256: dict->destroy(dict);
! 257: }
! 258: else
! 259: {
! 260: ck_assert(!parser->get_section(parser, CONF_PARSER_CONN, "foo"));
! 261: }
! 262: }
! 263: END_TEST
! 264:
! 265: static struct {
! 266: char *conf;
! 267: bool check_section;
! 268: char *value;
! 269: } whitespace_data[] = {
! 270: { "conn foo ", FALSE, NULL },
! 271: { "conn foo", FALSE, NULL },
! 272: { "conn foo\n", FALSE, NULL },
! 273: { "conn foo \n", FALSE, NULL },
! 274: { "conn foo\n ", FALSE, NULL },
! 275: { "conn foo\n \n", FALSE, NULL },
! 276: { "conn foo\nconn bar", TRUE, NULL },
! 277: { "conn foo\n \nconn bar", TRUE, NULL },
! 278: { "conn foo\n key=val", FALSE, "val" },
! 279: { "conn foo\n\tkey=val", FALSE, "val" },
! 280: { "conn foo\n\t \tkey=val", FALSE, "val" },
! 281: { "conn foo\n\tkey = val ", FALSE, "val" },
! 282: };
! 283:
! 284: START_TEST(test_whitespace)
! 285: {
! 286: dictionary_t *dict;
! 287:
! 288: create_parser(chunk_from_str(whitespace_data[_i].conf));
! 289: ck_assert(parser->parse(parser));
! 290: dict = parser->get_section(parser, CONF_PARSER_CONN, "foo");
! 291: ck_assert(dict);
! 292: if (whitespace_data[_i].value)
! 293: {
! 294: ck_assert_str_eq(whitespace_data[_i].value, dict->get(dict, "key"));
! 295: }
! 296: else
! 297: {
! 298: ck_assert(!dict->get(dict, "key"));
! 299: }
! 300: dict->destroy(dict);
! 301: if (whitespace_data[_i].check_section)
! 302: {
! 303: dict = parser->get_section(parser, CONF_PARSER_CONN, "bar");
! 304: ck_assert(dict);
! 305: dict->destroy(dict);
! 306: }
! 307: else
! 308: {
! 309: ck_assert(!parser->get_section(parser, CONF_PARSER_CONN, "bar"));
! 310: }
! 311: }
! 312: END_TEST
! 313:
! 314: static struct {
! 315: bool valid;
! 316: char *conf;
! 317: char *section;
! 318: char *value;
! 319: } strings_data[] = {
! 320: { FALSE, "\"conn foo\"", NULL, NULL },
! 321: { TRUE, "conn \"foo\"", "foo", NULL },
! 322: { FALSE, "conn foo bar", NULL, NULL },
! 323: { TRUE, "conn \"foo bar\"", "foo bar", NULL },
! 324: { TRUE, "conn \"#foo\"", "#foo", NULL },
! 325: { FALSE, "conn foo\n\t\"key=val\"", "foo", NULL },
! 326: { TRUE, "conn foo\n\t\"key\"=val", "foo", "val" },
! 327: { TRUE, "conn foo\n\tkey=val ue", "foo", "val ue" },
! 328: { TRUE, "conn foo\n\tkey=val ue", "foo", "val ue" },
! 329: { TRUE, "conn foo\n\tkey=\"val ue\"", "foo", "val ue" },
! 330: { TRUE, "conn foo\n\tkey=\"val\\nue\"", "foo", "val\nue" },
! 331: { TRUE, "conn foo\n\tkey=\"val\nue\"", "foo", "val\nue" },
! 332: { TRUE, "conn foo\n\tkey=\"val\\\nue\"", "foo", "value" },
! 333: { FALSE, "conn foo\n\tkey=\"unterminated", "foo", NULL },
! 334: };
! 335:
! 336: START_TEST(test_strings)
! 337: {
! 338: dictionary_t *dict;
! 339:
! 340: create_parser(chunk_from_str(strings_data[_i].conf));
! 341: ck_assert(parser->parse(parser) == strings_data[_i].valid);
! 342: if (strings_data[_i].section)
! 343: {
! 344: dict = parser->get_section(parser, CONF_PARSER_CONN,
! 345: strings_data[_i].section);
! 346: ck_assert(dict);
! 347: if (strings_data[_i].value)
! 348: {
! 349: ck_assert_str_eq(strings_data[_i].value, dict->get(dict, "key"));
! 350: }
! 351: else
! 352: {
! 353: ck_assert(!dict->get(dict, "key"));
! 354: }
! 355: dict->destroy(dict);
! 356: }
! 357: }
! 358: END_TEST
! 359:
! 360: START_TEST(test_refcounting)
! 361: {
! 362: dictionary_t *dict;
! 363:
! 364: create_parser(chunk_from_str(
! 365: "conn foo\n"
! 366: " key=val"));
! 367:
! 368: ck_assert(parser->parse(parser));
! 369: dict = parser->get_section(parser, CONF_PARSER_CONN, "foo");
! 370: ck_assert(dict);
! 371: ck_assert_str_eq("val", dict->get(dict, "key"));
! 372: parser->destroy(parser);
! 373: ck_assert_str_eq("val", dict->get(dict, "key"));
! 374: dict->destroy(dict);
! 375: }
! 376: END_TEST
! 377:
! 378: START_TEST(test_default)
! 379: {
! 380: enumerator_t *enumerator;
! 381: dictionary_t *dict;
! 382: char *name;
! 383:
! 384: create_parser(chunk_from_str(
! 385: "conn %default\n"
! 386: " key=valdef\n"
! 387: " unset=set\n"
! 388: "conn A\n"
! 389: " key=vala\n"
! 390: " unset=\n"
! 391: "conn B\n"
! 392: " keyb=valb\n"
! 393: ""));
! 394:
! 395: ck_assert(parser->parse(parser));
! 396: dict = parser->get_section(parser, CONF_PARSER_CONN, "%default");
! 397: ck_assert(!dict);
! 398: enumerator = parser->get_sections(parser, CONF_PARSER_CONN);
! 399: ck_assert(enumerator);
! 400: ck_assert(enumerator->enumerate(enumerator, &name));
! 401: ck_assert_str_eq("A", name);
! 402: ck_assert(enumerator->enumerate(enumerator, &name));
! 403: ck_assert_str_eq("B", name);
! 404: ck_assert(!enumerator->enumerate(enumerator, &name));
! 405: enumerator->destroy(enumerator);
! 406:
! 407: dict = parser->get_section(parser, CONF_PARSER_CONN, "A");
! 408: ck_assert(dict);
! 409: ck_assert_str_eq("vala", dict->get(dict, "key"));
! 410: ck_assert(!dict->get(dict, "unset"));
! 411: dict->destroy(dict);
! 412: dict = parser->get_section(parser, CONF_PARSER_CONN, "B");
! 413: ck_assert(dict);
! 414: ck_assert_str_eq("valdef", dict->get(dict, "key"));
! 415: ck_assert_str_eq("valb", dict->get(dict, "keyb"));
! 416: ck_assert_str_eq("set", dict->get(dict, "unset"));
! 417: dict->destroy(dict);
! 418: }
! 419: END_TEST
! 420:
! 421: START_TEST(test_also)
! 422: {
! 423: dictionary_t *dict;
! 424:
! 425: create_parser(chunk_from_str(
! 426: "conn A\n"
! 427: " key=vala\n"
! 428: " keya=val1\n"
! 429: " unset=set\n"
! 430: "conn B\n"
! 431: " also=A\n"
! 432: " key=valb\n"
! 433: " keyb=val2\n"
! 434: " unset=\n"
! 435: "conn C\n"
! 436: " keyc=val3\n"
! 437: " unset=set again\n"
! 438: " also=B\n"
! 439: "conn D\n"
! 440: " keyd=val4\n"
! 441: " also=A\n"
! 442: " also=B\n"
! 443: "conn E\n"
! 444: " keye=val5\n"
! 445: " also=B\n"
! 446: " also=A\n"
! 447: ""));
! 448:
! 449: ck_assert(parser->parse(parser));
! 450: dict = parser->get_section(parser, CONF_PARSER_CONN, "B");
! 451: ck_assert(dict);
! 452: ck_assert_str_eq("valb", dict->get(dict, "key"));
! 453: ck_assert_str_eq("val1", dict->get(dict, "keya"));
! 454: ck_assert_str_eq("val2", dict->get(dict, "keyb"));
! 455: ck_assert(!dict->get(dict, "unset"));
! 456: dict->destroy(dict);
! 457: dict = parser->get_section(parser, CONF_PARSER_CONN, "C");
! 458: ck_assert(dict);
! 459: ck_assert_str_eq("valb", dict->get(dict, "key"));
! 460: ck_assert_str_eq("val1", dict->get(dict, "keya"));
! 461: ck_assert_str_eq("val2", dict->get(dict, "keyb"));
! 462: ck_assert_str_eq("val3", dict->get(dict, "keyc"));
! 463: ck_assert_str_eq("set again", dict->get(dict, "unset"));
! 464: dict->destroy(dict);
! 465: /* since B includes A too the inclusion in D and E has no effect */
! 466: dict = parser->get_section(parser, CONF_PARSER_CONN, "D");
! 467: ck_assert(dict);
! 468: ck_assert_str_eq("valb", dict->get(dict, "key"));
! 469: ck_assert_str_eq("val1", dict->get(dict, "keya"));
! 470: ck_assert_str_eq("val2", dict->get(dict, "keyb"));
! 471: ck_assert(!dict->get(dict, "keyc"));
! 472: ck_assert_str_eq("val4", dict->get(dict, "keyd"));
! 473: ck_assert(!dict->get(dict, "unset"));
! 474: dict->destroy(dict);
! 475: dict = parser->get_section(parser, CONF_PARSER_CONN, "E");
! 476: ck_assert(dict);
! 477: ck_assert_str_eq("valb", dict->get(dict, "key"));
! 478: ck_assert_str_eq("val1", dict->get(dict, "keya"));
! 479: ck_assert_str_eq("val2", dict->get(dict, "keyb"));
! 480: ck_assert(!dict->get(dict, "keyc"));
! 481: ck_assert(!dict->get(dict, "keyd"));
! 482: ck_assert_str_eq("val5", dict->get(dict, "keye"));
! 483: ck_assert(!dict->get(dict, "unset"));
! 484: dict->destroy(dict);
! 485: }
! 486: END_TEST
! 487:
! 488: START_TEST(test_ambiguous)
! 489: {
! 490: dictionary_t *dict;
! 491:
! 492: create_parser(chunk_from_str(
! 493: "conn A\n"
! 494: " key=vala\n"
! 495: "conn B\n"
! 496: " key=valb\n"
! 497: "conn C\n"
! 498: " also=A\n"
! 499: " also=B\n"
! 500: "conn D\n"
! 501: " also=B\n"
! 502: " also=A\n"
! 503: "conn E\n"
! 504: " also=C\n"
! 505: " also=D\n"
! 506: "conn F\n"
! 507: " also=D\n"
! 508: " also=C\n"));
! 509:
! 510: ck_assert(parser->parse(parser));
! 511: dict = parser->get_section(parser, CONF_PARSER_CONN, "E");
! 512: ck_assert(dict);
! 513: ck_assert_str_eq("valb", dict->get(dict, "key"));
! 514: dict->destroy(dict);
! 515: dict = parser->get_section(parser, CONF_PARSER_CONN, "F");
! 516: ck_assert(dict);
! 517: ck_assert_str_eq("vala", dict->get(dict, "key"));
! 518: dict->destroy(dict);
! 519: }
! 520: END_TEST
! 521:
! 522: Suite *parser_suite_create()
! 523: {
! 524: Suite *s;
! 525: TCase *tc;
! 526:
! 527: s = suite_create("ipsec.conf parser");
! 528:
! 529: tc = tcase_create("get_section(s)");
! 530: tcase_add_checked_fixture(tc, NULL, teardown_parser);
! 531: tcase_add_test(tc, test_get_sections_config_setup);
! 532: tcase_add_test(tc, test_get_sections_conn);
! 533: tcase_add_test(tc, test_get_section_config_setup);
! 534: tcase_add_test(tc, test_get_section_conn);
! 535: suite_add_tcase(s, tc);
! 536:
! 537: tc = tcase_create("enumerate settings");
! 538: tcase_add_checked_fixture(tc, NULL, teardown_parser);
! 539: tcase_add_test(tc, test_enumerate_values);
! 540: suite_add_tcase(s, tc);
! 541:
! 542: tc = tcase_create("extensibility");
! 543: tcase_add_checked_fixture(tc, NULL, teardown_parser);
! 544: tcase_add_loop_test(tc, test_extensibility, 0, countof(extensibility_data));
! 545: suite_add_tcase(s, tc);
! 546:
! 547: tc = tcase_create("comments");
! 548: tcase_add_checked_fixture(tc, NULL, teardown_parser);
! 549: tcase_add_loop_test(tc, test_comments, 0, countof(comments_data));
! 550: suite_add_tcase(s, tc);
! 551:
! 552: tc = tcase_create("whitespace");
! 553: tcase_add_checked_fixture(tc, NULL, teardown_parser);
! 554: tcase_add_loop_test(tc, test_whitespace, 0, countof(whitespace_data));
! 555: suite_add_tcase(s, tc);
! 556:
! 557: tc = tcase_create("strings");
! 558: tcase_add_checked_fixture(tc, NULL, teardown_parser);
! 559: tcase_add_loop_test(tc, test_strings, 0, countof(strings_data));
! 560: suite_add_tcase(s, tc);
! 561:
! 562: tc = tcase_create("refcounting");
! 563: tcase_add_test(tc, test_refcounting);
! 564: suite_add_tcase(s, tc);
! 565:
! 566: tc = tcase_create("%default");
! 567: tcase_add_checked_fixture(tc, NULL, teardown_parser);
! 568: tcase_add_test(tc, test_default);
! 569: suite_add_tcase(s, tc);
! 570:
! 571: tc = tcase_create("also=");
! 572: tcase_add_checked_fixture(tc, NULL, teardown_parser);
! 573: tcase_add_test(tc, test_also);
! 574: tcase_add_test(tc, test_ambiguous);
! 575: suite_add_tcase(s, tc);
! 576:
! 577: return s;
! 578: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_parser.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 / starter / tests / suites