[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 Quagga; see the file COPYING.  If not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, 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"

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

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

/*=========================================================
 * 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_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_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_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_info_mpath_update
 */

struct bgp_node test_rn;

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

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

static int cleanup_bgp_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_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,
};

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();
	zclient = zclient_new(master);
	bgp_master_init(master);
	vrf_init();
	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	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with Quagga; see the file COPYING. If not, write to the Free
	19	* Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
	20	* 02111-1307, USA.
	21	*/
	22
	23	#include <zebra.h>
	24
1bf9f027	25	#include "qobj.h"
42ea6851 JB	26	#include "vty.h"
	27	#include "stream.h"
	28	#include "privs.h"
	29	#include "linklist.h"
	30	#include "memory.h"
	31	#include "zclient.h"
3f9c7369	32	#include "queue.h"
039f3a34	33	#include "filter.h"
42ea6851 JB	34
42ea6851 JB	35	#include "bgpd/bgpd.h"
42ea6851 JB	36	#include "bgpd/bgp_table.h"
42ea6851 JB	37	#include "bgpd/bgp_route.h"
96450faf	38	#include "bgpd/bgp_attr.h"
37d361e7	39	#include "bgpd/bgp_nexthop.h"
96450faf	40	#include "bgpd/bgp_mpath.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
ac4d0be5	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__ {
ac4d0be5	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;
ac4d0be5	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 */
ac4d0be5	87	static struct bgp bgp_create_fake(as_t as, const char *name)
42ea6851	88	{
ac4d0be5	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
	107	for (afi = AFI_IP; afi < AFI_MAX; afi++)
	108	for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++) {
	109	bgp->route[afi][safi] = bgp_table_init(afi, safi);
	110	bgp->aggregate[afi][safi] = bgp_table_init(afi, safi);
	111	bgp->rib[afi][safi] = bgp_table_init(afi, safi);
	112	bgp->maxpaths[afi][safi].maxpaths_ebgp = MULTIPATH_NUM;
	113	bgp->maxpaths[afi][safi].maxpaths_ibgp = MULTIPATH_NUM;
	114	}
	115
	116	bgp_scan_init(bgp);
	117	bgp->default_local_pref = BGP_DEFAULT_LOCAL_PREF;
	118	bgp->default_holdtime = BGP_DEFAULT_HOLDTIME;
	119	bgp->default_keepalive = BGP_DEFAULT_KEEPALIVE;
	120	bgp->restart_time = BGP_DEFAULT_RESTART_TIME;
	121	bgp->stalepath_time = BGP_DEFAULT_STALEPATH_TIME;
	122
	123	bgp->as = *as;
	124
	125	if (name)
	126	bgp->name = strdup(name);
	127
	128	return bgp;
42ea6851 JB	129	}
	130
	131	/*=========================================================
	132	* Testcase for maximum-paths configuration
	133	*/
ac4d0be5	134	static int setup_bgp_cfg_maximum_paths(testcase_t *t)
42ea6851	135	{
ac4d0be5	136	as_t asn = 1;
	137	t->tmp_data = bgp_create_fake(&asn, NULL);
	138	if (!t->tmp_data)
	139	return -1;
	140	return 0;
42ea6851 JB	141	}
42ea6851 JB	142
ac4d0be5	143	static int run_bgp_cfg_maximum_paths(testcase_t *t)
42ea6851	144	{
ac4d0be5	145	afi_t afi;
	146	safi_t safi;
	147	struct bgp *bgp;
	148	int api_result;
	149	int test_result = TEST_PASSED;
	150
	151	bgp = t->tmp_data;
	152	for (afi = AFI_IP; afi < AFI_MAX; afi++)
	153	for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++) {
	154	/* test bgp_maximum_paths_set */
	155	api_result = bgp_maximum_paths_set(
	156	bgp, afi, safi, BGP_PEER_EBGP, 10, 0);
	157	EXPECT_TRUE(api_result == 0, test_result);
	158	api_result = bgp_maximum_paths_set(
	159	bgp, afi, safi, BGP_PEER_IBGP, 10, 0);
	160	EXPECT_TRUE(api_result == 0, test_result);
	161	EXPECT_TRUE(bgp->maxpaths[afi][safi].maxpaths_ebgp
	162	== 10,
	163	test_result);
	164	EXPECT_TRUE(bgp->maxpaths[afi][safi].maxpaths_ibgp
	165	== 10,
	166	test_result);
	167
	168	/* test bgp_maximum_paths_unset */
	169	api_result = bgp_maximum_paths_unset(bgp, afi, safi,
	170	BGP_PEER_EBGP);
	171	EXPECT_TRUE(api_result == 0, test_result);
	172	api_result = bgp_maximum_paths_unset(bgp, afi, safi,
	173	BGP_PEER_IBGP);
	174	EXPECT_TRUE(api_result == 0, test_result);
	175	EXPECT_TRUE((bgp->maxpaths[afi][safi].maxpaths_ebgp
	176	== MULTIPATH_NUM),
	177	test_result);
	178	EXPECT_TRUE((bgp->maxpaths[afi][safi].maxpaths_ibgp
	179	== MULTIPATH_NUM),
	180	test_result);
	181	}
	182
	183	return test_result;
42ea6851 JB	184	}
42ea6851 JB	185
ac4d0be5	186	static int cleanup_bgp_cfg_maximum_paths(testcase_t *t)
42ea6851	187	{
ac4d0be5	188	return bgp_delete((struct bgp *)t->tmp_data);
42ea6851 JB	189	}
	190
	191	testcase_t test_bgp_cfg_maximum_paths = {
ac4d0be5	192	.desc = "Test bgp maximum-paths config",
	193	.setup = setup_bgp_cfg_maximum_paths,
	194	.run = run_bgp_cfg_maximum_paths,
	195	.cleanup = cleanup_bgp_cfg_maximum_paths,
42ea6851 JB	196	};
42ea6851 JB	197
96450faf JB	198	/*=========================================================
	199	* Testcase for bgp_mp_list
	200	*/
de8d5dff	201	struct peer test_mp_list_peer[] = {
ac4d0be5	202	{.local_as = 1, .as = 2}, {.local_as = 1, .as = 2},
	203	{.local_as = 1, .as = 2}, {.local_as = 1, .as = 2},
	204	{.local_as = 1, .as = 2},
de8d5dff	205	};
ac4d0be5	206	int test_mp_list_peer_count = sizeof(test_mp_list_peer) / sizeof(struct peer);
96450faf JB	207	struct attr test_mp_list_attr[4];
96450faf JB	208	struct bgp_info test_mp_list_info[] = {
ac4d0be5	209	{.peer = &test_mp_list_peer[0], .attr = &test_mp_list_attr[0]},
	210	{.peer = &test_mp_list_peer[1], .attr = &test_mp_list_attr[1]},
	211	{.peer = &test_mp_list_peer[2], .attr = &test_mp_list_attr[1]},
	212	{.peer = &test_mp_list_peer[3], .attr = &test_mp_list_attr[2]},
	213	{.peer = &test_mp_list_peer[4], .attr = &test_mp_list_attr[3]},
96450faf JB	214	};
96450faf JB	215	int test_mp_list_info_count =
ac4d0be5	216	sizeof(test_mp_list_info) / sizeof(struct bgp_info);
96450faf	217
ac4d0be5	218	static int setup_bgp_mp_list(testcase_t *t)
96450faf	219	{
ac4d0be5	220	test_mp_list_attr[0].nexthop.s_addr = 0x01010101;
	221	test_mp_list_attr[1].nexthop.s_addr = 0x02020202;
	222	test_mp_list_attr[2].nexthop.s_addr = 0x03030303;
	223	test_mp_list_attr[3].nexthop.s_addr = 0x04040404;
	224
	225	if ((test_mp_list_peer[0].su_remote = sockunion_str2su("1.1.1.1"))
	226	== NULL)
	227	return -1;
	228	if ((test_mp_list_peer[1].su_remote = sockunion_str2su("2.2.2.2"))
	229	== NULL)
	230	return -1;
	231	if ((test_mp_list_peer[2].su_remote = sockunion_str2su("3.3.3.3"))
	232	== NULL)
	233	return -1;
	234	if ((test_mp_list_peer[3].su_remote = sockunion_str2su("4.4.4.4"))
	235	== NULL)
	236	return -1;
	237	if ((test_mp_list_peer[4].su_remote = sockunion_str2su("5.5.5.5"))
	238	== NULL)
	239	return -1;
	240
	241	return 0;
96450faf JB	242	}
96450faf JB	243
ac4d0be5	244	static int run_bgp_mp_list(testcase_t *t)
96450faf	245	{
ac4d0be5	246	struct list mp_list;
	247	struct listnode *mp_node;
	248	struct bgp_info *info;
	249	int i;
	250	int test_result = TEST_PASSED;
	251	bgp_mp_list_init(&mp_list);
	252	EXPECT_TRUE(listcount(&mp_list) == 0, test_result);
	253
	254	bgp_mp_list_add(&mp_list, &test_mp_list_info[1]);
	255	bgp_mp_list_add(&mp_list, &test_mp_list_info[4]);
	256	bgp_mp_list_add(&mp_list, &test_mp_list_info[2]);
	257	bgp_mp_list_add(&mp_list, &test_mp_list_info[3]);
	258	bgp_mp_list_add(&mp_list, &test_mp_list_info[0]);
	259
	260	for (i = 0, mp_node = mp_list.head; i < test_mp_list_info_count;
	261	i++, mp_node = listnextnode(mp_node)) {
	262	info = listgetdata(mp_node);
	263	EXPECT_TRUE(info == &test_mp_list_info[i], test_result);
	264	}
	265
	266	bgp_mp_list_clear(&mp_list);
	267	EXPECT_TRUE(listcount(&mp_list) == 0, test_result);
	268
	269	return test_result;
96450faf JB	270	}
96450faf JB	271
ac4d0be5	272	static int cleanup_bgp_mp_list(testcase_t *t)
96450faf	273	{
ac4d0be5	274	int i;
96450faf	275
ac4d0be5	276	for (i = 0; i < test_mp_list_peer_count; i++)
ac4d0be5	277	sockunion_free(test_mp_list_peer[i].su_remote);
96450faf	278
ac4d0be5	279	return 0;
96450faf JB	280	}
	281
	282	testcase_t test_bgp_mp_list = {
ac4d0be5	283	.desc = "Test bgp_mp_list",
	284	.setup = setup_bgp_mp_list,
	285	.run = run_bgp_mp_list,
	286	.cleanup = cleanup_bgp_mp_list,
96450faf JB	287	};
96450faf JB	288
de8d5dff JB	289	/*=========================================================
	290	* Testcase for bgp_info_mpath_update
	291	*/
	292
	293	struct bgp_node test_rn;
	294
ac4d0be5	295	static int setup_bgp_info_mpath_update(testcase_t *t)
de8d5dff	296	{
ac4d0be5	297	int i;
	298	str2prefix("42.1.1.0/24", &test_rn.p);
	299	setup_bgp_mp_list(t);
	300	for (i = 0; i < test_mp_list_info_count; i++)
	301	bgp_info_add(&test_rn, &test_mp_list_info[i]);
	302	return 0;
de8d5dff JB	303	}
de8d5dff JB	304
ac4d0be5	305	static int run_bgp_info_mpath_update(testcase_t *t)
de8d5dff	306	{
ac4d0be5	307	struct bgp_info new_best, old_best, *mpath;
	308	struct list mp_list;
	309	struct bgp_maxpaths_cfg mp_cfg = {3, 3};
	310	int test_result = TEST_PASSED;
	311	bgp_mp_list_init(&mp_list);
	312	bgp_mp_list_add(&mp_list, &test_mp_list_info[4]);
	313	bgp_mp_list_add(&mp_list, &test_mp_list_info[3]);
	314	bgp_mp_list_add(&mp_list, &test_mp_list_info[0]);
	315	bgp_mp_list_add(&mp_list, &test_mp_list_info[1]);
	316	new_best = &test_mp_list_info[3];
	317	old_best = NULL;
	318	bgp_info_mpath_update(&test_rn, new_best, old_best, &mp_list, &mp_cfg);
	319	bgp_mp_list_clear(&mp_list);
	320	EXPECT_TRUE(bgp_info_mpath_count(new_best) == 2, test_result);
	321	mpath = bgp_info_mpath_first(new_best);
	322	EXPECT_TRUE(mpath == &test_mp_list_info[0], test_result);
	323	EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_INFO_MULTIPATH), test_result);
	324	mpath = bgp_info_mpath_next(mpath);
	325	EXPECT_TRUE(mpath == &test_mp_list_info[1], test_result);
	326	EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_INFO_MULTIPATH), test_result);
	327
	328	bgp_mp_list_add(&mp_list, &test_mp_list_info[0]);
	329	bgp_mp_list_add(&mp_list, &test_mp_list_info[1]);
	330	new_best = &test_mp_list_info[0];
	331	old_best = &test_mp_list_info[3];
	332	bgp_info_mpath_update(&test_rn, new_best, old_best, &mp_list, &mp_cfg);
	333	bgp_mp_list_clear(&mp_list);
	334	EXPECT_TRUE(bgp_info_mpath_count(new_best) == 1, test_result);
	335	mpath = bgp_info_mpath_first(new_best);
	336	EXPECT_TRUE(mpath == &test_mp_list_info[1], test_result);
	337	EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_INFO_MULTIPATH), test_result);
	338	EXPECT_TRUE(!CHECK_FLAG(test_mp_list_info[0].flags, BGP_INFO_MULTIPATH),
	339	test_result);
	340
	341	return test_result;
de8d5dff JB	342	}
de8d5dff JB	343
ac4d0be5	344	static int cleanup_bgp_info_mpath_update(testcase_t *t)
de8d5dff	345	{
ac4d0be5	346	int i;
de8d5dff	347
ac4d0be5	348	for (i = 0; i < test_mp_list_peer_count; i++)
ac4d0be5	349	sockunion_free(test_mp_list_peer[i].su_remote);
de8d5dff	350
ac4d0be5	351	return 0;
de8d5dff JB	352	}
	353
	354	testcase_t test_bgp_info_mpath_update = {
ac4d0be5	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,
de8d5dff JB	359	};
de8d5dff JB	360
42ea6851 JB	361	/*=========================================================
	362	* Set up testcase vector
	363	*/
	364	testcase_t *all_tests[] = {
ac4d0be5	365	&test_bgp_cfg_maximum_paths, &test_bgp_mp_list,
ac4d0be5	366	&test_bgp_info_mpath_update,
42ea6851 JB	367	};
42ea6851 JB	368
ac4d0be5	369	int all_tests_count = (sizeof(all_tests) / sizeof(testcase_t *));
42ea6851 JB	370
	371	/*=========================================================
	372	* Test Driver Functions
	373	*/
ac4d0be5	374	static int global_test_init(void)
42ea6851	375	{
ac4d0be5	376	qobj_init();
	377	master = thread_master_create();
	378	zclient = zclient_new(master);
	379	bgp_master_init(master);
	380	vrf_init();
	381	bgp_option_set(BGP_OPT_NO_LISTEN);
	382
	383	if (fileno(stdout) >= 0)
	384	tty = isatty(fileno(stdout));
	385	return 0;
42ea6851 JB	386	}
42ea6851 JB	387
ac4d0be5	388	static int global_test_cleanup(void)
42ea6851	389	{
ac4d0be5	390	if (zclient != NULL)
	391	zclient_free(zclient);
	392	thread_master_free(master);
	393	return 0;
42ea6851 JB	394	}
42ea6851 JB	395
ac4d0be5	396	static void display_result(testcase_t *test, int result)
42ea6851	397	{
ac4d0be5	398	if (tty)
	399	printf("%s: %s\n", test->desc,
	400	result == TEST_PASSED ? OK : FAILED);
	401	else
	402	printf("%s: %s\n", test->desc,
	403	result == TEST_PASSED ? "OK" : "FAILED");
42ea6851 JB	404	}
42ea6851 JB	405
ac4d0be5	406	static int setup_test(testcase_t *t)
42ea6851	407	{
ac4d0be5	408	int res = 0;
	409	if (t->setup)
	410	res = t->setup(t);
	411	return res;
42ea6851 JB	412	}
42ea6851 JB	413
ac4d0be5	414	static int cleanup_test(testcase_t *t)
42ea6851	415	{
ac4d0be5	416	int res = 0;
	417	if (t->cleanup)
	418	res = t->cleanup(t);
	419	return res;
42ea6851 JB	420	}
42ea6851 JB	421
ac4d0be5	422	static void run_tests(testcase_t tests[], int num_tests, int pass_count,
ac4d0be5	423	int *fail_count)
42ea6851	424	{
ac4d0be5	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	cur_test = tests[test_index];
	432	if (!cur_test->desc) {
	433	printf("error: test %d has no description!\n",
	434	test_index);
	435	continue;
	436	}
	437	if (!cur_test->run) {
	438	printf("error: test %s has no run function!\n",
	439	cur_test->desc);
	440	continue;
	441	}
	442	if (setup_test(cur_test) != 0) {
	443	printf("error: setup failed for test %s\n",
	444	cur_test->desc);
	445	continue;
	446	}
	447	result = cur_test->run(cur_test);
	448	if (result == TEST_PASSED)
	449	*pass_count += 1;
	450	else
	451	*fail_count += 1;
	452	display_result(cur_test, result);
	453	if (cleanup_test(cur_test) != 0) {
	454	printf("error: cleanup failed for test %s\n",
	455	cur_test->desc);
	456	continue;
	457	}
	458	}
42ea6851 JB	459	}
42ea6851 JB	460
ac4d0be5	461	int main(void)
42ea6851	462	{
ac4d0be5	463	int pass_count, fail_count;
	464	time_t cur_time;
	465
	466	time(&cur_time);
	467	printf("BGP Multipath Tests Run at %s", ctime(&cur_time));
	468	if (global_test_init() != 0) {
	469	printf("Global init failed. Terminating.\n");
	470	exit(1);
	471	}
	472	run_tests(all_tests, all_tests_count, &pass_count, &fail_count);
	473	global_test_cleanup();
	474	printf("Total pass/fail: %d/%d\n", pass_count, fail_count);
	475	return fail_count;
42ea6851	476	}