#include "bgpd/bgp_attr.h"
#include "bgpd/bgp_nexthop.h"
#include "bgpd/bgp_mpath.h"
+#include "bgpd/bgp_evpn.h"
#define VT100_RESET "\x1b[0m"
#define VT100_RED "\x1b[31m"
#define TEST_PASSED 0
#define TEST_FAILED -1
-#define EXPECT_TRUE(expr, res) \
- if (!(expr)) \
- { \
- printf ("Test failure in %s line %u: %s\n", \
- __FUNCTION__, __LINE__, #expr); \
- (res) = TEST_FAILED; \
- }
+#define EXPECT_TRUE(expr, res) \
+ if (!(expr)) { \
+ printf("Test failure in %s line %u: %s\n", __FUNCTION__, \
+ __LINE__, #expr); \
+ (res) = TEST_FAILED; \
+ }
typedef struct testcase_t__ testcase_t;
typedef int (*test_cleanup_func)(testcase_t *);
struct testcase_t__ {
- const char *desc;
- void *test_data;
- void *verify_data;
- void *tmp_data;
- test_setup_func setup;
- test_run_func run;
- test_cleanup_func cleanup;
+ const char *desc;
+ void *test_data;
+ void *verify_data;
+ void *tmp_data;
+ test_setup_func setup;
+ test_run_func run;
+ test_cleanup_func cleanup;
};
/* need these to link in libbgp */
struct thread_master *master = NULL;
struct zclient *zclient;
-struct zebra_privs_t bgpd_privs =
-{
- .user = NULL,
- .group = NULL,
- .vty_group = NULL,
+struct zebra_privs_t bgpd_privs = {
+ .user = NULL,
+ .group = NULL,
+ .vty_group = NULL,
};
static int tty = 0;
/* Create fake bgp instance */
-static struct bgp *
-bgp_create_fake (as_t *as, const char *name)
+static struct bgp *bgp_create_fake(as_t *as, const char *name)
{
- struct bgp *bgp;
- afi_t afi;
- safi_t safi;
-
- if ( (bgp = XCALLOC (MTYPE_BGP, sizeof (struct bgp))) == NULL)
- return NULL;
-
- bgp_lock (bgp);
- //bgp->peer_self = peer_new (bgp);
- //bgp->peer_self->host = XSTRDUP (MTYPE_BGP_PEER_HOST, "Static announcement");
-
- bgp->peer = list_new ();
- //bgp->peer->cmp = (int (*)(void *, void *)) peer_cmp;
-
- bgp->group = list_new ();
- //bgp->group->cmp = (int (*)(void *, void *)) peer_group_cmp;
-
- for (afi = AFI_IP; afi < AFI_MAX; afi++)
- for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
- {
- bgp->route[afi][safi] = bgp_table_init (afi, safi);
- bgp->aggregate[afi][safi] = bgp_table_init (afi, safi);
- bgp->rib[afi][safi] = bgp_table_init (afi, safi);
- bgp->maxpaths[afi][safi].maxpaths_ebgp = MULTIPATH_NUM;
- bgp->maxpaths[afi][safi].maxpaths_ibgp = MULTIPATH_NUM;
- }
-
- bgp_scan_init (bgp);
- bgp->default_local_pref = BGP_DEFAULT_LOCAL_PREF;
- bgp->default_holdtime = BGP_DEFAULT_HOLDTIME;
- bgp->default_keepalive = BGP_DEFAULT_KEEPALIVE;
- bgp->restart_time = BGP_DEFAULT_RESTART_TIME;
- bgp->stalepath_time = BGP_DEFAULT_STALEPATH_TIME;
-
- bgp->as = *as;
-
- if (name)
- bgp->name = strdup (name);
-
- return bgp;
+ struct bgp *bgp;
+ afi_t afi;
+ safi_t safi;
+
+ if ((bgp = XCALLOC(MTYPE_BGP, sizeof(struct bgp))) == NULL)
+ return NULL;
+
+ bgp_lock(bgp);
+ // bgp->peer_self = peer_new (bgp);
+ // bgp->peer_self->host = XSTRDUP (MTYPE_BGP_PEER_HOST, "Static
+ // announcement");
+
+ bgp->peer = list_new();
+ // bgp->peer->cmp = (int (*)(void *, void *)) peer_cmp;
+
+ bgp->group = list_new();
+ // bgp->group->cmp = (int (*)(void *, void *)) peer_group_cmp;
+
+ bgp_evpn_init(bgp);
+ for (afi = AFI_IP; afi < AFI_MAX; afi++)
+ for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++) {
+ bgp->route[afi][safi] = bgp_table_init(bgp, afi, safi);
+ bgp->aggregate[afi][safi] = bgp_table_init(
+ bgp, afi, safi);
+ bgp->rib[afi][safi] = bgp_table_init(bgp, afi, safi);
+ bgp->maxpaths[afi][safi].maxpaths_ebgp = MULTIPATH_NUM;
+ bgp->maxpaths[afi][safi].maxpaths_ibgp = MULTIPATH_NUM;
+ }
+
+ bgp_scan_init(bgp);
+ bgp->default_local_pref = BGP_DEFAULT_LOCAL_PREF;
+ bgp->default_holdtime = BGP_DEFAULT_HOLDTIME;
+ bgp->default_keepalive = BGP_DEFAULT_KEEPALIVE;
+ bgp->restart_time = BGP_DEFAULT_RESTART_TIME;
+ bgp->stalepath_time = BGP_DEFAULT_STALEPATH_TIME;
+
+ bgp->as = *as;
+
+ if (name)
+ bgp->name = strdup(name);
+
+ return bgp;
}
/*=========================================================
* Testcase for maximum-paths configuration
*/
-static int
-setup_bgp_cfg_maximum_paths (testcase_t *t)
+static int setup_bgp_cfg_maximum_paths(testcase_t *t)
{
- as_t asn = 1;
- t->tmp_data = bgp_create_fake (&asn, NULL);
- if (!t->tmp_data)
- return -1;
- return 0;
+ as_t asn = 1;
+ t->tmp_data = bgp_create_fake(&asn, NULL);
+ if (!t->tmp_data)
+ return -1;
+ return 0;
}
-static int
-run_bgp_cfg_maximum_paths (testcase_t *t)
+static int run_bgp_cfg_maximum_paths(testcase_t *t)
{
- afi_t afi;
- safi_t safi;
- struct bgp *bgp;
- int api_result;
- int test_result = TEST_PASSED;
-
- bgp = t->tmp_data;
- for (afi = AFI_IP; afi < AFI_MAX; afi++)
- for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
- {
- /* test bgp_maximum_paths_set */
- api_result = bgp_maximum_paths_set (bgp, afi, safi, BGP_PEER_EBGP, 10, 0);
- EXPECT_TRUE (api_result == 0, test_result);
- api_result = bgp_maximum_paths_set (bgp, afi, safi, BGP_PEER_IBGP, 10, 0);
- EXPECT_TRUE (api_result == 0, test_result);
- EXPECT_TRUE (bgp->maxpaths[afi][safi].maxpaths_ebgp == 10, test_result);
- EXPECT_TRUE (bgp->maxpaths[afi][safi].maxpaths_ibgp == 10, test_result);
-
- /* test bgp_maximum_paths_unset */
- api_result = bgp_maximum_paths_unset (bgp, afi, safi, BGP_PEER_EBGP);
- EXPECT_TRUE (api_result == 0, test_result);
- api_result = bgp_maximum_paths_unset (bgp, afi, safi, BGP_PEER_IBGP);
- EXPECT_TRUE (api_result == 0, test_result);
- EXPECT_TRUE ((bgp->maxpaths[afi][safi].maxpaths_ebgp ==
- MULTIPATH_NUM), test_result);
- EXPECT_TRUE ((bgp->maxpaths[afi][safi].maxpaths_ibgp ==
- MULTIPATH_NUM), test_result);
- }
-
- return test_result;
+ afi_t afi;
+ safi_t safi;
+ struct bgp *bgp;
+ int api_result;
+ int test_result = TEST_PASSED;
+
+ bgp = t->tmp_data;
+ for (afi = AFI_IP; afi < AFI_MAX; afi++)
+ for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++) {
+ /* test bgp_maximum_paths_set */
+ api_result = bgp_maximum_paths_set(
+ bgp, afi, safi, BGP_PEER_EBGP, 10, 0);
+ EXPECT_TRUE(api_result == 0, test_result);
+ api_result = bgp_maximum_paths_set(
+ bgp, afi, safi, BGP_PEER_IBGP, 10, 0);
+ EXPECT_TRUE(api_result == 0, test_result);
+ EXPECT_TRUE(bgp->maxpaths[afi][safi].maxpaths_ebgp
+ == 10,
+ test_result);
+ EXPECT_TRUE(bgp->maxpaths[afi][safi].maxpaths_ibgp
+ == 10,
+ test_result);
+
+ /* test bgp_maximum_paths_unset */
+ api_result = bgp_maximum_paths_unset(bgp, afi, safi,
+ BGP_PEER_EBGP);
+ EXPECT_TRUE(api_result == 0, test_result);
+ api_result = bgp_maximum_paths_unset(bgp, afi, safi,
+ BGP_PEER_IBGP);
+ EXPECT_TRUE(api_result == 0, test_result);
+ EXPECT_TRUE((bgp->maxpaths[afi][safi].maxpaths_ebgp
+ == MULTIPATH_NUM),
+ test_result);
+ EXPECT_TRUE((bgp->maxpaths[afi][safi].maxpaths_ibgp
+ == MULTIPATH_NUM),
+ test_result);
+ }
+
+ return test_result;
}
-static int
-cleanup_bgp_cfg_maximum_paths (testcase_t *t)
+static int cleanup_bgp_cfg_maximum_paths(testcase_t *t)
{
- return bgp_delete ((struct bgp *)t->tmp_data);
+ return bgp_delete((struct bgp *)t->tmp_data);
}
testcase_t test_bgp_cfg_maximum_paths = {
- .desc = "Test bgp maximum-paths config",
- .setup = setup_bgp_cfg_maximum_paths,
- .run = run_bgp_cfg_maximum_paths,
- .cleanup = cleanup_bgp_cfg_maximum_paths,
+ .desc = "Test bgp maximum-paths config",
+ .setup = setup_bgp_cfg_maximum_paths,
+ .run = run_bgp_cfg_maximum_paths,
+ .cleanup = cleanup_bgp_cfg_maximum_paths,
};
/*=========================================================
* Testcase for bgp_mp_list
*/
struct peer test_mp_list_peer[] = {
- { .local_as = 1, .as = 2 },
- { .local_as = 1, .as = 2 },
- { .local_as = 1, .as = 2 },
- { .local_as = 1, .as = 2 },
- { .local_as = 1, .as = 2 },
+ {.local_as = 1, .as = 2}, {.local_as = 1, .as = 2},
+ {.local_as = 1, .as = 2}, {.local_as = 1, .as = 2},
+ {.local_as = 1, .as = 2},
};
-int test_mp_list_peer_count = sizeof (test_mp_list_peer)/ sizeof (struct peer);
+int test_mp_list_peer_count = sizeof(test_mp_list_peer) / sizeof(struct peer);
struct attr test_mp_list_attr[4];
struct bgp_info test_mp_list_info[] = {
- { .peer = &test_mp_list_peer[0], .attr = &test_mp_list_attr[0] },
- { .peer = &test_mp_list_peer[1], .attr = &test_mp_list_attr[1] },
- { .peer = &test_mp_list_peer[2], .attr = &test_mp_list_attr[1] },
- { .peer = &test_mp_list_peer[3], .attr = &test_mp_list_attr[2] },
- { .peer = &test_mp_list_peer[4], .attr = &test_mp_list_attr[3] },
+ {.peer = &test_mp_list_peer[0], .attr = &test_mp_list_attr[0]},
+ {.peer = &test_mp_list_peer[1], .attr = &test_mp_list_attr[1]},
+ {.peer = &test_mp_list_peer[2], .attr = &test_mp_list_attr[1]},
+ {.peer = &test_mp_list_peer[3], .attr = &test_mp_list_attr[2]},
+ {.peer = &test_mp_list_peer[4], .attr = &test_mp_list_attr[3]},
};
int test_mp_list_info_count =
- sizeof (test_mp_list_info)/sizeof (struct bgp_info);
+ sizeof(test_mp_list_info) / sizeof(struct bgp_info);
-static int
-setup_bgp_mp_list (testcase_t *t)
+static int setup_bgp_mp_list(testcase_t *t)
{
- test_mp_list_attr[0].nexthop.s_addr = 0x01010101;
- test_mp_list_attr[1].nexthop.s_addr = 0x02020202;
- test_mp_list_attr[2].nexthop.s_addr = 0x03030303;
- test_mp_list_attr[3].nexthop.s_addr = 0x04040404;
-
- if ((test_mp_list_peer[0].su_remote = sockunion_str2su ("1.1.1.1")) == NULL)
- return -1;
- if ((test_mp_list_peer[1].su_remote = sockunion_str2su ("2.2.2.2")) == NULL)
- return -1;
- if ((test_mp_list_peer[2].su_remote = sockunion_str2su ("3.3.3.3")) == NULL)
- return -1;
- if ((test_mp_list_peer[3].su_remote = sockunion_str2su ("4.4.4.4")) == NULL)
- return -1;
- if ((test_mp_list_peer[4].su_remote = sockunion_str2su ("5.5.5.5")) == NULL)
- return -1;
-
- return 0;
+ test_mp_list_attr[0].nexthop.s_addr = 0x01010101;
+ test_mp_list_attr[1].nexthop.s_addr = 0x02020202;
+ test_mp_list_attr[2].nexthop.s_addr = 0x03030303;
+ test_mp_list_attr[3].nexthop.s_addr = 0x04040404;
+
+ if ((test_mp_list_peer[0].su_remote = sockunion_str2su("1.1.1.1"))
+ == NULL)
+ return -1;
+ if ((test_mp_list_peer[1].su_remote = sockunion_str2su("2.2.2.2"))
+ == NULL)
+ return -1;
+ if ((test_mp_list_peer[2].su_remote = sockunion_str2su("3.3.3.3"))
+ == NULL)
+ return -1;
+ if ((test_mp_list_peer[3].su_remote = sockunion_str2su("4.4.4.4"))
+ == NULL)
+ return -1;
+ if ((test_mp_list_peer[4].su_remote = sockunion_str2su("5.5.5.5"))
+ == NULL)
+ return -1;
+
+ return 0;
}
-static int
-run_bgp_mp_list (testcase_t *t)
+static int run_bgp_mp_list(testcase_t *t)
{
- struct list mp_list;
- struct listnode *mp_node;
- struct bgp_info *info;
- int i;
- int test_result = TEST_PASSED;
- bgp_mp_list_init (&mp_list);
- EXPECT_TRUE (listcount(&mp_list) == 0, test_result);
-
- bgp_mp_list_add (&mp_list, &test_mp_list_info[1]);
- bgp_mp_list_add (&mp_list, &test_mp_list_info[4]);
- bgp_mp_list_add (&mp_list, &test_mp_list_info[2]);
- bgp_mp_list_add (&mp_list, &test_mp_list_info[3]);
- bgp_mp_list_add (&mp_list, &test_mp_list_info[0]);
-
- for (i = 0, mp_node = mp_list.head; i < test_mp_list_info_count;
- i++, mp_node = listnextnode(mp_node))
- {
- info = listgetdata(mp_node);
- EXPECT_TRUE (info == &test_mp_list_info[i], test_result);
- }
-
- bgp_mp_list_clear (&mp_list);
- EXPECT_TRUE (listcount(&mp_list) == 0, test_result);
-
- return test_result;
+ struct list mp_list;
+ struct listnode *mp_node;
+ struct bgp_info *info;
+ int i;
+ int test_result = TEST_PASSED;
+ bgp_mp_list_init(&mp_list);
+ EXPECT_TRUE(listcount(&mp_list) == 0, test_result);
+
+ bgp_mp_list_add(&mp_list, &test_mp_list_info[1]);
+ bgp_mp_list_add(&mp_list, &test_mp_list_info[4]);
+ bgp_mp_list_add(&mp_list, &test_mp_list_info[2]);
+ bgp_mp_list_add(&mp_list, &test_mp_list_info[3]);
+ bgp_mp_list_add(&mp_list, &test_mp_list_info[0]);
+
+ for (i = 0, mp_node = mp_list.head; i < test_mp_list_info_count;
+ i++, mp_node = listnextnode(mp_node)) {
+ info = listgetdata(mp_node);
+ EXPECT_TRUE(info == &test_mp_list_info[i], test_result);
+ }
+
+ bgp_mp_list_clear(&mp_list);
+ EXPECT_TRUE(listcount(&mp_list) == 0, test_result);
+
+ return test_result;
}
-static int
-cleanup_bgp_mp_list (testcase_t *t)
+static int cleanup_bgp_mp_list(testcase_t *t)
{
- int i;
+ int i;
- for (i = 0; i < test_mp_list_peer_count; i++)
- sockunion_free (test_mp_list_peer[i].su_remote);
+ for (i = 0; i < test_mp_list_peer_count; i++)
+ sockunion_free(test_mp_list_peer[i].su_remote);
- return 0;
+ return 0;
}
testcase_t test_bgp_mp_list = {
- .desc = "Test bgp_mp_list",
- .setup = setup_bgp_mp_list,
- .run = run_bgp_mp_list,
- .cleanup = cleanup_bgp_mp_list,
+ .desc = "Test bgp_mp_list",
+ .setup = setup_bgp_mp_list,
+ .run = run_bgp_mp_list,
+ .cleanup = cleanup_bgp_mp_list,
};
/*=========================================================
struct bgp_node test_rn;
-static int
-setup_bgp_info_mpath_update (testcase_t *t)
+static int setup_bgp_info_mpath_update(testcase_t *t)
{
- int i;
- str2prefix ("42.1.1.0/24", &test_rn.p);
- setup_bgp_mp_list (t);
- for (i = 0; i < test_mp_list_info_count; i++)
- bgp_info_add (&test_rn, &test_mp_list_info[i]);
- return 0;
+ int i;
+ str2prefix("42.1.1.0/24", &test_rn.p);
+ setup_bgp_mp_list(t);
+ for (i = 0; i < test_mp_list_info_count; i++)
+ bgp_info_add(&test_rn, &test_mp_list_info[i]);
+ return 0;
}
-static int
-run_bgp_info_mpath_update (testcase_t *t)
+static int run_bgp_info_mpath_update(testcase_t *t)
{
- struct bgp_info *new_best, *old_best, *mpath;
- struct list mp_list;
- struct bgp_maxpaths_cfg mp_cfg = { 3, 3 };
- int test_result = TEST_PASSED;
- bgp_mp_list_init (&mp_list);
- bgp_mp_list_add (&mp_list, &test_mp_list_info[4]);
- bgp_mp_list_add (&mp_list, &test_mp_list_info[3]);
- bgp_mp_list_add (&mp_list, &test_mp_list_info[0]);
- bgp_mp_list_add (&mp_list, &test_mp_list_info[1]);
- new_best = &test_mp_list_info[3];
- old_best = NULL;
- bgp_info_mpath_update (&test_rn, new_best, old_best, &mp_list, &mp_cfg);
- bgp_mp_list_clear (&mp_list);
- EXPECT_TRUE (bgp_info_mpath_count (new_best) == 2, test_result);
- mpath = bgp_info_mpath_first (new_best);
- EXPECT_TRUE (mpath == &test_mp_list_info[0], test_result);
- EXPECT_TRUE (CHECK_FLAG (mpath->flags, BGP_INFO_MULTIPATH), test_result);
- mpath = bgp_info_mpath_next (mpath);
- EXPECT_TRUE (mpath == &test_mp_list_info[1], test_result);
- EXPECT_TRUE (CHECK_FLAG (mpath->flags, BGP_INFO_MULTIPATH), test_result);
-
- bgp_mp_list_add (&mp_list, &test_mp_list_info[0]);
- bgp_mp_list_add (&mp_list, &test_mp_list_info[1]);
- new_best = &test_mp_list_info[0];
- old_best = &test_mp_list_info[3];
- bgp_info_mpath_update (&test_rn, new_best, old_best, &mp_list, &mp_cfg);
- bgp_mp_list_clear (&mp_list);
- EXPECT_TRUE (bgp_info_mpath_count (new_best) == 1, test_result);
- mpath = bgp_info_mpath_first (new_best);
- EXPECT_TRUE (mpath == &test_mp_list_info[1], test_result);
- EXPECT_TRUE (CHECK_FLAG (mpath->flags, BGP_INFO_MULTIPATH), test_result);
- EXPECT_TRUE (!CHECK_FLAG (test_mp_list_info[0].flags, BGP_INFO_MULTIPATH),
- test_result);
-
- return test_result;
+ struct bgp_info *new_best, *old_best, *mpath;
+ struct list mp_list;
+ struct bgp_maxpaths_cfg mp_cfg = {3, 3};
+ int test_result = TEST_PASSED;
+ bgp_mp_list_init(&mp_list);
+ bgp_mp_list_add(&mp_list, &test_mp_list_info[4]);
+ bgp_mp_list_add(&mp_list, &test_mp_list_info[3]);
+ bgp_mp_list_add(&mp_list, &test_mp_list_info[0]);
+ bgp_mp_list_add(&mp_list, &test_mp_list_info[1]);
+ new_best = &test_mp_list_info[3];
+ old_best = NULL;
+ bgp_info_mpath_update(&test_rn, new_best, old_best, &mp_list, &mp_cfg);
+ bgp_mp_list_clear(&mp_list);
+ EXPECT_TRUE(bgp_info_mpath_count(new_best) == 2, test_result);
+ mpath = bgp_info_mpath_first(new_best);
+ EXPECT_TRUE(mpath == &test_mp_list_info[0], test_result);
+ EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_INFO_MULTIPATH), test_result);
+ mpath = bgp_info_mpath_next(mpath);
+ EXPECT_TRUE(mpath == &test_mp_list_info[1], test_result);
+ EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_INFO_MULTIPATH), test_result);
+
+ bgp_mp_list_add(&mp_list, &test_mp_list_info[0]);
+ bgp_mp_list_add(&mp_list, &test_mp_list_info[1]);
+ new_best = &test_mp_list_info[0];
+ old_best = &test_mp_list_info[3];
+ bgp_info_mpath_update(&test_rn, new_best, old_best, &mp_list, &mp_cfg);
+ bgp_mp_list_clear(&mp_list);
+ EXPECT_TRUE(bgp_info_mpath_count(new_best) == 1, test_result);
+ mpath = bgp_info_mpath_first(new_best);
+ EXPECT_TRUE(mpath == &test_mp_list_info[1], test_result);
+ EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_INFO_MULTIPATH), test_result);
+ EXPECT_TRUE(!CHECK_FLAG(test_mp_list_info[0].flags, BGP_INFO_MULTIPATH),
+ test_result);
+
+ return test_result;
}
-static int
-cleanup_bgp_info_mpath_update (testcase_t *t)
+static int cleanup_bgp_info_mpath_update(testcase_t *t)
{
- int i;
+ int i;
- for (i = 0; i < test_mp_list_peer_count; i++)
- sockunion_free (test_mp_list_peer[i].su_remote);
+ for (i = 0; i < test_mp_list_peer_count; i++)
+ sockunion_free(test_mp_list_peer[i].su_remote);
- return 0;
+ return 0;
}
testcase_t test_bgp_info_mpath_update = {
- .desc = "Test bgp_info_mpath_update",
- .setup = setup_bgp_info_mpath_update,
- .run = run_bgp_info_mpath_update,
- .cleanup = cleanup_bgp_info_mpath_update,
+ .desc = "Test bgp_info_mpath_update",
+ .setup = setup_bgp_info_mpath_update,
+ .run = run_bgp_info_mpath_update,
+ .cleanup = cleanup_bgp_info_mpath_update,
};
/*=========================================================
* Set up testcase vector
*/
testcase_t *all_tests[] = {
- &test_bgp_cfg_maximum_paths,
- &test_bgp_mp_list,
- &test_bgp_info_mpath_update,
+ &test_bgp_cfg_maximum_paths, &test_bgp_mp_list,
+ &test_bgp_info_mpath_update,
};
-int all_tests_count = (sizeof(all_tests)/sizeof(testcase_t *));
+int all_tests_count = (sizeof(all_tests) / sizeof(testcase_t *));
/*=========================================================
* Test Driver Functions
*/
-static int
-global_test_init (void)
+static int global_test_init(void)
{
- qobj_init ();
- master = thread_master_create(NULL);
- zclient = zclient_new(master);
- bgp_master_init (master);
- vrf_init (NULL, NULL, NULL, NULL);
- bgp_option_set (BGP_OPT_NO_LISTEN);
-
- if (fileno (stdout) >= 0)
- tty = isatty (fileno (stdout));
- return 0;
+ qobj_init();
+ master = thread_master_create(NULL);
+ zclient = zclient_new_notify(master, &zclient_options_default);
+ bgp_master_init(master);
+ vrf_init(NULL, NULL, NULL, NULL);
+ bgp_option_set(BGP_OPT_NO_LISTEN);
+
+ if (fileno(stdout) >= 0)
+ tty = isatty(fileno(stdout));
+ return 0;
}
-static int
-global_test_cleanup (void)
+static int global_test_cleanup(void)
{
- if (zclient != NULL)
- zclient_free (zclient);
- thread_master_free (master);
- return 0;
+ if (zclient != NULL)
+ zclient_free(zclient);
+ thread_master_free(master);
+ return 0;
}
-static void
-display_result (testcase_t *test, int result)
+static void display_result(testcase_t *test, int result)
{
- if (tty)
- printf ("%s: %s\n", test->desc, result == TEST_PASSED ? OK : FAILED);
- else
- printf ("%s: %s\n", test->desc, result == TEST_PASSED ? "OK" : "FAILED");
+ if (tty)
+ printf("%s: %s\n", test->desc,
+ result == TEST_PASSED ? OK : FAILED);
+ else
+ printf("%s: %s\n", test->desc,
+ result == TEST_PASSED ? "OK" : "FAILED");
}
-static int
-setup_test (testcase_t *t)
+static int setup_test(testcase_t *t)
{
- int res = 0;
- if (t->setup)
- res = t->setup (t);
- return res;
+ int res = 0;
+ if (t->setup)
+ res = t->setup(t);
+ return res;
}
-static int
-cleanup_test (testcase_t *t)
+static int cleanup_test(testcase_t *t)
{
- int res = 0;
- if (t->cleanup)
- res = t->cleanup (t);
- return res;
+ int res = 0;
+ if (t->cleanup)
+ res = t->cleanup(t);
+ return res;
}
-static void
-run_tests (testcase_t *tests[], int num_tests, int *pass_count, int *fail_count)
+static void run_tests(testcase_t *tests[], int num_tests, int *pass_count,
+ int *fail_count)
{
- int test_index, result;
- testcase_t *cur_test;
-
- *pass_count = *fail_count = 0;
-
- for (test_index = 0; test_index < num_tests; test_index++)
- {
- cur_test = tests[test_index];
- if (!cur_test->desc)
- {
- printf ("error: test %d has no description!\n", test_index);
- continue;
- }
- if (!cur_test->run)
- {
- printf ("error: test %s has no run function!\n", cur_test->desc);
- continue;
- }
- if (setup_test (cur_test) != 0)
- {
- printf ("error: setup failed for test %s\n", cur_test->desc);
- continue;
- }
- result = cur_test->run (cur_test);
- if (result == TEST_PASSED)
- *pass_count += 1;
- else
- *fail_count += 1;
- display_result (cur_test, result);
- if (cleanup_test (cur_test) != 0)
- {
- printf ("error: cleanup failed for test %s\n", cur_test->desc);
- continue;
- }
- }
+ int test_index, result;
+ testcase_t *cur_test;
+
+ *pass_count = *fail_count = 0;
+
+ for (test_index = 0; test_index < num_tests; test_index++) {
+ cur_test = tests[test_index];
+ if (!cur_test->desc) {
+ printf("error: test %d has no description!\n",
+ test_index);
+ continue;
+ }
+ if (!cur_test->run) {
+ printf("error: test %s has no run function!\n",
+ cur_test->desc);
+ continue;
+ }
+ if (setup_test(cur_test) != 0) {
+ printf("error: setup failed for test %s\n",
+ cur_test->desc);
+ continue;
+ }
+ result = cur_test->run(cur_test);
+ if (result == TEST_PASSED)
+ *pass_count += 1;
+ else
+ *fail_count += 1;
+ display_result(cur_test, result);
+ if (cleanup_test(cur_test) != 0) {
+ printf("error: cleanup failed for test %s\n",
+ cur_test->desc);
+ continue;
+ }
+ }
}
-int
-main (void)
+int main(void)
{
- int pass_count, fail_count;
- time_t cur_time;
-
- time (&cur_time);
- printf("BGP Multipath Tests Run at %s", ctime(&cur_time));
- if (global_test_init () != 0)
- {
- printf("Global init failed. Terminating.\n");
- exit(1);
- }
- run_tests (all_tests, all_tests_count, &pass_count, &fail_count);
- global_test_cleanup ();
- printf("Total pass/fail: %d/%d\n", pass_count, fail_count);
- return fail_count;
+ int pass_count, fail_count;
+ time_t cur_time;
+
+ time(&cur_time);
+ printf("BGP Multipath Tests Run at %s", ctime(&cur_time));
+ if (global_test_init() != 0) {
+ printf("Global init failed. Terminating.\n");
+ exit(1);
+ }
+ run_tests(all_tests, all_tests_count, &pass_count, &fail_count);
+ global_test_cleanup();
+ printf("Total pass/fail: %d/%d\n", pass_count, fail_count);
+ return fail_count;
}
projects / mirror_frr.git / blobdiff