[mirror_frr.git] / tests / bgpd / test_mpath.c

/*
 * BGP Multipath Unit Test
 * Copyright (C) 2010 Google Inc.
 *
 * This file is part of Quagga
 *
 * Quagga is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * Quagga is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <zebra.h>

#include "qobj.h"
#include "vty.h"
#include "stream.h"
#include "privs.h"
#include "linklist.h"
#include "memory.h"
#include "zclient.h"
#include "queue.h"
#include "filter.h"

#include "bgpd/bgpd.h"
#include "bgpd/bgp_table.h"
#include "bgpd/bgp_route.h"
#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 VT100_GREEN "\x1b[32m"
#define VT100_YELLOW "\x1b[33m"
#define OK VT100_GREEN "OK" VT100_RESET
#define FAILED VT100_RED "failed" VT100_RESET

#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;                                           \
	}

typedef struct testcase_t__ testcase_t;

typedef int (*test_setup_func)(testcase_t *);
typedef int (*test_run_func)(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;
};

/* 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,
};

static int tty = 0;

/* Create fake bgp instance */
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;

	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)
{
	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)
{
	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)
{
	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,
};

/*=========================================================
 * 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},
};
int test_mp_list_peer_count = sizeof(test_mp_list_peer) / sizeof(struct peer);
struct attr test_mp_list_attr[4];
struct bgp_path_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]},
};
int test_mp_list_info_count =
	sizeof(test_mp_list_info) / sizeof(struct bgp_path_info);

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;
}

static int run_bgp_mp_list(testcase_t *t)
{
	struct list mp_list;
	struct listnode *mp_node;
	struct bgp_path_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)
{
	int i;

	for (i = 0; i < test_mp_list_peer_count; i++)
		sockunion_free(test_mp_list_peer[i].su_remote);

	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,
};

/*=========================================================
 * Testcase for bgp_path_info_mpath_update
 */

struct bgp_node test_rn;

static int setup_bgp_path_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_path_info_add(&test_rn, &test_mp_list_info[i]);
	return 0;
}

static int run_bgp_path_info_mpath_update(testcase_t *t)
{
	struct bgp_path_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_path_info_mpath_update(&test_rn, new_best, old_best, &mp_list,
				   &mp_cfg);
	bgp_mp_list_clear(&mp_list);
	EXPECT_TRUE(bgp_path_info_mpath_count(new_best) == 2, test_result);
	mpath = bgp_path_info_mpath_first(new_best);
	EXPECT_TRUE(mpath == &test_mp_list_info[0], test_result);
	EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_PATH_MULTIPATH), test_result);
	mpath = bgp_path_info_mpath_next(mpath);
	EXPECT_TRUE(mpath == &test_mp_list_info[1], test_result);
	EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_PATH_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_path_info_mpath_update(&test_rn, new_best, old_best, &mp_list,
				   &mp_cfg);
	bgp_mp_list_clear(&mp_list);
	EXPECT_TRUE(bgp_path_info_mpath_count(new_best) == 1, test_result);
	mpath = bgp_path_info_mpath_first(new_best);
	EXPECT_TRUE(mpath == &test_mp_list_info[1], test_result);
	EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_PATH_MULTIPATH), test_result);
	EXPECT_TRUE(!CHECK_FLAG(test_mp_list_info[0].flags, BGP_PATH_MULTIPATH),
		    test_result);

	return test_result;
}

static int cleanup_bgp_path_info_mpath_update(testcase_t *t)
{
	int i;

	for (i = 0; i < test_mp_list_peer_count; i++)
		sockunion_free(test_mp_list_peer[i].su_remote);

	return 0;
}

testcase_t test_bgp_path_info_mpath_update = {
	.desc = "Test bgp_path_info_mpath_update",
	.setup = setup_bgp_path_info_mpath_update,
	.run = run_bgp_path_info_mpath_update,
	.cleanup = cleanup_bgp_path_info_mpath_update,
};

/*=========================================================
 * Set up testcase vector
 */
testcase_t *all_tests[] = {
	&test_bgp_cfg_maximum_paths, &test_bgp_mp_list,
	&test_bgp_path_info_mpath_update,
};

int all_tests_count = (sizeof(all_tests) / sizeof(testcase_t *));

/*=========================================================
 * Test Driver Functions
 */
static int global_test_init(void)
{
	qobj_init();
	master = thread_master_create(NULL);
	zclient = zclient_new(master, &zclient_options_default);
	bgp_master_init(master);
	vrf_init(NULL, 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)
{
	if (zclient != NULL)
		zclient_free(zclient);
	thread_master_free(master);
	return 0;
}

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");
}

static int setup_test(testcase_t *t)
{
	int res = 0;
	if (t->setup)
		res = t->setup(t);
	return res;
}

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