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

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * BGP Multipath Unit Test
 * Copyright (C) 2010 Google Inc.
 *
 * This file is part of Quagga
 */

#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"
#include "bgpd/bgp_network.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", __func__, __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;
extern 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);
	FOREACH_AFI_SAFI (afi, 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;
	FOREACH_AFI_SAFI (afi, 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 = array_size(test_mp_list_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 = array_size(test_mp_list_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;
	struct bgp *bgp;
	struct bgp_table *rt;
	struct route_node *rt_node;
	as_t asn = 1;

	t->tmp_data = bgp_create_fake(&asn, NULL);
	if (!t->tmp_data)
		return -1;

	bgp = t->tmp_data;
	rt = bgp->rib[AFI_IP][SAFI_UNICAST];

	if (!rt)
		return -1;

	str2prefix("42.1.1.0/24", &test_rn.p);
	rt_node = bgp_dest_to_rnode(&test_rn);
	memcpy((struct route_table *)&rt_node->table, &rt->route_table,
	       sizeof(struct route_table));
	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(NULL, &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(NULL, &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 bgp_delete((struct bgp *)t->tmp_data);
}

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 = array_size(all_tests);

/*=========================================================
 * Test Driver Functions
 */
static int global_test_init(void)
{
	qobj_init();
	master = thread_master_create(NULL);
	zclient = zclient_new(master, &zclient_options_default, NULL, 0);
	bgp_master_init(master, BGP_SOCKET_SNDBUF_SIZE, list_new());
	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)
{
	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
acddc0ed	1	// SPDX-License-Identifier: GPL-2.0-or-later
8ef0791c	2	/*
42ea6851 JB	3	* BGP Multipath Unit Test
	4	* Copyright (C) 2010 Google Inc.
	5	*
	6	* This file is part of Quagga
42ea6851 JB	7	*/
	8
	9	#include <zebra.h>
	10
1bf9f027	11	#include "qobj.h"
42ea6851 JB	12	#include "vty.h"
	13	#include "stream.h"
	14	#include "privs.h"
	15	#include "linklist.h"
	16	#include "memory.h"
	17	#include "zclient.h"
3f9c7369	18	#include "queue.h"
039f3a34	19	#include "filter.h"
42ea6851 JB	20
42ea6851 JB	21	#include "bgpd/bgpd.h"
42ea6851 JB	22	#include "bgpd/bgp_table.h"
42ea6851 JB	23	#include "bgpd/bgp_route.h"
96450faf	24	#include "bgpd/bgp_attr.h"
37d361e7	25	#include "bgpd/bgp_nexthop.h"
96450faf	26	#include "bgpd/bgp_mpath.h"
1525e99f	27	#include "bgpd/bgp_evpn.h"
c2d020ad	28	#include "bgpd/bgp_network.h"
42ea6851 JB	29
	30	#define VT100_RESET "\x1b[0m"
	31	#define VT100_RED "\x1b[31m"
	32	#define VT100_GREEN "\x1b[32m"
	33	#define VT100_YELLOW "\x1b[33m"
	34	#define OK VT100_GREEN "OK" VT100_RESET
	35	#define FAILED VT100_RED "failed" VT100_RESET
	36
	37	#define TEST_PASSED 0
	38	#define TEST_FAILED -1
	39
d62a17ae	40	#define EXPECT_TRUE(expr, res) \
d62a17ae	41	if (!(expr)) { \
15569c58 DA	42	printf("Test failure in %s line %u: %s\n", __func__, __LINE__, \
15569c58 DA	43	#expr); \
d62a17ae	44	(res) = TEST_FAILED; \
d62a17ae	45	}
42ea6851 JB	46
	47	typedef struct testcase_t__ testcase_t;
	48
	49	typedef int (test_setup_func)(testcase_t );
	50	typedef int (test_run_func)(testcase_t );
	51	typedef int (test_cleanup_func)(testcase_t );
	52
	53	struct testcase_t__ {
d62a17ae	54	const char *desc;
	55	void *test_data;
	56	void *verify_data;
	57	void *tmp_data;
	58	test_setup_func setup;
	59	test_run_func run;
	60	test_cleanup_func cleanup;
42ea6851 JB	61	};
	62
	63	/* need these to link in libbgp */
	64	struct thread_master *master = NULL;
9635de6e	65	extern struct zclient *zclient;
d62a17ae	66	struct zebra_privs_t bgpd_privs = {
	67	.user = NULL,
	68	.group = NULL,
	69	.vty_group = NULL,
42ea6851 JB	70	};
	71
	72	static int tty = 0;
	73
	74	/* Create fake bgp instance */
d62a17ae	75	static struct bgp bgp_create_fake(as_t as, const char *name)
42ea6851	76	{
d62a17ae	77	struct bgp *bgp;
	78	afi_t afi;
	79	safi_t safi;
	80
	81	if ((bgp = XCALLOC(MTYPE_BGP, sizeof(struct bgp))) == NULL)
	82	return NULL;
	83
	84	bgp_lock(bgp);
	85	// bgp->peer_self = peer_new (bgp);
	86	// bgp->peer_self->host = XSTRDUP (MTYPE_BGP_PEER_HOST, "Static
	87	// announcement");
	88
	89	bgp->peer = list_new();
	90	// bgp->peer->cmp = (int ()(void , void *)) peer_cmp;
	91
	92	bgp->group = list_new();
	93	// bgp->group->cmp = (int ()(void , void *)) peer_group_cmp;
	94
1525e99f	95	bgp_evpn_init(bgp);
f18ba3cd DS	96	FOREACH_AFI_SAFI (afi, safi) {
	97	bgp->route[afi][safi] = bgp_table_init(bgp, afi, safi);
	98	bgp->aggregate[afi][safi] = bgp_table_init(bgp, afi, safi);
	99	bgp->rib[afi][safi] = bgp_table_init(bgp, afi, safi);
	100	bgp->maxpaths[afi][safi].maxpaths_ebgp = MULTIPATH_NUM;
	101	bgp->maxpaths[afi][safi].maxpaths_ibgp = MULTIPATH_NUM;
	102	}
d62a17ae	103
	104	bgp_scan_init(bgp);
	105	bgp->default_local_pref = BGP_DEFAULT_LOCAL_PREF;
	106	bgp->default_holdtime = BGP_DEFAULT_HOLDTIME;
	107	bgp->default_keepalive = BGP_DEFAULT_KEEPALIVE;
	108	bgp->restart_time = BGP_DEFAULT_RESTART_TIME;
	109	bgp->stalepath_time = BGP_DEFAULT_STALEPATH_TIME;
	110
	111	bgp->as = *as;
	112
	113	if (name)
	114	bgp->name = strdup(name);
	115
	116	return bgp;
42ea6851 JB	117	}
	118
	119	/*=========================================================
	120	* Testcase for maximum-paths configuration
	121	*/
d62a17ae	122	static int setup_bgp_cfg_maximum_paths(testcase_t *t)
42ea6851	123	{
d62a17ae	124	as_t asn = 1;
	125	t->tmp_data = bgp_create_fake(&asn, NULL);
	126	if (!t->tmp_data)
	127	return -1;
	128	return 0;
42ea6851 JB	129	}
42ea6851 JB	130
d62a17ae	131	static int run_bgp_cfg_maximum_paths(testcase_t *t)
42ea6851	132	{
d62a17ae	133	afi_t afi;
	134	safi_t safi;
	135	struct bgp *bgp;
	136	int api_result;
	137	int test_result = TEST_PASSED;
	138
	139	bgp = t->tmp_data;
f18ba3cd DS	140	FOREACH_AFI_SAFI (afi, safi) {
	141	/* test bgp_maximum_paths_set */
	142	api_result = bgp_maximum_paths_set(bgp, afi, safi,
	143	BGP_PEER_EBGP, 10, 0);
	144	EXPECT_TRUE(api_result == 0, test_result);
	145	api_result = bgp_maximum_paths_set(bgp, afi, safi,
	146	BGP_PEER_IBGP, 10, 0);
	147	EXPECT_TRUE(api_result == 0, test_result);
	148	EXPECT_TRUE(bgp->maxpaths[afi][safi].maxpaths_ebgp == 10,
	149	test_result);
	150	EXPECT_TRUE(bgp->maxpaths[afi][safi].maxpaths_ibgp == 10,
	151	test_result);
	152
	153	/* test bgp_maximum_paths_unset */
	154	api_result =
	155	bgp_maximum_paths_unset(bgp, afi, safi, BGP_PEER_EBGP);
	156	EXPECT_TRUE(api_result == 0, test_result);
	157	api_result =
	158	bgp_maximum_paths_unset(bgp, afi, safi, BGP_PEER_IBGP);
	159	EXPECT_TRUE(api_result == 0, test_result);
	160	EXPECT_TRUE((bgp->maxpaths[afi][safi].maxpaths_ebgp
	161	== MULTIPATH_NUM),
	162	test_result);
	163	EXPECT_TRUE((bgp->maxpaths[afi][safi].maxpaths_ibgp
	164	== MULTIPATH_NUM),
	165	test_result);
	166	}
d62a17ae	167
d62a17ae	168	return test_result;
42ea6851 JB	169	}
42ea6851 JB	170
d62a17ae	171	static int cleanup_bgp_cfg_maximum_paths(testcase_t *t)
42ea6851	172	{
d62a17ae	173	return bgp_delete((struct bgp *)t->tmp_data);
42ea6851 JB	174	}
	175
	176	testcase_t test_bgp_cfg_maximum_paths = {
d62a17ae	177	.desc = "Test bgp maximum-paths config",
	178	.setup = setup_bgp_cfg_maximum_paths,
	179	.run = run_bgp_cfg_maximum_paths,
	180	.cleanup = cleanup_bgp_cfg_maximum_paths,
42ea6851 JB	181	};
42ea6851 JB	182
96450faf JB	183	/*=========================================================
	184	* Testcase for bgp_mp_list
	185	*/
de8d5dff	186	struct peer test_mp_list_peer[] = {
d62a17ae	187	{.local_as = 1, .as = 2}, {.local_as = 1, .as = 2},
	188	{.local_as = 1, .as = 2}, {.local_as = 1, .as = 2},
	189	{.local_as = 1, .as = 2},
de8d5dff	190	};
97b5d752	191	int test_mp_list_peer_count = array_size(test_mp_list_peer);
96450faf	192	struct attr test_mp_list_attr[4];
4b7e6066	193	struct bgp_path_info test_mp_list_info[] = {
d62a17ae	194	{.peer = &test_mp_list_peer[0], .attr = &test_mp_list_attr[0]},
	195	{.peer = &test_mp_list_peer[1], .attr = &test_mp_list_attr[1]},
	196	{.peer = &test_mp_list_peer[2], .attr = &test_mp_list_attr[1]},
	197	{.peer = &test_mp_list_peer[3], .attr = &test_mp_list_attr[2]},
	198	{.peer = &test_mp_list_peer[4], .attr = &test_mp_list_attr[3]},
96450faf	199	};
97b5d752	200	int test_mp_list_info_count = array_size(test_mp_list_info);
96450faf	201
d62a17ae	202	static int setup_bgp_mp_list(testcase_t *t)
96450faf	203	{
d62a17ae	204	test_mp_list_attr[0].nexthop.s_addr = 0x01010101;
	205	test_mp_list_attr[1].nexthop.s_addr = 0x02020202;
	206	test_mp_list_attr[2].nexthop.s_addr = 0x03030303;
	207	test_mp_list_attr[3].nexthop.s_addr = 0x04040404;
	208
	209	if ((test_mp_list_peer[0].su_remote = sockunion_str2su("1.1.1.1"))
	210	== NULL)
	211	return -1;
	212	if ((test_mp_list_peer[1].su_remote = sockunion_str2su("2.2.2.2"))
	213	== NULL)
	214	return -1;
	215	if ((test_mp_list_peer[2].su_remote = sockunion_str2su("3.3.3.3"))
	216	== NULL)
	217	return -1;
	218	if ((test_mp_list_peer[3].su_remote = sockunion_str2su("4.4.4.4"))
	219	== NULL)
	220	return -1;
	221	if ((test_mp_list_peer[4].su_remote = sockunion_str2su("5.5.5.5"))
	222	== NULL)
	223	return -1;
	224
	225	return 0;
96450faf JB	226	}
96450faf JB	227
d62a17ae	228	static int run_bgp_mp_list(testcase_t *t)
96450faf	229	{
d62a17ae	230	struct list mp_list;
d62a17ae	231	struct listnode *mp_node;
4b7e6066	232	struct bgp_path_info *info;
d62a17ae	233	int i;
	234	int test_result = TEST_PASSED;
	235	bgp_mp_list_init(&mp_list);
	236	EXPECT_TRUE(listcount(&mp_list) == 0, test_result);
	237
	238	bgp_mp_list_add(&mp_list, &test_mp_list_info[1]);
	239	bgp_mp_list_add(&mp_list, &test_mp_list_info[4]);
	240	bgp_mp_list_add(&mp_list, &test_mp_list_info[2]);
	241	bgp_mp_list_add(&mp_list, &test_mp_list_info[3]);
	242	bgp_mp_list_add(&mp_list, &test_mp_list_info[0]);
	243
	244	for (i = 0, mp_node = mp_list.head; i < test_mp_list_info_count;
	245	i++, mp_node = listnextnode(mp_node)) {
	246	info = listgetdata(mp_node);
	247	EXPECT_TRUE(info == &test_mp_list_info[i], test_result);
	248	}
	249
	250	bgp_mp_list_clear(&mp_list);
	251	EXPECT_TRUE(listcount(&mp_list) == 0, test_result);
	252
	253	return test_result;
96450faf JB	254	}
96450faf JB	255
d62a17ae	256	static int cleanup_bgp_mp_list(testcase_t *t)
96450faf	257	{
d62a17ae	258	int i;
96450faf	259
d62a17ae	260	for (i = 0; i < test_mp_list_peer_count; i++)
d62a17ae	261	sockunion_free(test_mp_list_peer[i].su_remote);
96450faf	262
d62a17ae	263	return 0;
96450faf JB	264	}
	265
	266	testcase_t test_bgp_mp_list = {
d62a17ae	267	.desc = "Test bgp_mp_list",
	268	.setup = setup_bgp_mp_list,
	269	.run = run_bgp_mp_list,
	270	.cleanup = cleanup_bgp_mp_list,
96450faf JB	271	};
96450faf JB	272
de8d5dff	273	/*=========================================================
4b7e6066	274	* Testcase for bgp_path_info_mpath_update
de8d5dff JB	275	*/
	276
	277	struct bgp_node test_rn;
	278
4b7e6066	279	static int setup_bgp_path_info_mpath_update(testcase_t *t)
de8d5dff	280	{
d62a17ae	281	int i;
f009ff26	282	struct bgp *bgp;
	283	struct bgp_table *rt;
	284	struct route_node *rt_node;
	285	as_t asn = 1;
	286
	287	t->tmp_data = bgp_create_fake(&asn, NULL);
	288	if (!t->tmp_data)
	289	return -1;
	290
	291	bgp = t->tmp_data;
	292	rt = bgp->rib[AFI_IP][SAFI_UNICAST];
	293
	294	if (!rt)
	295	return -1;
	296
d62a17ae	297	str2prefix("42.1.1.0/24", &test_rn.p);
9bcb3eef	298	rt_node = bgp_dest_to_rnode(&test_rn);
f009ff26	299	memcpy((struct route_table *)&rt_node->table, &rt->route_table,
6aed8082	300	sizeof(struct route_table));
d62a17ae	301	setup_bgp_mp_list(t);
d62a17ae	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;
4378495a	320	bgp_path_info_mpath_update(NULL, &test_rn, new_best, old_best, &mp_list,
121e245d	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];
4378495a	335	bgp_path_info_mpath_update(NULL, &test_rn, new_best, old_best, &mp_list,
121e245d	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
f009ff26	355	return bgp_delete((struct bgp *)t->tmp_data);
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
97b5d752	373	int all_tests_count = array_size(all_tests);
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);
a243d1db	382	zclient = zclient_new(master, &zclient_options_default, NULL, 0);
733367c0	383	bgp_master_init(master, BGP_SOCKET_SNDBUF_SIZE, list_new());
ac2cb9bf	384	vrf_init(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	}