[mirror_frr.git] / tests / bgp_mpath_test.c

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