Annotation of embedaddon/quagga/tests/bgp_mpath_test.c, revision 1.1
1.1 ! misho 1: /* $QuaggaId: Format:%an, %ai, %h$ $
! 2: *
! 3: * BGP Multipath Unit Test
! 4: * Copyright (C) 2010 Google Inc.
! 5: *
! 6: * This file is part of Quagga
! 7: *
! 8: * Quagga is free software; you can redistribute it and/or modify it
! 9: * under the terms of the GNU General Public License as published by the
! 10: * Free Software Foundation; either version 2, or (at your option) any
! 11: * later version.
! 12: *
! 13: * Quagga is distributed in the hope that it will be useful, but
! 14: * WITHOUT ANY WARRANTY; without even the implied warranty of
! 15: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! 16: * General Public License for more details.
! 17: *
! 18: * You should have received a copy of the GNU General Public License
! 19: * along with Quagga; see the file COPYING. If not, write to the Free
! 20: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
! 21: * 02111-1307, USA.
! 22: */
! 23:
! 24: #include <zebra.h>
! 25:
! 26: #include "vty.h"
! 27: #include "stream.h"
! 28: #include "privs.h"
! 29: #include "linklist.h"
! 30: #include "memory.h"
! 31: #include "zclient.h"
! 32:
! 33: #include "bgpd/bgpd.h"
! 34: #include "bgpd/bgp_table.h"
! 35: #include "bgpd/bgp_route.h"
! 36: #include "bgpd/bgp_attr.h"
! 37: #include "bgpd/bgp_mpath.h"
! 38:
! 39: #define VT100_RESET "\x1b[0m"
! 40: #define VT100_RED "\x1b[31m"
! 41: #define VT100_GREEN "\x1b[32m"
! 42: #define VT100_YELLOW "\x1b[33m"
! 43: #define OK VT100_GREEN "OK" VT100_RESET
! 44: #define FAILED VT100_RED "failed" VT100_RESET
! 45:
! 46: #define TEST_PASSED 0
! 47: #define TEST_FAILED -1
! 48:
! 49: #define EXPECT_TRUE(expr, res) \
! 50: if (!(expr)) \
! 51: { \
! 52: printf ("Test failure in %s line %u: %s\n", \
! 53: __FUNCTION__, __LINE__, #expr); \
! 54: (res) = TEST_FAILED; \
! 55: }
! 56:
! 57: typedef struct testcase_t__ testcase_t;
! 58:
! 59: typedef int (*test_setup_func)(testcase_t *);
! 60: typedef int (*test_run_func)(testcase_t *);
! 61: typedef int (*test_cleanup_func)(testcase_t *);
! 62:
! 63: struct testcase_t__ {
! 64: const char *desc;
! 65: void *test_data;
! 66: void *verify_data;
! 67: void *tmp_data;
! 68: test_setup_func setup;
! 69: test_run_func run;
! 70: test_cleanup_func cleanup;
! 71: };
! 72:
! 73: /* need these to link in libbgp */
! 74: struct thread_master *master = NULL;
! 75: struct zclient *zclient;
! 76: struct zebra_privs_t bgpd_privs =
! 77: {
! 78: .user = NULL,
! 79: .group = NULL,
! 80: .vty_group = NULL,
! 81: };
! 82:
! 83: static int tty = 0;
! 84:
! 85: /* Create fake bgp instance */
! 86: static struct bgp *
! 87: bgp_create_fake (as_t *as, const char *name)
! 88: {
! 89: struct bgp *bgp;
! 90: afi_t afi;
! 91: safi_t safi;
! 92:
! 93: if ( (bgp = XCALLOC (MTYPE_BGP, sizeof (struct bgp))) == NULL)
! 94: return NULL;
! 95:
! 96: bgp_lock (bgp);
! 97: //bgp->peer_self = peer_new (bgp);
! 98: //bgp->peer_self->host = XSTRDUP (MTYPE_BGP_PEER_HOST, "Static announcement");
! 99:
! 100: bgp->peer = list_new ();
! 101: //bgp->peer->cmp = (int (*)(void *, void *)) peer_cmp;
! 102:
! 103: bgp->group = list_new ();
! 104: //bgp->group->cmp = (int (*)(void *, void *)) peer_group_cmp;
! 105:
! 106: bgp->rsclient = list_new ();
! 107: //bgp->rsclient->cmp = (int (*)(void*, void*)) peer_cmp;
! 108:
! 109: for (afi = AFI_IP; afi < AFI_MAX; afi++)
! 110: for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
! 111: {
! 112: bgp->route[afi][safi] = bgp_table_init (afi, safi);
! 113: bgp->aggregate[afi][safi] = bgp_table_init (afi, safi);
! 114: bgp->rib[afi][safi] = bgp_table_init (afi, safi);
! 115: bgp->maxpaths[afi][safi].maxpaths_ebgp = BGP_DEFAULT_MAXPATHS;
! 116: bgp->maxpaths[afi][safi].maxpaths_ibgp = BGP_DEFAULT_MAXPATHS;
! 117: }
! 118:
! 119: bgp->default_local_pref = BGP_DEFAULT_LOCAL_PREF;
! 120: bgp->default_holdtime = BGP_DEFAULT_HOLDTIME;
! 121: bgp->default_keepalive = BGP_DEFAULT_KEEPALIVE;
! 122: bgp->restart_time = BGP_DEFAULT_RESTART_TIME;
! 123: bgp->stalepath_time = BGP_DEFAULT_STALEPATH_TIME;
! 124:
! 125: bgp->as = *as;
! 126:
! 127: if (name)
! 128: bgp->name = strdup (name);
! 129:
! 130: return bgp;
! 131: }
! 132:
! 133: /*=========================================================
! 134: * Testcase for maximum-paths configuration
! 135: */
! 136: static int
! 137: setup_bgp_cfg_maximum_paths (testcase_t *t)
! 138: {
! 139: as_t asn = 1;
! 140: t->tmp_data = bgp_create_fake (&asn, NULL);
! 141: if (!t->tmp_data)
! 142: return -1;
! 143: return 0;
! 144: }
! 145:
! 146: static int
! 147: run_bgp_cfg_maximum_paths (testcase_t *t)
! 148: {
! 149: afi_t afi;
! 150: safi_t safi;
! 151: struct bgp *bgp;
! 152: int api_result;
! 153: int test_result = TEST_PASSED;
! 154:
! 155: bgp = t->tmp_data;
! 156: for (afi = AFI_IP; afi < AFI_MAX; afi++)
! 157: for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
! 158: {
! 159: /* test bgp_maximum_paths_set */
! 160: api_result = bgp_maximum_paths_set (bgp, afi, safi, BGP_PEER_EBGP, 10);
! 161: EXPECT_TRUE (api_result == 0, test_result);
! 162: api_result = bgp_maximum_paths_set (bgp, afi, safi, BGP_PEER_IBGP, 10);
! 163: EXPECT_TRUE (api_result == 0, test_result);
! 164: EXPECT_TRUE (bgp->maxpaths[afi][safi].maxpaths_ebgp == 10, test_result);
! 165: EXPECT_TRUE (bgp->maxpaths[afi][safi].maxpaths_ibgp == 10, test_result);
! 166:
! 167: /* test bgp_maximum_paths_unset */
! 168: api_result = bgp_maximum_paths_unset (bgp, afi, safi, BGP_PEER_EBGP);
! 169: EXPECT_TRUE (api_result == 0, test_result);
! 170: api_result = bgp_maximum_paths_unset (bgp, afi, safi, BGP_PEER_IBGP);
! 171: EXPECT_TRUE (api_result == 0, test_result);
! 172: EXPECT_TRUE ((bgp->maxpaths[afi][safi].maxpaths_ebgp ==
! 173: BGP_DEFAULT_MAXPATHS), test_result);
! 174: EXPECT_TRUE ((bgp->maxpaths[afi][safi].maxpaths_ibgp ==
! 175: BGP_DEFAULT_MAXPATHS), test_result);
! 176: }
! 177:
! 178: return test_result;
! 179: }
! 180:
! 181: static int
! 182: cleanup_bgp_cfg_maximum_paths (testcase_t *t)
! 183: {
! 184: return bgp_delete ((struct bgp *)t->tmp_data);
! 185: }
! 186:
! 187: testcase_t test_bgp_cfg_maximum_paths = {
! 188: .desc = "Test bgp maximum-paths config",
! 189: .setup = setup_bgp_cfg_maximum_paths,
! 190: .run = run_bgp_cfg_maximum_paths,
! 191: .cleanup = cleanup_bgp_cfg_maximum_paths,
! 192: };
! 193:
! 194: /*=========================================================
! 195: * Testcase for bgp_mp_list
! 196: */
! 197: struct peer test_mp_list_peer[] = {
! 198: { .local_as = 1, .as = 2 },
! 199: { .local_as = 1, .as = 2 },
! 200: { .local_as = 1, .as = 2 },
! 201: { .local_as = 1, .as = 2 },
! 202: { .local_as = 1, .as = 2 },
! 203: };
! 204: int test_mp_list_peer_count = sizeof (test_mp_list_peer)/ sizeof (struct peer);
! 205: struct attr test_mp_list_attr[4];
! 206: struct bgp_info test_mp_list_info[] = {
! 207: { .peer = &test_mp_list_peer[0], .attr = &test_mp_list_attr[0] },
! 208: { .peer = &test_mp_list_peer[1], .attr = &test_mp_list_attr[1] },
! 209: { .peer = &test_mp_list_peer[2], .attr = &test_mp_list_attr[1] },
! 210: { .peer = &test_mp_list_peer[3], .attr = &test_mp_list_attr[2] },
! 211: { .peer = &test_mp_list_peer[4], .attr = &test_mp_list_attr[3] },
! 212: };
! 213: int test_mp_list_info_count =
! 214: sizeof (test_mp_list_info)/sizeof (struct bgp_info);
! 215:
! 216: static int
! 217: setup_bgp_mp_list (testcase_t *t)
! 218: {
! 219: test_mp_list_attr[0].nexthop.s_addr = 0x01010101;
! 220: test_mp_list_attr[1].nexthop.s_addr = 0x02020202;
! 221: test_mp_list_attr[2].nexthop.s_addr = 0x03030303;
! 222: test_mp_list_attr[3].nexthop.s_addr = 0x04040404;
! 223:
! 224: if ((test_mp_list_peer[0].su_remote = sockunion_str2su ("1.1.1.1")) == NULL)
! 225: return -1;
! 226: if ((test_mp_list_peer[1].su_remote = sockunion_str2su ("2.2.2.2")) == NULL)
! 227: return -1;
! 228: if ((test_mp_list_peer[2].su_remote = sockunion_str2su ("3.3.3.3")) == NULL)
! 229: return -1;
! 230: if ((test_mp_list_peer[3].su_remote = sockunion_str2su ("4.4.4.4")) == NULL)
! 231: return -1;
! 232: if ((test_mp_list_peer[4].su_remote = sockunion_str2su ("5.5.5.5")) == NULL)
! 233: return -1;
! 234:
! 235: return 0;
! 236: }
! 237:
! 238: static int
! 239: run_bgp_mp_list (testcase_t *t)
! 240: {
! 241: struct list mp_list;
! 242: struct listnode *mp_node;
! 243: struct bgp_info *info;
! 244: int i;
! 245: int test_result = TEST_PASSED;
! 246: bgp_mp_list_init (&mp_list);
! 247: EXPECT_TRUE (listcount(&mp_list) == 0, test_result);
! 248:
! 249: bgp_mp_list_add (&mp_list, &test_mp_list_info[1]);
! 250: bgp_mp_list_add (&mp_list, &test_mp_list_info[4]);
! 251: bgp_mp_list_add (&mp_list, &test_mp_list_info[2]);
! 252: bgp_mp_list_add (&mp_list, &test_mp_list_info[3]);
! 253: bgp_mp_list_add (&mp_list, &test_mp_list_info[0]);
! 254:
! 255: for (i = 0, mp_node = listhead(&mp_list); i < test_mp_list_info_count;
! 256: i++, mp_node = listnextnode(mp_node))
! 257: {
! 258: info = listgetdata(mp_node);
! 259: EXPECT_TRUE (info == &test_mp_list_info[i], test_result);
! 260: }
! 261:
! 262: bgp_mp_list_clear (&mp_list);
! 263: EXPECT_TRUE (listcount(&mp_list) == 0, test_result);
! 264:
! 265: return test_result;
! 266: }
! 267:
! 268: static int
! 269: cleanup_bgp_mp_list (testcase_t *t)
! 270: {
! 271: int i;
! 272:
! 273: for (i = 0; i < test_mp_list_peer_count; i++)
! 274: sockunion_free (test_mp_list_peer[i].su_remote);
! 275:
! 276: return 0;
! 277: }
! 278:
! 279: testcase_t test_bgp_mp_list = {
! 280: .desc = "Test bgp_mp_list",
! 281: .setup = setup_bgp_mp_list,
! 282: .run = run_bgp_mp_list,
! 283: .cleanup = cleanup_bgp_mp_list,
! 284: };
! 285:
! 286: /*=========================================================
! 287: * Testcase for bgp_info_mpath_update
! 288: */
! 289:
! 290: struct bgp_node test_rn;
! 291:
! 292: static int
! 293: setup_bgp_info_mpath_update (testcase_t *t)
! 294: {
! 295: int i;
! 296: str2prefix ("42.1.1.0/24", &test_rn.p);
! 297: setup_bgp_mp_list (t);
! 298: for (i = 0; i < test_mp_list_info_count; i++)
! 299: bgp_info_add (&test_rn, &test_mp_list_info[i]);
! 300: return 0;
! 301: }
! 302:
! 303: static int
! 304: run_bgp_info_mpath_update (testcase_t *t)
! 305: {
! 306: struct bgp_info *new_best, *old_best, *mpath;
! 307: struct list mp_list;
! 308: struct bgp_maxpaths_cfg mp_cfg = { 3, 3 };
! 309: int test_result = TEST_PASSED;
! 310: bgp_mp_list_init (&mp_list);
! 311: bgp_mp_list_add (&mp_list, &test_mp_list_info[4]);
! 312: bgp_mp_list_add (&mp_list, &test_mp_list_info[3]);
! 313: bgp_mp_list_add (&mp_list, &test_mp_list_info[0]);
! 314: bgp_mp_list_add (&mp_list, &test_mp_list_info[1]);
! 315: new_best = &test_mp_list_info[3];
! 316: old_best = NULL;
! 317: bgp_info_mpath_update (&test_rn, new_best, old_best, &mp_list, &mp_cfg);
! 318: bgp_mp_list_clear (&mp_list);
! 319: EXPECT_TRUE (bgp_info_mpath_count (new_best) == 2, test_result);
! 320: mpath = bgp_info_mpath_first (new_best);
! 321: EXPECT_TRUE (mpath == &test_mp_list_info[0], test_result);
! 322: EXPECT_TRUE (CHECK_FLAG (mpath->flags, BGP_INFO_MULTIPATH), test_result);
! 323: mpath = bgp_info_mpath_next (mpath);
! 324: EXPECT_TRUE (mpath == &test_mp_list_info[1], test_result);
! 325: EXPECT_TRUE (CHECK_FLAG (mpath->flags, BGP_INFO_MULTIPATH), test_result);
! 326:
! 327: bgp_mp_list_add (&mp_list, &test_mp_list_info[0]);
! 328: bgp_mp_list_add (&mp_list, &test_mp_list_info[1]);
! 329: new_best = &test_mp_list_info[0];
! 330: old_best = &test_mp_list_info[3];
! 331: bgp_info_mpath_update (&test_rn, new_best, old_best, &mp_list, &mp_cfg);
! 332: bgp_mp_list_clear (&mp_list);
! 333: EXPECT_TRUE (bgp_info_mpath_count (new_best) == 1, test_result);
! 334: mpath = bgp_info_mpath_first (new_best);
! 335: EXPECT_TRUE (mpath == &test_mp_list_info[1], test_result);
! 336: EXPECT_TRUE (CHECK_FLAG (mpath->flags, BGP_INFO_MULTIPATH), test_result);
! 337: EXPECT_TRUE (!CHECK_FLAG (test_mp_list_info[0].flags, BGP_INFO_MULTIPATH),
! 338: test_result);
! 339:
! 340: return test_result;
! 341: }
! 342:
! 343: static int
! 344: cleanup_bgp_info_mpath_update (testcase_t *t)
! 345: {
! 346: int i;
! 347:
! 348: for (i = 0; i < test_mp_list_peer_count; i++)
! 349: sockunion_free (test_mp_list_peer[i].su_remote);
! 350:
! 351: return 0;
! 352: }
! 353:
! 354: testcase_t test_bgp_info_mpath_update = {
! 355: .desc = "Test bgp_info_mpath_update",
! 356: .setup = setup_bgp_info_mpath_update,
! 357: .run = run_bgp_info_mpath_update,
! 358: .cleanup = cleanup_bgp_info_mpath_update,
! 359: };
! 360:
! 361: /*=========================================================
! 362: * Set up testcase vector
! 363: */
! 364: testcase_t *all_tests[] = {
! 365: &test_bgp_cfg_maximum_paths,
! 366: &test_bgp_mp_list,
! 367: &test_bgp_info_mpath_update,
! 368: };
! 369:
! 370: int all_tests_count = (sizeof(all_tests)/sizeof(testcase_t *));
! 371:
! 372: /*=========================================================
! 373: * Test Driver Functions
! 374: */
! 375: static int
! 376: global_test_init (void)
! 377: {
! 378: master = thread_master_create ();
! 379: zclient = zclient_new ();
! 380: bgp_master_init ();
! 381:
! 382: if (fileno (stdout) >= 0)
! 383: tty = isatty (fileno (stdout));
! 384: return 0;
! 385: }
! 386:
! 387: static int
! 388: global_test_cleanup (void)
! 389: {
! 390: zclient_free (zclient);
! 391: thread_master_free (master);
! 392: return 0;
! 393: }
! 394:
! 395: static void
! 396: display_result (testcase_t *test, int result)
! 397: {
! 398: if (tty)
! 399: printf ("%s: %s\n", test->desc, result == TEST_PASSED ? OK : FAILED);
! 400: else
! 401: printf ("%s: %s\n", test->desc, result == TEST_PASSED ? "OK" : "FAILED");
! 402: }
! 403:
! 404: static int
! 405: setup_test (testcase_t *t)
! 406: {
! 407: int res = 0;
! 408: if (t->setup)
! 409: res = t->setup (t);
! 410: return res;
! 411: }
! 412:
! 413: static int
! 414: cleanup_test (testcase_t *t)
! 415: {
! 416: int res = 0;
! 417: if (t->cleanup)
! 418: res = t->cleanup (t);
! 419: return res;
! 420: }
! 421:
! 422: static void
! 423: run_tests (testcase_t *tests[], int num_tests, int *pass_count, int *fail_count)
! 424: {
! 425: int test_index, result;
! 426: testcase_t *cur_test;
! 427:
! 428: *pass_count = *fail_count = 0;
! 429:
! 430: for (test_index = 0; test_index < num_tests; test_index++)
! 431: {
! 432: cur_test = tests[test_index];
! 433: if (!cur_test->desc)
! 434: {
! 435: printf ("error: test %d has no description!\n", test_index);
! 436: continue;
! 437: }
! 438: if (!cur_test->run)
! 439: {
! 440: printf ("error: test %s has no run function!\n", cur_test->desc);
! 441: continue;
! 442: }
! 443: if (setup_test (cur_test) != 0)
! 444: {
! 445: printf ("error: setup failed for test %s\n", cur_test->desc);
! 446: continue;
! 447: }
! 448: result = cur_test->run (cur_test);
! 449: if (result == TEST_PASSED)
! 450: *pass_count += 1;
! 451: else
! 452: *fail_count += 1;
! 453: display_result (cur_test, result);
! 454: if (cleanup_test (cur_test) != 0)
! 455: {
! 456: printf ("error: cleanup failed for test %s\n", cur_test->desc);
! 457: continue;
! 458: }
! 459: }
! 460: }
! 461:
! 462: int
! 463: main (void)
! 464: {
! 465: int pass_count, fail_count;
! 466: time_t cur_time;
! 467:
! 468: time (&cur_time);
! 469: printf("BGP Multipath Tests Run at %s", ctime(&cur_time));
! 470: if (global_test_init () != 0)
! 471: {
! 472: printf("Global init failed. Terminating.\n");
! 473: exit(1);
! 474: }
! 475: run_tests (all_tests, all_tests_count, &pass_count, &fail_count);
! 476: global_test_cleanup ();
! 477: printf("Total pass/fail: %d/%d\n", pass_count, fail_count);
! 478: return fail_count;
! 479: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bgp_mpath_test.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / tests