mirror of
https://github.com/RIOT-OS/RIOT.git
synced 2024-12-29 04:50:03 +01:00
732 lines
28 KiB
C
732 lines
28 KiB
C
/*
|
|
* Copyright (C) 2015 Martin Landsmann
|
|
*
|
|
* This file is subject to the terms and conditions of the GNU Lesser
|
|
* General Public License v2.1. See the file LICENSE in the top level
|
|
* directory for more details.
|
|
*/
|
|
|
|
#include <stdio.h> /**< required for snprintf() */
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include "embUnit.h"
|
|
#include "tests-fib_sr.h"
|
|
|
|
#include "thread.h"
|
|
#include "net/fib.h"
|
|
#include "universal_address.h"
|
|
|
|
/**
|
|
* @brief maximum number of source routes
|
|
*/
|
|
#define TEST_MAX_FIB_SR (20)
|
|
|
|
/**
|
|
* @brief maximum number of entries in all source routes
|
|
*/
|
|
#define TEST_MAX_FIB_SR_ENTRIES (TEST_MAX_FIB_SR * 20)
|
|
|
|
/**
|
|
* @brief the FIB source route headers
|
|
*/
|
|
static fib_sr_t _sr_headers[TEST_MAX_FIB_SR];
|
|
|
|
/**
|
|
* @brief the FIB source route table entries pool
|
|
*/
|
|
static fib_sr_entry_t _sr_datapool[TEST_MAX_FIB_SR_ENTRIES];
|
|
|
|
/**
|
|
* @brief the FIB source route table "glue container"
|
|
*/
|
|
static fib_sr_meta_t _entries_sr = { .headers = _sr_headers,
|
|
.entry_pool = _sr_datapool,
|
|
.entry_pool_size = TEST_MAX_FIB_SR_ENTRIES };
|
|
|
|
/**
|
|
* @brief the FIB source route table
|
|
* @note is initialized in the entry function of this unittest
|
|
*/
|
|
static fib_table_t test_fib_sr_table;
|
|
|
|
/*
|
|
* @brief helper function to create source routes.
|
|
* The entries are constructed with the given prefix and numbers
|
|
* counted from the given count borders (from and to).
|
|
* @param[in] pre prefix string to use
|
|
* @param[in] from starting index to count from
|
|
* @param[in] to last index to count to
|
|
* @param[in] sr the source route to append the created entries
|
|
* @param[in] buf_size the size in bytes for each address to be created
|
|
*/
|
|
static int _create_sr(const char *pre, size_t from, size_t to, fib_sr_t *sr, size_t buf_size)
|
|
{
|
|
char addr_nxt[buf_size];
|
|
|
|
strncpy(addr_nxt, pre, strlen(pre));
|
|
|
|
for (size_t i = from; i < to; ++i) {
|
|
int res;
|
|
snprintf(&(addr_nxt[strlen(pre)]), buf_size, "%" PRIuSIZE, i);
|
|
/* append a hop */
|
|
res = fib_sr_entry_append(&test_fib_sr_table, sr, (uint8_t *)&addr_nxt, buf_size);
|
|
if (res != 0) {
|
|
return res;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* @brief create a new empty source route and check the parameters
|
|
* It is expected to have a new source route with the given parameters
|
|
*/
|
|
static void test_fib_sr_01_create_empty_sr(void)
|
|
{
|
|
fib_sr_t *local_sourceroutes[1];
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
|
|
42, 0x0, 10000));
|
|
|
|
kernel_pid_t sr_iface_id;
|
|
uint32_t sr_flags;
|
|
uint32_t sr_lifetime;
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_read_head(&test_fib_sr_table, local_sourceroutes[0],
|
|
&sr_iface_id, &sr_flags,
|
|
&sr_lifetime)
|
|
);
|
|
|
|
TEST_ASSERT_EQUAL_INT(42, sr_iface_id);
|
|
TEST_ASSERT_EQUAL_INT(0x0, sr_flags);
|
|
|
|
/* the lifetime should decrease
|
|
* Since the FIB uses timex under the hood which has a finer grained resolution
|
|
* testing the lifetime requires to active wait a bit, say 5 ms.
|
|
* Uncomment the following two lines if you want to test the temporal behaviour
|
|
* @note this may fail since unittests are currently not thread-friendly
|
|
*/
|
|
//xtimer_msleep(5);
|
|
//TEST_ASSERT(sr_lifetime<10000);
|
|
|
|
fib_deinit(&test_fib_sr_table);
|
|
}
|
|
|
|
/*
|
|
* @brief create a new empty source route, change its parameters
|
|
* and check the change
|
|
* It is expected to have a new source route with the given adjusted parameters
|
|
*/
|
|
static void test_fib_sr_02_change_sr_parameters(void)
|
|
{
|
|
fib_sr_t *local_sourceroutes[1];
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
|
|
42, 0x0, 10000));
|
|
|
|
/* Case 01 - re-set all parameters */
|
|
kernel_pid_t sr_iface_id = 43;
|
|
uint32_t sr_flags = 0x99;
|
|
uint32_t sr_lifetime = 20000;
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_set(&test_fib_sr_table, local_sourceroutes[0],
|
|
&sr_iface_id, &sr_flags, &sr_lifetime));
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_read_head(&test_fib_sr_table, local_sourceroutes[0],
|
|
&sr_iface_id, &sr_flags,
|
|
&sr_lifetime)
|
|
);
|
|
|
|
TEST_ASSERT_EQUAL_INT(43, sr_iface_id);
|
|
TEST_ASSERT_EQUAL_INT(0x99, sr_flags);
|
|
|
|
/* the lifetime should be slightly below 20000
|
|
* Since the FIB uses timex under the hood which has a finer grained resolution
|
|
* testing the lifetime requires to active wait a bit, say 5 ms.
|
|
* Uncomment the following three lines if you want to test the temporal behaviour
|
|
* @note this may fail since unittests are currently not thread-friendly
|
|
*/
|
|
//xtimer_msleep(5);
|
|
//TEST_ASSERT(sr_lifetime>10000);
|
|
//TEST_ASSERT(sr_lifetime<20000);
|
|
|
|
fib_deinit(&test_fib_sr_table);
|
|
}
|
|
|
|
/*
|
|
* @brief check errors on reading sr parameters and trying to access an expired sr
|
|
*/
|
|
static void test_fib_sr_03_read_sr_parameters(void)
|
|
{
|
|
fib_sr_t *local_sourceroutes[1];
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
|
|
42, 0x0, 10000));
|
|
|
|
kernel_pid_t sr_iface_id;
|
|
uint32_t sr_flags;
|
|
uint32_t sr_lifetime;
|
|
TEST_ASSERT_EQUAL_INT(-EFAULT, fib_sr_read_head(&test_fib_sr_table, NULL,
|
|
&sr_iface_id, &sr_flags,
|
|
&sr_lifetime)
|
|
);
|
|
TEST_ASSERT_EQUAL_INT(-EFAULT, fib_sr_read_head(&test_fib_sr_table, local_sourceroutes[0],
|
|
NULL, &sr_flags,
|
|
&sr_lifetime)
|
|
);
|
|
/* we set the lifetime to 1 ms and expect it to expire */
|
|
sr_lifetime = 1;
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_set(&test_fib_sr_table, local_sourceroutes[0],
|
|
&sr_iface_id, &sr_flags, &sr_lifetime)
|
|
);
|
|
/*
|
|
* Since the FIB uses timex under the hood which has a finer grained resolution
|
|
* testing the lifetime requires to active wait a bit, say 1 ms.
|
|
* Uncomment the following lines if you want to test the temporal behaviour
|
|
* @note this may fail since unittests are currently not thread-friendly
|
|
*/
|
|
/*
|
|
xtimer_msleep(1);
|
|
TEST_ASSERT_EQUAL_INT(-ENOENT, fib_sr_read_head(&test_fib_sr_table, local_sourceroutes[0],
|
|
&sr_iface_id, &sr_flags,
|
|
&sr_lifetime)
|
|
);
|
|
*/
|
|
|
|
fib_deinit(&test_fib_sr_table);
|
|
}
|
|
|
|
/*
|
|
* @brief create a new empty source route and delete it
|
|
* It is expected to have no source route
|
|
*/
|
|
static void test_fib_sr_04_create_and_delete_sr(void)
|
|
{
|
|
fib_sr_t *local_sourceroutes[1];
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
|
|
42, 0x0, 10000));
|
|
|
|
/* test wrong parameter */
|
|
TEST_ASSERT_EQUAL_INT(-EFAULT, fib_sr_delete(&test_fib_sr_table, NULL));
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
|
|
|
|
kernel_pid_t sr_iface_id;
|
|
uint32_t sr_flags;
|
|
uint32_t sr_lifetime;
|
|
TEST_ASSERT_EQUAL_INT(-ENOENT, fib_sr_read_head(&test_fib_sr_table, local_sourceroutes[0],
|
|
&sr_iface_id, &sr_flags,
|
|
&sr_lifetime)
|
|
);
|
|
|
|
fib_deinit(&test_fib_sr_table);
|
|
}
|
|
|
|
/*
|
|
* @brief create a new empty source route and append two hops on its path
|
|
*/
|
|
static void test_fib_sr_05_create_sr_and_append_hop(void)
|
|
{
|
|
fib_sr_t *local_sourceroutes[1];
|
|
size_t add_buf_size = 16;
|
|
char addr_nxt[add_buf_size];
|
|
|
|
snprintf(addr_nxt, add_buf_size, "Some address X1");
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
|
|
42, 0x0, 10000));
|
|
|
|
/* append a first hop */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_append(&test_fib_sr_table, local_sourceroutes[0],
|
|
(uint8_t *)&addr_nxt,
|
|
add_buf_size)
|
|
);
|
|
|
|
snprintf(addr_nxt, add_buf_size, "Some address X2");
|
|
/* append a hop behind the first hop */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_append(&test_fib_sr_table, local_sourceroutes[0],
|
|
(uint8_t *)&addr_nxt,
|
|
add_buf_size)
|
|
);
|
|
|
|
/* the destination should be now X2 */
|
|
char addr_out[add_buf_size];
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_read_destination(&test_fib_sr_table, local_sourceroutes[0],
|
|
(uint8_t *)&addr_out,
|
|
&add_buf_size)
|
|
);
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, memcmp(addr_nxt, addr_out, add_buf_size));
|
|
|
|
/* try to append the address twice */
|
|
TEST_ASSERT_EQUAL_INT(-EINVAL, fib_sr_entry_append(&test_fib_sr_table, local_sourceroutes[0],
|
|
(uint8_t *)&addr_nxt,
|
|
add_buf_size)
|
|
);
|
|
|
|
/* remove the source route */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
|
|
|
|
fib_deinit(&test_fib_sr_table);
|
|
}
|
|
|
|
/*
|
|
* @brief create a new source route with a number of hops on its path
|
|
* Search entry and add a new entry after the found one
|
|
*/
|
|
static void test_fib_sr_06_create_sr_with_hops(void)
|
|
{
|
|
fib_sr_t *local_sourceroutes[1];
|
|
size_t add_buf_size = 16;
|
|
char addr_nxt[add_buf_size];
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
|
|
42, 0x0, 10000));
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, _create_sr("Some address X", 0, 10, local_sourceroutes[0], 16));
|
|
|
|
/* now we search for a specific entry, e.g. X6 */
|
|
fib_sr_entry_t *sr_path_entry[1];
|
|
snprintf(addr_nxt, add_buf_size, "Some address X6");
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_search(&test_fib_sr_table, local_sourceroutes[0],
|
|
(uint8_t *)&addr_nxt, add_buf_size,
|
|
&sr_path_entry[0])
|
|
);
|
|
|
|
/* and move on to the next entry (just because we can) */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_next(&test_fib_sr_table, local_sourceroutes[0],
|
|
&sr_path_entry[0]));
|
|
|
|
/* now we add a new entry behind sr_path_entry[0] and drop the remaining route */
|
|
snprintf(addr_nxt, add_buf_size, "Some address XY");
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_add(&test_fib_sr_table, local_sourceroutes[0],
|
|
sr_path_entry[0],
|
|
(uint8_t *)&addr_nxt,
|
|
add_buf_size, false)
|
|
);
|
|
|
|
/* so entries X8 and X9 should be gone */
|
|
snprintf(addr_nxt, add_buf_size, "Some address X8");
|
|
TEST_ASSERT_EQUAL_INT(-EHOSTUNREACH, fib_sr_search(&test_fib_sr_table, local_sourceroutes[0],
|
|
(uint8_t *)&addr_nxt, add_buf_size,
|
|
&sr_path_entry[0])
|
|
);
|
|
snprintf(addr_nxt, add_buf_size, "Some address X9");
|
|
TEST_ASSERT_EQUAL_INT(-EHOSTUNREACH, fib_sr_search(&test_fib_sr_table, local_sourceroutes[0],
|
|
(uint8_t *)&addr_nxt, add_buf_size,
|
|
&sr_path_entry[0])
|
|
);
|
|
|
|
/* now we go to a earlier entry and add a new entry not dropping the remaining ones */
|
|
snprintf(addr_nxt, add_buf_size, "Some address X2");
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_search(&test_fib_sr_table, local_sourceroutes[0],
|
|
(uint8_t *)&addr_nxt, add_buf_size,
|
|
&sr_path_entry[0])
|
|
);
|
|
|
|
snprintf(addr_nxt, add_buf_size, "Some address XZ");
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_add(&test_fib_sr_table, local_sourceroutes[0],
|
|
sr_path_entry[0],
|
|
(uint8_t *)&addr_nxt,
|
|
add_buf_size, true)
|
|
);
|
|
|
|
/*
|
|
* @note uncomment the following line to print the source route.
|
|
* expected X0, .., X2, XZ, X3, .., X7, XY
|
|
*/
|
|
/* fib_print_sr( local_sourceroutes[0]); */
|
|
|
|
/* remove the source route */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
|
|
|
|
fib_deinit(&test_fib_sr_table);
|
|
}
|
|
|
|
/*
|
|
* @brief create a new source route with a number of hops on its path,
|
|
* and delete several entries
|
|
*/
|
|
static void test_fib_sr_07_create_sr_with_hops_and_delete_one(void)
|
|
{
|
|
fib_sr_t *local_sourceroutes[1];
|
|
size_t add_buf_size = 16;
|
|
char addr_nxt[add_buf_size];
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
|
|
42, 0x0, 10000));
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, _create_sr("Some address X", 0, 10, local_sourceroutes[0], 16));
|
|
|
|
snprintf(addr_nxt, add_buf_size, "Some address X6");
|
|
/* we delete X6 keeping the remaining entries */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_delete(&test_fib_sr_table, local_sourceroutes[0],
|
|
(uint8_t *)&addr_nxt, add_buf_size,
|
|
true)
|
|
);
|
|
|
|
snprintf(addr_nxt, add_buf_size, "Some address X9");
|
|
/* now the destination */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_delete(&test_fib_sr_table, local_sourceroutes[0],
|
|
(uint8_t *)&addr_nxt, add_buf_size,
|
|
true)
|
|
);
|
|
|
|
snprintf(addr_nxt, add_buf_size, "Some address X0");
|
|
/* and now the first hop on the path */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_delete(&test_fib_sr_table, local_sourceroutes[0],
|
|
(uint8_t *)&addr_nxt, add_buf_size,
|
|
true)
|
|
);
|
|
|
|
/*
|
|
* @note uncomment the following line to print the source route.
|
|
* expected X1, .., X5, X7, .., X8
|
|
*/
|
|
/* fib_print_sr( local_sourceroutes[0]); */
|
|
|
|
/* remove the source route */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
|
|
|
|
fib_deinit(&test_fib_sr_table);
|
|
}
|
|
|
|
/*
|
|
* @brief create a new source route with a number of hops on its path,
|
|
* and overwrite the address of one entry
|
|
*/
|
|
static void test_fib_sr_08_create_sr_with_hops_and_overwrite_one(void)
|
|
{
|
|
fib_sr_t *local_sourceroutes[1];
|
|
size_t add_buf_size = 16;
|
|
char addr_nxt[add_buf_size];
|
|
char addr_exc[add_buf_size];
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
|
|
42, 0x0, 10000));
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, _create_sr("Some address X", 0, 10, local_sourceroutes[0], 16));
|
|
|
|
/* now we search for a specific entry, e.g. X6 */
|
|
snprintf(addr_nxt, add_buf_size, "Some address X6");
|
|
snprintf(addr_exc, add_buf_size, "Some address XY");
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_overwrite(&test_fib_sr_table, local_sourceroutes[0],
|
|
(uint8_t *)&addr_nxt, add_buf_size,
|
|
(uint8_t *)&addr_exc, add_buf_size)
|
|
);
|
|
/*
|
|
* @note uncomment the following line to print the source route.
|
|
* expected X0, .., X5, XY, X7, .., X9
|
|
*/
|
|
/* fib_print_sr( local_sourceroutes[0]); */
|
|
|
|
/* remove the source route */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
|
|
|
|
fib_deinit(&test_fib_sr_table);
|
|
}
|
|
|
|
/*
|
|
* @brief create a new source route with a number of hops on its path,
|
|
* search an entry and copy the address to the caller
|
|
*/
|
|
static void test_fib_sr_09_create_sr_with_hops_and_get_one(void)
|
|
{
|
|
fib_sr_t *local_sourceroutes[1];
|
|
size_t add_buf_size = 16;
|
|
char addr_nxt[add_buf_size];
|
|
char addr_out[add_buf_size];
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
|
|
42, 0x0, 10000));
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, _create_sr("Some address X", 0, 10, local_sourceroutes[0], 16));
|
|
|
|
/* first we have an empty iterator */
|
|
fib_sr_entry_t *sr_path_entry[1];
|
|
sr_path_entry[0] = NULL;
|
|
|
|
/* now we move on to a specific hop, i.e. the 6th one (X5) */
|
|
for (size_t i = 0; i < 6; ++i) {
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_next(&test_fib_sr_table, local_sourceroutes[0],
|
|
&sr_path_entry[0]));
|
|
}
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_get_address(&test_fib_sr_table, local_sourceroutes[0],
|
|
sr_path_entry[0],
|
|
(uint8_t *)&addr_out, &add_buf_size)
|
|
);
|
|
|
|
/* we ecpect the X5 address */
|
|
snprintf(addr_nxt, add_buf_size, "Some address X5");
|
|
TEST_ASSERT_EQUAL_INT(0, memcmp(addr_nxt, addr_out, add_buf_size));
|
|
|
|
/*
|
|
* @note uncomment the following line to print the source route.
|
|
*/
|
|
/* fib_print_sr( local_sourceroutes[0]); */
|
|
|
|
/* remove the source route */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
|
|
|
|
fib_deinit(&test_fib_sr_table);
|
|
}
|
|
|
|
/*
|
|
* @brief create a new source route with a number of hops on its path,
|
|
* and get it (also in reverse order)
|
|
*/
|
|
static void test_fib_sr_10_create_sr_with_hops_and_get_a_route(void)
|
|
{
|
|
fib_sr_t *local_sourceroutes[1];
|
|
size_t add_buf_size = 16;
|
|
char addr_nxt[add_buf_size];
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
|
|
42, 0x0, 10000));
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, _create_sr("Some address X", 0, 10, local_sourceroutes[0], 16));
|
|
|
|
size_t addr_list_elements = 10;
|
|
size_t element_size = 16;
|
|
uint8_t addr_list[ addr_list_elements * element_size ];
|
|
kernel_pid_t sr_iface_id;
|
|
uint32_t sr_flags = 0x0;
|
|
snprintf(addr_nxt, add_buf_size, "Some address X9");
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_get_route(&test_fib_sr_table, (uint8_t *)&addr_nxt,
|
|
add_buf_size, &sr_iface_id, &sr_flags,
|
|
addr_list, &addr_list_elements, &element_size,
|
|
false, NULL)
|
|
);
|
|
|
|
/*
|
|
* @note uncomment the following lines to print the source route and the result.
|
|
* expected X0, .., X9
|
|
*/
|
|
/*
|
|
fib_print_sr( local_sourceroutes[0]);
|
|
|
|
for (size_t i = 0; i < addr_list_elements; ++i) {
|
|
printf("[");
|
|
for (size_t j = 0; j < element_size; j++) {
|
|
printf("%c", addr_list[(i*element_size)+j]);
|
|
}printf("] ");
|
|
}puts("");
|
|
*/
|
|
|
|
/* now we get the addresses in reverse order */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_get_route(&test_fib_sr_table, (uint8_t *)&addr_nxt,
|
|
add_buf_size, &sr_iface_id, &sr_flags,
|
|
addr_list, &addr_list_elements, &element_size,
|
|
true, NULL)
|
|
);
|
|
|
|
/*
|
|
* @note uncomment the following lines to print the source route and the result.
|
|
* expected X0, .., X9
|
|
*/
|
|
/*
|
|
fib_print_sr( local_sourceroutes[0]);
|
|
|
|
for (size_t i = 0; i < addr_list_elements; ++i) {
|
|
printf("[");
|
|
for (size_t j = 0; j < element_size; j++) {
|
|
printf("%c", addr_list[(i*element_size)+j]);
|
|
}printf("] ");
|
|
}puts("");
|
|
*/
|
|
|
|
/* remove the source route */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
|
|
|
|
fib_deinit(&test_fib_sr_table);
|
|
}
|
|
|
|
/*
|
|
* @brief create a new source route with a number of hops on its path,
|
|
* and get a partial route (also in reverse order)
|
|
*/
|
|
static void test_fib_sr_11_create_sr_with_hops_and_get_a_partial_route(void)
|
|
{
|
|
fib_sr_t *local_sourceroutes[1];
|
|
size_t add_buf_size = 16;
|
|
char addr_nxt[add_buf_size];
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
|
|
42, 0x0, 10000));
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, _create_sr("Some address X", 0, 10, local_sourceroutes[0], 16));
|
|
|
|
size_t addr_list_elements = 10;
|
|
size_t element_size = 16;
|
|
uint8_t addr_list[ addr_list_elements * element_size ];
|
|
kernel_pid_t sr_iface_id;
|
|
uint32_t sr_flags = 0x0;
|
|
snprintf(addr_nxt, add_buf_size, "Some address X7");
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_get_route(&test_fib_sr_table, (uint8_t *)&addr_nxt,
|
|
add_buf_size, &sr_iface_id, &sr_flags,
|
|
addr_list, &addr_list_elements, &element_size,
|
|
false, NULL)
|
|
);
|
|
|
|
/*
|
|
* @note uncomment the following lines to print the resulting source route.
|
|
* expected X0..X9 where X0..X7 has usecount of 2
|
|
*/
|
|
/*
|
|
fib_print_sr( local_sourceroutes[0]);
|
|
|
|
for (size_t i = 0; i < addr_list_elements; ++i) {
|
|
printf("[");
|
|
for (size_t j = 0; j < element_size; j++) {
|
|
printf("%c", addr_list[(i*element_size)+j]);
|
|
}printf("] ");
|
|
}puts("");
|
|
*/
|
|
|
|
/* now we get the addresses in reverse order */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_get_route(&test_fib_sr_table, (uint8_t *)&addr_nxt,
|
|
add_buf_size, &sr_iface_id, &sr_flags,
|
|
addr_list, &addr_list_elements, &element_size,
|
|
true, NULL)
|
|
);
|
|
|
|
/*
|
|
* @note uncomment the following lines to print the resulting source route.
|
|
*/
|
|
/*
|
|
for (size_t i = 0; i < addr_list_elements; ++i) {
|
|
printf("[");
|
|
for (size_t j = 0; j < element_size; j++) {
|
|
printf("%c", addr_list[(i*element_size)+j]);
|
|
}printf("] ");
|
|
}puts("");
|
|
*/
|
|
|
|
/* remove the source route */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_delete(&test_fib_sr_table, local_sourceroutes[0]));
|
|
|
|
fib_deinit(&test_fib_sr_table);
|
|
}
|
|
|
|
/*
|
|
* @brief create new source routes and get all routes succesively
|
|
*/
|
|
static void test_fib_sr_12_get_consecutive_sr(void)
|
|
{
|
|
fib_sr_t *local_sourceroutes[3];
|
|
size_t add_buf_size = 16;
|
|
char addr_nxt[add_buf_size];
|
|
|
|
/* Create SR1 X0,.., X9,XX */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[0],
|
|
42, 0x0, 10000));
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, _create_sr("Some address X", 0, 10, local_sourceroutes[0], 16));
|
|
|
|
snprintf(addr_nxt, add_buf_size, "Some address XX");
|
|
|
|
/* append a the last hop, i.e. the destination */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_append(&test_fib_sr_table, local_sourceroutes[0],
|
|
(uint8_t *)&addr_nxt,
|
|
add_buf_size)
|
|
);
|
|
|
|
/* Create SR1 Y1,.., Y7,XX */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[1],
|
|
42, 0x0, 10000));
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, _create_sr("Some address Y", 1, 8, local_sourceroutes[1], 16));
|
|
|
|
snprintf(addr_nxt, add_buf_size, "Some address XX");
|
|
/* append a the last hop, i.e. the destination */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_append(&test_fib_sr_table, local_sourceroutes[1],
|
|
(uint8_t *)&addr_nxt,
|
|
add_buf_size)
|
|
);
|
|
|
|
/* Create SR1 Z5,.., Z7,XX */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_create(&test_fib_sr_table, &local_sourceroutes[2],
|
|
42, 0x0, 10000));
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, _create_sr("Some address Z", 5, 8, local_sourceroutes[2], 16));
|
|
|
|
snprintf(addr_nxt, add_buf_size, "Some address XX");
|
|
/* append a the last hop, i.e. the destination */
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_entry_append(&test_fib_sr_table, local_sourceroutes[2],
|
|
(uint8_t *)&addr_nxt,
|
|
add_buf_size)
|
|
);
|
|
|
|
fib_sr_t *iter[1];
|
|
iter[0] = NULL;
|
|
size_t addr_list_elements = 11;
|
|
size_t element_size = 16;
|
|
uint8_t addr_list[ addr_list_elements * element_size ];
|
|
kernel_pid_t sr_iface_id;
|
|
uint32_t sr_flags = 0x0;
|
|
snprintf(addr_nxt, add_buf_size, "Some address XX");
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_get_route(&test_fib_sr_table, (uint8_t *)&addr_nxt,
|
|
add_buf_size, &sr_iface_id, &sr_flags,
|
|
addr_list, &addr_list_elements, &element_size,
|
|
false, iter)
|
|
);
|
|
|
|
TEST_ASSERT_EQUAL_INT(11, addr_list_elements);
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_get_route(&test_fib_sr_table, (uint8_t *)&addr_nxt,
|
|
add_buf_size, &sr_iface_id, &sr_flags,
|
|
addr_list, &addr_list_elements, &element_size,
|
|
false, iter)
|
|
);
|
|
|
|
TEST_ASSERT_EQUAL_INT(8, addr_list_elements);
|
|
|
|
TEST_ASSERT_EQUAL_INT(0, fib_sr_get_route(&test_fib_sr_table, (uint8_t *)&addr_nxt,
|
|
add_buf_size, &sr_iface_id, &sr_flags,
|
|
addr_list, &addr_list_elements, &element_size,
|
|
false, iter)
|
|
);
|
|
TEST_ASSERT_EQUAL_INT(4, addr_list_elements);
|
|
|
|
fib_deinit(&test_fib_sr_table);
|
|
}
|
|
|
|
Test *tests_fib_sr_tests(void)
|
|
{
|
|
test_fib_sr_table.data.source_routes = &_entries_sr;
|
|
test_fib_sr_table.table_type = FIB_TABLE_TYPE_SR;
|
|
test_fib_sr_table.size = TEST_MAX_FIB_SR;
|
|
mutex_init(&(test_fib_sr_table.mtx_access));
|
|
test_fib_sr_table.notify_rp_pos = 0;
|
|
|
|
fib_init(&test_fib_sr_table);
|
|
EMB_UNIT_TESTFIXTURES(fixtures) {
|
|
new_TestFixture(test_fib_sr_01_create_empty_sr),
|
|
new_TestFixture(test_fib_sr_02_change_sr_parameters),
|
|
new_TestFixture(test_fib_sr_03_read_sr_parameters),
|
|
new_TestFixture(test_fib_sr_04_create_and_delete_sr),
|
|
new_TestFixture(test_fib_sr_05_create_sr_and_append_hop),
|
|
new_TestFixture(test_fib_sr_06_create_sr_with_hops),
|
|
new_TestFixture(test_fib_sr_07_create_sr_with_hops_and_delete_one),
|
|
new_TestFixture(test_fib_sr_08_create_sr_with_hops_and_overwrite_one),
|
|
new_TestFixture(test_fib_sr_09_create_sr_with_hops_and_get_one),
|
|
new_TestFixture(test_fib_sr_10_create_sr_with_hops_and_get_a_route),
|
|
new_TestFixture(test_fib_sr_11_create_sr_with_hops_and_get_a_partial_route),
|
|
new_TestFixture(test_fib_sr_12_get_consecutive_sr),
|
|
};
|
|
|
|
EMB_UNIT_TESTCALLER(fib_sr_tests, NULL, NULL, fixtures);
|
|
|
|
return (Test *)&fib_sr_tests;
|
|
}
|
|
|
|
void tests_fib_sr(void)
|
|
{
|
|
TESTS_RUN(tests_fib_sr_tests());
|
|
}
|