Porting PicoTCP WIP
This commit is contained in:
545
kernel/picotcp/test/unit/modunit_pico_aodv.c
Normal file
545
kernel/picotcp/test/unit/modunit_pico_aodv.c
Normal file
@ -0,0 +1,545 @@
|
||||
#include <pico_stack.h>
|
||||
#include <pico_tree.h>
|
||||
#include <pico_socket.h>
|
||||
#include <pico_aodv.h>
|
||||
#include <pico_device.h>
|
||||
#include <pico_ipv4.h>
|
||||
#include "modules/pico_aodv.c"
|
||||
#include "check.h"
|
||||
|
||||
|
||||
Suite *pico_suite(void);
|
||||
|
||||
START_TEST(tc_aodv_node_compare)
|
||||
{
|
||||
struct pico_aodv_node a, b;
|
||||
a.dest.ip4.addr = long_be(1);
|
||||
b.dest.ip4.addr = long_be(2);
|
||||
|
||||
fail_if(aodv_node_compare(&a, &b) >= 0);
|
||||
a.dest.ip4.addr = long_be(3);
|
||||
fail_if(aodv_node_compare(&a, &b) <= 0);
|
||||
b.dest.ip4.addr = long_be(3);
|
||||
fail_if(aodv_node_compare(&a, &b) != 0);
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_aodv_dev_cmp)
|
||||
{
|
||||
struct pico_device a, b;
|
||||
a.hash = 1;
|
||||
b.hash = 2;
|
||||
fail_if(aodv_dev_cmp(&a, &b) >= 0);
|
||||
a.hash = 3;
|
||||
fail_if(aodv_dev_cmp(&a, &b) <= 0);
|
||||
b.hash = 3;
|
||||
fail_if(aodv_dev_cmp(&a, &b) != 0);
|
||||
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_get_node_by_addr)
|
||||
{
|
||||
struct pico_aodv_node a;
|
||||
union pico_address test;
|
||||
a.dest.ip4.addr = long_be(10);
|
||||
test.ip4.addr = long_be(10);
|
||||
|
||||
pico_tree_insert(&aodv_nodes, &a);
|
||||
|
||||
fail_if(get_node_by_addr(&test) != &a);
|
||||
pico_tree_delete(&aodv_nodes, &a);
|
||||
fail_if(get_node_by_addr(&test) != NULL);
|
||||
|
||||
}
|
||||
END_TEST
|
||||
|
||||
static int set_bcast_link_called = 0;
|
||||
void pico_ipv4_route_set_bcast_link(struct pico_ipv4_link *link)
|
||||
{
|
||||
IGNORE_PARAMETER(link);
|
||||
set_bcast_link_called++;
|
||||
}
|
||||
|
||||
START_TEST(tc_pico_aodv_set_dev)
|
||||
{
|
||||
struct pico_device *dev = NULL;
|
||||
pico_aodv_set_dev(dev);
|
||||
fail_if(set_bcast_link_called != 1);
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_aodv_peer_refresh)
|
||||
{
|
||||
/* TODO: test this: static int aodv_peer_refresh(struct pico_aodv_node *node, uint32_t seq) */
|
||||
struct pico_aodv_node node;
|
||||
memset(&node, 0, sizeof(node));
|
||||
node.dseq = 0xFFFF;
|
||||
fail_if(aodv_peer_refresh(&node, 10) != 0); /* should succeed, because SYNC flag is not yet set... */
|
||||
fail_if((node.flags & PICO_AODV_NODE_SYNC) == 0); /* Flag should be set after last call... */
|
||||
fail_if(aodv_peer_refresh(&node, 5) == 0); /* should FAIL, because seq number is lower... */
|
||||
fail_if(aodv_peer_refresh(&node, 10) == 0); /* should FAIL, because seq number is still the same... */
|
||||
fail_if(aodv_peer_refresh(&node, 15) != 0); /* should succeed, because seq number is now bigger... */
|
||||
fail_if(node.dseq != 15);
|
||||
}
|
||||
END_TEST
|
||||
|
||||
static int called_route_add = 0;
|
||||
static uint32_t route_add_gw = 0u;
|
||||
static int route_add_metric = 0;
|
||||
int pico_ipv4_route_add(struct pico_ip4 address, struct pico_ip4 netmask, struct pico_ip4 gateway, int metric, struct pico_ipv4_link *link)
|
||||
{
|
||||
IGNORE_PARAMETER(link);
|
||||
IGNORE_PARAMETER(netmask);
|
||||
IGNORE_PARAMETER(address);
|
||||
called_route_add++;
|
||||
route_add_gw = gateway.addr;
|
||||
route_add_metric = metric;
|
||||
return 0;
|
||||
}
|
||||
|
||||
START_TEST(tc_aodv_elect_route)
|
||||
{
|
||||
struct pico_aodv_node node;
|
||||
union pico_address gateway;
|
||||
memset(&node, 0, sizeof(node));
|
||||
gateway.ip4.addr = 0x55555555;
|
||||
|
||||
called_route_add = 0;
|
||||
aodv_elect_route(&node, NULL, 150, NULL);
|
||||
fail_if(called_route_add != 1); /* Not active, should succeed */
|
||||
fail_if(route_add_gw != 0u);
|
||||
fail_if(route_add_metric != 1);
|
||||
|
||||
called_route_add = 0;
|
||||
route_add_metric = 0;
|
||||
route_add_gw = 0u;
|
||||
node.flags = PICO_AODV_NODE_ROUTE_DOWN | PICO_AODV_NODE_ROUTE_UP;
|
||||
aodv_elect_route(&node, &gateway, 150, NULL);
|
||||
fail_if(called_route_add != 0); /* Already active, existing metric is lower */
|
||||
|
||||
called_route_add = 0;
|
||||
route_add_metric = 0;
|
||||
route_add_gw = 0u;
|
||||
node.metric = 22;
|
||||
aodv_elect_route(&node, &gateway, 15, NULL);
|
||||
fail_if(called_route_add != 1); /* Already active, existing metric is higher */
|
||||
fail_if(route_add_metric != 16);
|
||||
fail_if(route_add_gw != 0x55555555);
|
||||
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_aodv_peer_new)
|
||||
{
|
||||
union pico_address addr;
|
||||
struct pico_aodv_node *new;
|
||||
addr.ip4.addr = 0x44444444;
|
||||
new = aodv_peer_new(&addr);
|
||||
fail_if(!new);
|
||||
fail_if(!get_node_by_addr(&addr));
|
||||
pico_set_mm_failure(1);
|
||||
new = aodv_peer_new(&addr);
|
||||
fail_if(new);
|
||||
}
|
||||
END_TEST
|
||||
START_TEST(tc_aodv_peer_eval)
|
||||
{
|
||||
union pico_address addr;
|
||||
struct pico_aodv_node *node = NULL;
|
||||
/* Case 0: Creation */
|
||||
addr.ip4.addr = 0x11224433;
|
||||
node = aodv_peer_eval(&addr, 0, 0);
|
||||
fail_if(!node);
|
||||
fail_if((node->flags & PICO_AODV_NODE_SYNC) != 0); /* Not synced! */
|
||||
|
||||
/* Case 1: retrieve, unsynced */
|
||||
node->metric = 42;
|
||||
node = aodv_peer_eval(&addr, 0, 0); /* Should get existing node! */
|
||||
fail_if(!node);
|
||||
fail_if(node->metric != 42);
|
||||
fail_if((node->flags & PICO_AODV_NODE_SYNC) != 0); /* Not synced! */
|
||||
|
||||
|
||||
/* Case 2: new node, invalid allocation */
|
||||
addr.ip4.addr = 0x11224455;
|
||||
pico_set_mm_failure(1);
|
||||
node = aodv_peer_eval(&addr, long_be(10), 1);
|
||||
fail_if(node);
|
||||
|
||||
/* Case 3: existing node, setting the new sequence */
|
||||
addr.ip4.addr = 0x11224433;
|
||||
node = aodv_peer_eval(&addr, long_be(10), 1); /* Should get existing node! */
|
||||
fail_if(node->metric != 42);
|
||||
fail_if((node->flags & PICO_AODV_NODE_SYNC) == 0);
|
||||
fail_if(node->dseq != 10);
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_aodv_lifetime)
|
||||
{
|
||||
struct pico_aodv_node node;
|
||||
pico_time now = PICO_TIME_MS();
|
||||
memset(&node, 0, sizeof(node));
|
||||
fail_if(aodv_lifetime(&node) == 0);
|
||||
fail_if(node.last_seen < now);
|
||||
node.last_seen = now - AODV_ACTIVE_ROUTE_TIMEOUT;
|
||||
fail_if(aodv_lifetime(&node) != 0);
|
||||
}
|
||||
END_TEST
|
||||
|
||||
static uint8_t sent_pkt_type = 0xFF;
|
||||
static uint32_t dest_addr = 0;
|
||||
static int pico_socket_sendto_called = 0;
|
||||
static int pico_socket_sendto_extended_called = 0;
|
||||
uint32_t expected_dseq = 0;
|
||||
int pico_socket_sendto(struct pico_socket *s, const void *buf, const int len, void *dst, uint16_t remote_port)
|
||||
{
|
||||
uint8_t *pkt = (uint8_t *)(uintptr_t)buf;
|
||||
printf("Sendto called!\n");
|
||||
pico_socket_sendto_called++;
|
||||
fail_if(remote_port != short_be(PICO_AODV_PORT));
|
||||
fail_if (s != aodv_socket);
|
||||
fail_if(pkt[0] > 4);
|
||||
fail_if(pkt[0] < 1);
|
||||
sent_pkt_type = pkt[0];
|
||||
dest_addr = ((union pico_address *)dst)->ip4.addr;
|
||||
if (sent_pkt_type == AODV_TYPE_RREQ) {
|
||||
/* struct pico_aodv_rreq *req = (struct pico_aodv_rreq *)(uintptr_t)buf; */
|
||||
fail_if(len != sizeof(struct pico_aodv_rreq));
|
||||
}
|
||||
else if (sent_pkt_type == AODV_TYPE_RREP) {
|
||||
struct pico_aodv_rrep *rep = (struct pico_aodv_rrep *)(uintptr_t)buf;
|
||||
fail_if(len != sizeof(struct pico_aodv_rrep));
|
||||
fail_if(rep->dest != 0x11111111);
|
||||
fail_if(rep->orig != 0x22222222);
|
||||
printf("rep->dseq= %08x, exp: %08x\n", rep->dseq, expected_dseq);
|
||||
fail_if(rep->dseq != expected_dseq);
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
int pico_socket_sendto_extended(struct pico_socket *s, const void *buf, const int len,
|
||||
void *dst, uint16_t remote_port, struct pico_msginfo *msginfo)
|
||||
{
|
||||
IGNORE_PARAMETER(msginfo);
|
||||
pico_socket_sendto_extended_called++;
|
||||
return pico_socket_sendto(s, buf, len, dst, remote_port);
|
||||
}
|
||||
|
||||
START_TEST(tc_aodv_send_reply)
|
||||
{
|
||||
struct pico_aodv_node node;
|
||||
struct pico_aodv_rreq req;
|
||||
struct pico_msginfo info;
|
||||
union pico_address addr;
|
||||
addr.ip4.addr = 0x22222222;
|
||||
memset(&node, 0, sizeof(node));
|
||||
memset(&req, 0, sizeof(req));
|
||||
memset(&info, 0, sizeof(info));
|
||||
|
||||
req.dest = 0x11111111;
|
||||
req.orig = addr.ip4.addr;
|
||||
req.dseq = 99;
|
||||
|
||||
aodv_send_reply(&node, &req, 1, &info);
|
||||
fail_if(pico_socket_sendto_called != 0); /* Call should have no effect, due to non-existing origin node */
|
||||
|
||||
/* Creating origin... */
|
||||
fail_if(aodv_peer_new(&addr) == NULL);
|
||||
aodv_send_reply(&node, &req, 0, &info);
|
||||
fail_if(pico_socket_sendto_called != 0); /* Call should have no effect, node non-local, non sync'd */
|
||||
|
||||
expected_dseq = long_be(pico_aodv_local_id + 1);
|
||||
aodv_send_reply(&node, &req, 1, &info);
|
||||
fail_if(pico_socket_sendto_called != 1); /* Call should succeed */
|
||||
pico_socket_sendto_called = 0;
|
||||
|
||||
node.flags = PICO_AODV_NODE_SYNC;
|
||||
node.dseq = 42;
|
||||
expected_dseq = long_be(42);
|
||||
aodv_send_reply(&node, &req, 0, &info);
|
||||
fail_if(pico_socket_sendto_called != 1); /* Call should succeed */
|
||||
pico_socket_sendto_called = 0;
|
||||
}
|
||||
END_TEST
|
||||
|
||||
static struct pico_ipv4_link global_link;
|
||||
struct pico_ipv4_link *pico_ipv4_link_by_dev(struct pico_device *dev)
|
||||
{
|
||||
IGNORE_PARAMETER(dev);
|
||||
if (!global_link.address.addr)
|
||||
return NULL;
|
||||
|
||||
printf("Setting link!\n");
|
||||
return &global_link;
|
||||
}
|
||||
|
||||
static struct pico_device global_dev;
|
||||
static int link_find_success = 0;
|
||||
struct pico_device *pico_ipv4_link_find(struct pico_ip4 *ip4)
|
||||
{
|
||||
IGNORE_PARAMETER(ip4);
|
||||
if (link_find_success)
|
||||
return &global_dev;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int timer_set = 0;
|
||||
uint32_t pico_timer_add(pico_time expire, void (*timer)(pico_time, void *), void *arg)
|
||||
{
|
||||
IGNORE_PARAMETER(arg);
|
||||
IGNORE_PARAMETER(timer);
|
||||
IGNORE_PARAMETER(expire);
|
||||
printf("Timer set!\n");
|
||||
timer_set++;
|
||||
return (uint32_t ) 0x99999999;
|
||||
|
||||
}
|
||||
|
||||
START_TEST(tc_aodv_send_req)
|
||||
{
|
||||
struct pico_aodv_node node;
|
||||
struct pico_device d;
|
||||
aodv_socket = NULL;
|
||||
|
||||
memset(&node, 0, sizeof(node));
|
||||
node.flags = PICO_AODV_NODE_ROUTE_DOWN | PICO_AODV_NODE_ROUTE_UP;
|
||||
fail_if(aodv_send_req(&node) != 0); /* Should fail: node already active */
|
||||
fail_if(pico_socket_sendto_called != 0);
|
||||
fail_if(pico_socket_sendto_extended_called != 0);
|
||||
|
||||
node.flags = 0;
|
||||
fail_if(aodv_send_req(&node) != 0); /* Should fail: no devices in tree */
|
||||
fail_if(pico_socket_sendto_called != 0);
|
||||
fail_if(pico_socket_sendto_extended_called != 0);
|
||||
|
||||
pico_tree_insert(&aodv_devices, &d);
|
||||
fail_if(aodv_send_req(&node) != -1); /* Should fail: aodv_socket == NULL */
|
||||
fail_if(pico_err != PICO_ERR_EINVAL);
|
||||
fail_if(pico_socket_sendto_called != 0);
|
||||
fail_if(pico_socket_sendto_extended_called != 0);
|
||||
|
||||
|
||||
/* No valid link, timer is set, call does not send packets */
|
||||
aodv_socket = (struct pico_socket*) 1;
|
||||
global_link.address.addr = 0;
|
||||
fail_if(aodv_send_req(&node) != 0);
|
||||
fail_if(pico_socket_sendto_called != 0);
|
||||
fail_if(pico_socket_sendto_extended_called != 0);
|
||||
fail_if(timer_set != 1);
|
||||
timer_set = 0;
|
||||
|
||||
|
||||
/* One valid link, timer is set, one packet is sent */
|
||||
global_link.address.addr = 0xFEFEFEFE;
|
||||
fail_if(aodv_send_req(&node) != 1);
|
||||
fail_if(pico_socket_sendto_called != 1);
|
||||
fail_if(pico_socket_sendto_extended_called != 1);
|
||||
fail_if(timer_set != 1);
|
||||
pico_socket_sendto_called = 0;
|
||||
pico_socket_sendto_extended_called = 0;
|
||||
timer_set = 0;
|
||||
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_aodv_reverse_path_discover)
|
||||
{
|
||||
struct pico_aodv_node node;
|
||||
memset(&node, 0, sizeof(node));
|
||||
aodv_reverse_path_discover(0, &node);
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_aodv_recv_valid_rreq)
|
||||
{
|
||||
struct pico_aodv_node node;
|
||||
struct pico_aodv_rreq req;
|
||||
struct pico_msginfo info;
|
||||
union pico_address addr;
|
||||
memset(&node, 0, sizeof(node));
|
||||
memset(&req, 0, sizeof(req));
|
||||
memset(&info, 0, sizeof(info));
|
||||
|
||||
addr.ip4.addr = 0x22222222;
|
||||
|
||||
link_find_success = 0;
|
||||
aodv_recv_valid_rreq(&node, &req, &info);
|
||||
fail_if(pico_socket_sendto_called > 0);
|
||||
|
||||
/* link not local, but active node, set to send reply, no timer */
|
||||
link_find_success = 0;
|
||||
fail_if(aodv_peer_new(&addr) == NULL);
|
||||
global_link.address.addr = 0x44444444;
|
||||
req.orig = addr.ip4.addr;
|
||||
req.dest = 0x11111111;
|
||||
node.flags = PICO_AODV_NODE_SYNC | PICO_AODV_NODE_ROUTE_UP | PICO_AODV_NODE_ROUTE_DOWN;
|
||||
node.dseq = 42;
|
||||
expected_dseq = long_be(42);
|
||||
aodv_recv_valid_rreq(&node, &req, &info);
|
||||
fail_if(pico_socket_sendto_called < 1);
|
||||
fail_if(timer_set > 0);
|
||||
pico_socket_sendto_called = 0;
|
||||
|
||||
/* link local, active node. Full send + set timer. */
|
||||
link_find_success = 1;
|
||||
expected_dseq = long_be(pico_aodv_local_id + 1);
|
||||
aodv_peer_new(&addr);
|
||||
aodv_recv_valid_rreq(&node, &req, &info);
|
||||
fail_if(pico_socket_sendto_called < 1);
|
||||
fail_if(timer_set < 1);
|
||||
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_aodv_parse_rreq)
|
||||
{
|
||||
/* TODO: test this: static void aodv_parse_rreq(union pico_address *from, uint8_t *buf, int len, struct pico_msginfo *msginfo) */
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_aodv_parse_rrep)
|
||||
{
|
||||
/* TODO: test this: static void aodv_parse_rrep(union pico_address *from, uint8_t *buf, int len, struct pico_msginfo *msginfo) */
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_aodv_parse_rerr)
|
||||
{
|
||||
/* TODO: test this: static void aodv_parse_rerr(union pico_address *from, uint8_t *buf, int len, struct pico_msginfo *msginfo) */
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_aodv_parse_rack)
|
||||
{
|
||||
aodv_parse_rack(NULL, NULL, 0, NULL);
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_pico_aodv_parse)
|
||||
{
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_pico_aodv_socket_callback)
|
||||
{
|
||||
/* TODO: test this: static void pico_aodv_socket_callback(uint16_t ev, struct pico_socket *s) */
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_aodv_make_rreq)
|
||||
{
|
||||
/* TODO: test this: static void aodv_make_rreq(struct pico_aodv_node *node, struct pico_aodv_rreq *req) */
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_aodv_retrans_rreq)
|
||||
{
|
||||
/* TODO: test this: static void aodv_retrans_rreq(pico_time now, void *arg) */
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_pico_aodv_expired)
|
||||
{
|
||||
/* TODO: test this: static void pico_aodv_expired(struct pico_aodv_node *node) */
|
||||
}
|
||||
END_TEST
|
||||
|
||||
START_TEST(tc_pico_aodv_collector)
|
||||
{
|
||||
/* TODO: test this: static void pico_aodv_collector(pico_time now, void *arg) */
|
||||
}
|
||||
END_TEST
|
||||
|
||||
|
||||
Suite *pico_suite(void)
|
||||
{
|
||||
Suite *s = suite_create("PicoTCP");
|
||||
|
||||
TCase *TCase_aodv_node_compare = tcase_create("Unit test for aodv_node_compare");
|
||||
TCase *TCase_aodv_dev_cmp = tcase_create("Unit test for aodv_dev_cmp");
|
||||
TCase *TCase_get_node_by_addr = tcase_create("Unit test for get_node_by_addr");
|
||||
TCase *TCase_pico_aodv_set_dev = tcase_create("Unit test for pico_aodv_set_dev");
|
||||
TCase *TCase_aodv_peer_refresh = tcase_create("Unit test for aodv_peer_refresh");
|
||||
TCase *TCase_aodv_elect_route = tcase_create("Unit test for aodv_elect_route");
|
||||
TCase *TCase_aodv_peer_new = tcase_create("Unit test for aodv_peer_new");
|
||||
TCase *TCase_aodv_peer_eval = tcase_create("Unit test for aodv_peer_eval");
|
||||
TCase *TCase_aodv_lifetime = tcase_create("Unit test for aodv_lifetime");
|
||||
TCase *TCase_aodv_send_reply = tcase_create("Unit test for aodv_send_reply");
|
||||
TCase *TCase_aodv_send_req = tcase_create("Unit test for aodv_send_req");
|
||||
TCase *TCase_aodv_reverse_path_discover = tcase_create("Unit test for aodv_reverse_path_discover");
|
||||
TCase *TCase_aodv_recv_valid_rreq = tcase_create("Unit test for aodv_recv_valid_rreq");
|
||||
TCase *TCase_aodv_parse_rreq = tcase_create("Unit test for aodv_parse_rreq");
|
||||
TCase *TCase_aodv_parse_rrep = tcase_create("Unit test for aodv_parse_rrep");
|
||||
TCase *TCase_aodv_parse_rerr = tcase_create("Unit test for aodv_parse_rerr");
|
||||
TCase *TCase_aodv_parse_rack = tcase_create("Unit test for aodv_parse_rack");
|
||||
TCase *TCase_pico_aodv_parse = tcase_create("Unit test for pico_aodv_parse");
|
||||
TCase *TCase_pico_aodv_socket_callback = tcase_create("Unit test for pico_aodv_socket_callback");
|
||||
TCase *TCase_aodv_make_rreq = tcase_create("Unit test for aodv_make_rreq");
|
||||
TCase *TCase_aodv_retrans_rreq = tcase_create("Unit test for aodv_retrans_rreq");
|
||||
TCase *TCase_pico_aodv_expired = tcase_create("Unit test for pico_aodv_expired");
|
||||
TCase *TCase_pico_aodv_collector = tcase_create("Unit test for pico_aodv_collector");
|
||||
|
||||
|
||||
tcase_add_test(TCase_aodv_node_compare, tc_aodv_node_compare);
|
||||
suite_add_tcase(s, TCase_aodv_node_compare);
|
||||
tcase_add_test(TCase_aodv_dev_cmp, tc_aodv_dev_cmp);
|
||||
suite_add_tcase(s, TCase_aodv_dev_cmp);
|
||||
tcase_add_test(TCase_get_node_by_addr, tc_get_node_by_addr);
|
||||
suite_add_tcase(s, TCase_get_node_by_addr);
|
||||
tcase_add_test(TCase_pico_aodv_set_dev, tc_pico_aodv_set_dev);
|
||||
suite_add_tcase(s, TCase_pico_aodv_set_dev);
|
||||
tcase_add_test(TCase_aodv_peer_refresh, tc_aodv_peer_refresh);
|
||||
suite_add_tcase(s, TCase_aodv_peer_refresh);
|
||||
tcase_add_test(TCase_aodv_elect_route, tc_aodv_elect_route);
|
||||
suite_add_tcase(s, TCase_aodv_elect_route);
|
||||
tcase_add_test(TCase_aodv_peer_new, tc_aodv_peer_new);
|
||||
suite_add_tcase(s, TCase_aodv_peer_new);
|
||||
tcase_add_test(TCase_aodv_peer_eval, tc_aodv_peer_eval);
|
||||
suite_add_tcase(s, TCase_aodv_peer_eval);
|
||||
tcase_add_test(TCase_aodv_lifetime, tc_aodv_lifetime);
|
||||
suite_add_tcase(s, TCase_aodv_lifetime);
|
||||
tcase_add_test(TCase_aodv_send_reply, tc_aodv_send_reply);
|
||||
suite_add_tcase(s, TCase_aodv_send_reply);
|
||||
tcase_add_test(TCase_aodv_send_req, tc_aodv_send_req);
|
||||
suite_add_tcase(s, TCase_aodv_send_req);
|
||||
tcase_add_test(TCase_aodv_reverse_path_discover, tc_aodv_reverse_path_discover);
|
||||
suite_add_tcase(s, TCase_aodv_reverse_path_discover);
|
||||
tcase_add_test(TCase_aodv_recv_valid_rreq, tc_aodv_recv_valid_rreq);
|
||||
suite_add_tcase(s, TCase_aodv_recv_valid_rreq);
|
||||
tcase_add_test(TCase_aodv_parse_rreq, tc_aodv_parse_rreq);
|
||||
suite_add_tcase(s, TCase_aodv_parse_rreq);
|
||||
tcase_add_test(TCase_aodv_parse_rrep, tc_aodv_parse_rrep);
|
||||
suite_add_tcase(s, TCase_aodv_parse_rrep);
|
||||
tcase_add_test(TCase_aodv_parse_rerr, tc_aodv_parse_rerr);
|
||||
suite_add_tcase(s, TCase_aodv_parse_rerr);
|
||||
tcase_add_test(TCase_aodv_parse_rack, tc_aodv_parse_rack);
|
||||
suite_add_tcase(s, TCase_aodv_parse_rack);
|
||||
tcase_add_test(TCase_pico_aodv_parse, tc_pico_aodv_parse);
|
||||
suite_add_tcase(s, TCase_pico_aodv_parse);
|
||||
tcase_add_test(TCase_pico_aodv_socket_callback, tc_pico_aodv_socket_callback);
|
||||
suite_add_tcase(s, TCase_pico_aodv_socket_callback);
|
||||
tcase_add_test(TCase_aodv_make_rreq, tc_aodv_make_rreq);
|
||||
suite_add_tcase(s, TCase_aodv_make_rreq);
|
||||
tcase_add_test(TCase_aodv_retrans_rreq, tc_aodv_retrans_rreq);
|
||||
suite_add_tcase(s, TCase_aodv_retrans_rreq);
|
||||
tcase_add_test(TCase_pico_aodv_expired, tc_pico_aodv_expired);
|
||||
suite_add_tcase(s, TCase_pico_aodv_expired);
|
||||
tcase_add_test(TCase_pico_aodv_collector, tc_pico_aodv_collector);
|
||||
suite_add_tcase(s, TCase_pico_aodv_collector);
|
||||
return s;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int fails;
|
||||
Suite *s = pico_suite();
|
||||
SRunner *sr = srunner_create(s);
|
||||
srunner_run_all(sr, CK_NORMAL);
|
||||
fails = srunner_ntests_failed(sr);
|
||||
srunner_free(sr);
|
||||
return fails;
|
||||
}
|
||||
Reference in New Issue
Block a user