kaspar/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2025-12-29 16:31:18 +01:00
Code Releases Activity

unittests: Provide unittests for net_dev_dummy

Browse Source 
* tests if net_dev_dummy is correct and if driver part of net_dev is
  correct
This commit is contained in:
Martine Lenders 2014-08-08 19:21:03 +02:00
parent cf3fdaabb6
commit 0de78831f9
5 changed files with 1052 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
tests/unittests/Makefile
View File

@ -1,7 +1,8 @@
APPLICATION = unittests
include ../Makefile.tests_common
BOARD_INSUFFICIENT_RAM := chronos msb-430 msb-430h redbee-econotag stm32f0discovery
BOARD_INSUFFICIENT_RAM := chronos msb-430 msb-430h redbee-econotag stm32f0discovery \
telosb wsn430-v1_3b wsn430-v1_4 z1
USEMODULE += embunit
@ -18,6 +19,20 @@ else ifeq ($(OUTPUT),COMPILER)
USEMODULE += embunit_textui
endif
# Some randomly generated but still deterministic values for testing
CFLAGS += -DTEST_STRING8="\"o<\\\\rrB/q\""
CFLAGS += -DTEST_STRING12="\"50U'HLKC3_ft\""
CFLAGS += -DTEST_STRING16="\"nvxuO*6o3C=a6g7]\""
CFLAGS += -DTEST_STRING64="\"3key9'=4\\\\wvAM&;.E&U/rOG:>\\\\C!r{K k.E[%;(}_I(D%XQk8+T>_M^G'Mm49,n:))]}\""
CFLAGS += -DTEST_INT8=-69
CFLAGS += -DTEST_INT16=-12229
CFLAGS += -DTEST_INT32=-1894529023L
CFLAGS += -DTEST_INT64=-4562349816927799244LL
CFLAGS += -DTEST_UINT8=95U
CFLAGS += -DTEST_UINT16=10098U
CFLAGS += -DTEST_UINT32=2831907245LU
CFLAGS += -DTEST_UINT64=13500266397057512199LLU
ifeq (, $(filter tests-%, $(MAKECMDGOALS)))
UNIT_TESTS := $(foreach d,$(wildcard tests-*/Makefile),$(shell dirname $(d)))
else
@ -40,6 +55,12 @@ BASELIBS += $(UNIT_TESTS:%=$(BINDIR)%.a)
include $(RIOTBASE)/Makefile.include
ifeq (,$(filter msp430x16x,$(CPU)))
CFLAGS += -DTEST_INT=TEST_INT32
else
CFLAGS += -DTEST_INT=TEST_INT16
endif
.PHONY: FORCE $(UNIT_TESTS)
FORCE:

4
tests/unittests/tests-netdev_dummy/Makefile Normal file
View File

@ -0,0 +1,4 @@
MODULE = tests-netdev_dummy
include $(RIOTBASE)/Makefile.base

1
tests/unittests/tests-netdev_dummy/Makefile.include Normal file
View File

@ -0,0 +1 @@
USEMODULE += netdev_dummy

988
tests/unittests/tests-netdev_dummy/tests-netdev_dummy.c Normal file
View File

@ -0,0 +1,988 @@
/*
* Copyright (C) 2014 Martin Lenders
*
* 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 <errno.h>
#include <stdint.h>
#include <string.h>
#include "clist.h"
#include "embUnit/embUnit.h"
#include "netdev_dummy.h"
#include "tests-netdev_dummy.h"
static netdev_t *dev = &(unittest_netdev_dummy_devs[0]);
static char received_data[UNITTESTS_NETDEV_DUMMY_MAX_PACKET];
static char received_src[UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN];
static char received_dst[UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN];
static size_t received_data_len = 0, received_src_len = 0, received_dst_len = 0;
#define OPTION_NUMBER (6)
#define RANDOM_OPTION (TEST_UINT8 % OPTION_NUMBER) + 1
static void _reset_received(void)
{
memset(received_data, 0, sizeof(received_data));
memset(received_src, 0, sizeof(received_src));
memset(received_dst, 0, sizeof(received_dst));
received_data_len = 0;
received_src_len = 0;
received_dst_len = 0;
}
static void set_up(void)
{
unittest_netdev_dummy_init();
dev->driver->init(dev);
}
static void tear_down(void)
{
_reset_received();
}
/* callback for callback tests */
int _fill_received(netdev_t *dev_rcv, void *src, size_t src_len, void *dest,
size_t dest_len, void *payload, size_t payload_len)
{
if ((dev != dev_rcv) || (payload_len > sizeof(received_data)) ||
(src_len > sizeof(received_src)) || (dest_len > sizeof(received_dst))) {
/* should not happen */
return -1;
}
memcpy(received_src, src, src_len);
received_src_len = src_len;
memcpy(received_dst, dest, dest_len);
received_dst_len = dest_len;
memcpy(received_data, payload, payload_len);
received_data_len = payload_len;
return 0;
}
/* callback for callback tests */
int _always_wrong(netdev_t *dev_rcv, void *src, size_t src_len, void *dest,
size_t dest_len, void *payload, size_t payload_len)
{
(void)dev_rcv;
(void)src;
(void)src_len;
(void)dest;
(void)dest_len;
(void)payload;
(void)payload_len;
return -1;
}
/*********************************************
* driver::init tests *
*********************************************/
static void test_netdev_dummy_init_dev_null(void)
{
TEST_ASSERT_EQUAL_INT(-ENODEV, dev->driver->init(NULL));
}
static void test_netdev_dummy_init_dev_wrong(void)
{
netdev_t wrong_dev;
TEST_ASSERT_EQUAL_INT(-ENODEV, dev->driver->init(&wrong_dev));
}
/*********************************************
* driver::send_data tests *
*********************************************/
static void test_netdev_dummy_send_data_dev_null(void)
{
char dest[] = TEST_STRING8;
char data[] = TEST_STRING64;
TEST_ASSERT_EQUAL_INT(-ENODEV, dev->driver->send_data(NULL, dest,
UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN, NULL,
data, strlen(data)));
}
static void test_netdev_dummy_send_data_dev_wrong(void)
{
char dest[] = TEST_STRING8;
char data[] = TEST_STRING64;
netdev_t wrong_dev;
TEST_ASSERT_EQUAL_INT(-ENODEV, dev->driver->send_data(&wrong_dev, dest,
UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN, NULL,
data, strlen(data)));
}
static void test_netdev_dummy_send_data_dest_too_long(void)
{
char dest[] = TEST_STRING8;
char data[] = TEST_STRING64;
TEST_ASSERT_EQUAL_INT(-EAFNOSUPPORT, dev->driver->send_data(dev, dest,
UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN + TEST_UINT8,
NULL, data, 1));
}
static void test_netdev_dummy_send_data_data_too_long(void)
{
char dest[] = TEST_STRING8;
char data[] = TEST_STRING64;
TEST_ASSERT_EQUAL_INT(-EMSGSIZE, dev->driver->send_data(dev, dest,
UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN, NULL,
data,
UNITTESTS_NETDEV_DUMMY_MAX_PACKET + TEST_UINT8));
}
static void test_netdev_dummy_send_data_no_ulhs(void)
{
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char data[] = TEST_STRING8;
#if UNITTESTS_NETDEV_DUMMY_MAX_PACKET < 8
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET;
#else
size_t data_len = 8;
#endif
TEST_ASSERT_EQUAL_INT((int)data_len, dev->driver->send_data(dev, dest,
dest_len, NULL, data, data_len));
TEST_ASSERT_EQUAL_INT(0, unittest_netdev_dummy_check_transmitted(dev,
dest, dest_len, data, data_len));
}
#if UNITTESTS_NETDEV_DUMMY_MAX_PACKET > 4
static void test_netdev_dummy_send_data_with_ulhs(void)
{
netdev_hlist_t hlist_node = {NULL, NULL, TEST_STRING8, 4};
netdev_hlist_t *hlist = NULL;
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char data[] = TEST_STRING16;
#if UNITTESTS_NETDEV_DUMMY_MAX_PACKET < 12
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET - 4;
char expected[UNITTESTS_NETDEV_DUMMY_MAX_PACKET];
#else
size_t data_len = 8;
char expected[12];
#endif
memcpy(expected, TEST_STRING8, 4);
memcpy(&(expected[4]), TEST_STRING16, data_len);
clist_add((clist_node_t **)&hlist, (clist_node_t *)&hlist_node);
TEST_ASSERT_EQUAL_INT((int)sizeof(expected), dev->driver->send_data(dev,
dest, dest_len, hlist, data, data_len));
TEST_ASSERT_EQUAL_INT(0, unittest_netdev_dummy_check_transmitted(dev,
dest, dest_len, expected, data_len + 4));
}
#endif
/*********************************************
* driver::add_receive_data_callback tests *
*********************************************/
static void test_netdev_dummy_add_cb_dev_null(void)
{
TEST_ASSERT_EQUAL_INT(-ENODEV, dev->driver->add_receive_data_callback(NULL,
_fill_received));
}
static void test_netdev_dummy_add_cb_dev_wrong(void)
{
netdev_t wrong_dev;
TEST_ASSERT_EQUAL_INT(-ENODEV, dev->driver->add_receive_data_callback(&wrong_dev,
_fill_received));
}
static void test_netdev_dummy_add_cb_buffer_full(void)
{
for (int i = 0; i < UNITTESTS_NETDEV_DUMMY_MAX_CB; i++) {
TEST_ASSERT_EQUAL_INT(0, dev->driver->add_receive_data_callback(dev,
(netdev_rcv_data_cb_t)(i + 1)));
}
TEST_ASSERT_EQUAL_INT(-ENOBUFS, dev->driver->add_receive_data_callback(dev,
_fill_received));
}
static void test_netdev_dummy_add_cb_successful(void)
{
char src[] = TEST_STRING64;
size_t src_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char data[] = TEST_STRING8;
#if UNITTESTS_NETDEV_DUMMY_MAX_PACKET < 8
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET;
#else
size_t data_len = 8;
#endif
TEST_ASSERT_EQUAL_INT(0, dev->driver->add_receive_data_callback(dev,
_fill_received));
TEST_ASSERT_EQUAL_INT(0, unittest_netdev_dummy_fire_rcv_event(dev, src,
src_len, dest, dest_len, data, data_len));
TEST_ASSERT_EQUAL_INT(src_len, received_src_len);
TEST_ASSERT_EQUAL_INT(0, memcmp(received_src, src, src_len));
TEST_ASSERT_EQUAL_INT(dest_len, received_dst_len);
TEST_ASSERT_EQUAL_INT(0, memcmp(received_dst, dest, dest_len));
TEST_ASSERT_EQUAL_INT(data_len, received_data_len);
TEST_ASSERT_EQUAL_INT(0, memcmp(received_data, data, data_len));
}
/*********************************************
* driver::rem_receive_data_callback tests *
*********************************************/
static void test_netdev_dummy_rem_cb_dev_null(void)
{
TEST_ASSERT_EQUAL_INT(-ENODEV, dev->driver->rem_receive_data_callback(NULL,
_fill_received));
}
static void test_netdev_dummy_rem_cb_dev_wrong(void)
{
netdev_t wrong_dev;
TEST_ASSERT_EQUAL_INT(-ENODEV, dev->driver->rem_receive_data_callback(
&wrong_dev, _fill_received));
}
static void test_netdev_dummy_rem_cb_unknown_cb(void)
{
TEST_ASSERT_EQUAL_INT(0, dev->driver->rem_receive_data_callback(
dev, _fill_received));
}
static void test_netdev_dummy_rem_cb_successful(void)
{
char src[] = TEST_STRING64;
size_t src_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char data[] = TEST_STRING8;
#if UNITTESTS_NETDEV_DUMMY_MAX_PACKET < 8
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET;
#else
size_t data_len = 8;
#endif
TEST_ASSERT_EQUAL_INT(0, dev->driver->add_receive_data_callback(dev,
_fill_received));
TEST_ASSERT_EQUAL_INT(0, unittest_netdev_dummy_fire_rcv_event(dev, src,
src_len, dest, dest_len, data, data_len));
_reset_received();
TEST_ASSERT_EQUAL_INT(0, dev->driver->rem_receive_data_callback(dev,
_fill_received));
TEST_ASSERT_EQUAL_INT(0, unittest_netdev_dummy_fire_rcv_event(dev, src,
src_len, dest, dest_len, data, data_len));
TEST_ASSERT_EQUAL_INT(0, received_src_len);
TEST_ASSERT_EQUAL_INT(0, received_dst_len);
TEST_ASSERT_EQUAL_INT(0, received_data_len);
for (int i = 0; i < UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN; i++) {
TEST_ASSERT_EQUAL_INT(0, received_src[i]);
}
for (int i = 0; i < UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN; i++) {
TEST_ASSERT_EQUAL_INT(0, received_dst[i]);
}
for (int i = 0; i < UNITTESTS_NETDEV_DUMMY_MAX_PACKET; i++) {
TEST_ASSERT_EQUAL_INT(0, received_data[i]);
}
}
static void test_netdev_dummy_rem_cb_multiple_added(void)
{
char src[] = TEST_STRING64;
size_t src_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char data[] = TEST_STRING8;
#if UNITTESTS_NETDEV_DUMMY_MAX_PACKET < 8
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET;
#else
size_t data_len = 8;
#endif
TEST_ASSERT_EQUAL_INT(0, dev->driver->add_receive_data_callback(dev,
_fill_received));
TEST_ASSERT_EQUAL_INT(0, unittest_netdev_dummy_fire_rcv_event(dev, src,
src_len, dest, dest_len, data, data_len));
_reset_received();
TEST_ASSERT_EQUAL_INT(0, dev->driver->add_receive_data_callback(dev,
_always_wrong));
TEST_ASSERT_EQUAL_INT(-ECANCELED, unittest_netdev_dummy_fire_rcv_event(
dev, src, src_len, dest, dest_len, data, data_len));
TEST_ASSERT_EQUAL_INT(0, dev->driver->rem_receive_data_callback(dev,
_always_wrong));
TEST_ASSERT_EQUAL_INT(0, unittest_netdev_dummy_fire_rcv_event(dev, src,
src_len, dest, dest_len, data, data_len));
TEST_ASSERT_EQUAL_INT(src_len, received_src_len);
TEST_ASSERT_EQUAL_INT(0, memcmp(received_src, src, src_len));
TEST_ASSERT_EQUAL_INT(dest_len, received_dst_len);
TEST_ASSERT_EQUAL_INT(0, memcmp(received_dst, dest, dest_len));
TEST_ASSERT_EQUAL_INT(data_len, received_data_len);
TEST_ASSERT_EQUAL_INT(0, memcmp(received_data, data, data_len));
}
/*********************************************
* driver::get_option tests *
*********************************************/
static void test_netdev_dummy_get_option_dev_null(void)
{
unsigned int value = (unsigned int)TEST_UINT32;
size_t value_len = sizeof(unsigned int);
TEST_ASSERT_EQUAL_INT(-ENODEV, dev->driver->get_option(NULL, RANDOM_OPTION,
&value, &value_len));
}
static void test_netdev_dummy_get_option_dev_wrong(void)
{
unsigned int value = (unsigned int)TEST_UINT32;
size_t value_len = sizeof(unsigned int);
netdev_t wrong_dev;
TEST_ASSERT_EQUAL_INT(-ENODEV, dev->driver->get_option(&wrong_dev,
RANDOM_OPTION, &value, &value_len));
}
static void test_netdev_dummy_get_option_null_value(void)
{
size_t value_len = sizeof(unsigned int);
TEST_ASSERT_EQUAL_INT(-EFAULT, dev->driver->get_option(dev,
RANDOM_OPTION, NULL, &value_len));
}
static void test_netdev_dummy_get_option_null_value_len(void)
{
unsigned int value = (unsigned int)TEST_UINT32;
TEST_ASSERT_EQUAL_INT(-EFAULT, dev->driver->get_option(dev,
RANDOM_OPTION, &value, NULL));
TEST_ASSERT_EQUAL_INT((unsigned int)TEST_UINT32, value);
}
static void test_netdev_dummy_get_option_overflow(void)
{
unsigned int value = (unsigned int)TEST_UINT32;
size_t value_len = 0;
TEST_ASSERT_EQUAL_INT(-EOVERFLOW, dev->driver->get_option(dev,
RANDOM_OPTION, &value, &value_len));
TEST_ASSERT_EQUAL_INT((unsigned int)TEST_UINT32, value);
}
static void test_netdev_dummy_get_option_not_supported(void)
{
unsigned int value = (unsigned int)TEST_UINT32;
size_t value_len = 0;
TEST_ASSERT_EQUAL_INT(-ENOTSUP, dev->driver->get_option(dev,
(netdev_opt_t)0xffffffff, &value, &value_len));
TEST_ASSERT_EQUAL_INT((unsigned int)TEST_UINT32, value);
}
static void test_netdev_dummy_get_channel(void)
{
unsigned int value = (unsigned int)TEST_UINT32;
size_t value_len = sizeof(unsigned int) + TEST_UINT8;
TEST_ASSERT_EQUAL_INT(0, dev->driver->get_option(dev, NETDEV_OPT_CHANNEL,
&value, &value_len));
TEST_ASSERT_EQUAL_INT(0, value);
TEST_ASSERT_EQUAL_INT(sizeof(unsigned int), value_len);
}
static void test_netdev_dummy_get_address(void)
{
uint8_t value[UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN];
size_t value_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN + TEST_UINT8;
TEST_ASSERT_EQUAL_INT(0, dev->driver->get_option(dev, NETDEV_OPT_ADDRESS,
value, &value_len));
for (int i = 0; i < UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN; i++) {
TEST_ASSERT_EQUAL_INT(0, value[i]);
}
TEST_ASSERT_EQUAL_INT(UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN, value_len);
}
static void test_netdev_dummy_get_nid(void)
{
unsigned int value = (unsigned int)TEST_UINT32;
size_t value_len = sizeof(unsigned int) + TEST_UINT8;
TEST_ASSERT_EQUAL_INT(0, dev->driver->get_option(dev, NETDEV_OPT_NID,
&value, &value_len));
TEST_ASSERT_EQUAL_INT(0, value);
TEST_ASSERT_EQUAL_INT(sizeof(unsigned int), value_len);
}
static void test_netdev_dummy_get_long_address(void)
{
uint8_t value[UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN];
size_t value_len = UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN + TEST_UINT8;
TEST_ASSERT_EQUAL_INT(0, dev->driver->get_option(dev, NETDEV_OPT_ADDRESS_LONG,
value, &value_len));
for (int i = 0; i < UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN; i++) {
TEST_ASSERT_EQUAL_INT(0, value[i]);
}
TEST_ASSERT_EQUAL_INT(UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN, value_len);
}
static void test_netdev_dummy_get_tx_power(void)
{
int value = TEST_INT;
size_t value_len = sizeof(int) + TEST_UINT8;
TEST_ASSERT_EQUAL_INT(0, dev->driver->get_option(dev, NETDEV_OPT_TX_POWER,
&value, &value_len));
TEST_ASSERT_EQUAL_INT(0, value);
TEST_ASSERT_EQUAL_INT(sizeof(int), value_len);
}
/*********************************************
* driver::set_option tests *
*********************************************/
static void test_netdev_dummy_set_option_dev_null(void)
{
unsigned int value = (unsigned int)TEST_UINT32;
int res = -ENOTSUP;
netdev_opt_t opt = RANDOM_OPTION;
while (res == -ENOTSUP) {
res = dev->driver->set_option(NULL, opt, &value, sizeof(unsigned int));
opt = (opt + 1) % OPTION_NUMBER;
}
TEST_ASSERT_EQUAL_INT(-ENODEV, res);
}
static void test_netdev_dummy_set_option_dev_wrong(void)
{
int value = (unsigned int)TEST_INT;
netdev_t wrong_dev;
int res = -ENOTSUP;
netdev_opt_t opt = RANDOM_OPTION;
while (res == -ENOTSUP) {
res = dev->driver->set_option(&wrong_dev, opt, &value,
sizeof(unsigned int));
opt = (opt + 1) % OPTION_NUMBER;
}
TEST_ASSERT_EQUAL_INT(-ENODEV, res);
}
static void test_netdev_dummy_set_option_null_value(void)
{
int res = -ENOTSUP;
netdev_opt_t opt = RANDOM_OPTION;
while (res == -ENOTSUP) {
res = dev->driver->set_option(dev, opt, NULL, sizeof(unsigned int));
opt = (opt + 1) % OPTION_NUMBER;
}
TEST_ASSERT_EQUAL_INT(-EFAULT, res);
}
static void test_netdev_dummy_set_option_inval(void)
{
unsigned int value = (unsigned int)TEST_UINT32;
int res = -ENOTSUP;
netdev_opt_t opt = RANDOM_OPTION;
while (res == -ENOTSUP) {
res = dev->driver->set_option(dev, opt, &value, 0);
opt = (opt + 1) % OPTION_NUMBER;
}
TEST_ASSERT_EQUAL_INT(-EINVAL, res);
TEST_ASSERT_EQUAL_INT((unsigned int)TEST_UINT32, value);
}
static void test_netdev_dummy_set_option_overflow(void)
{
unsigned int value = (unsigned int)TEST_UINT32;
size_t value_len = UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN + TEST_UINT8 + 1;
int res = -ENOTSUP;
netdev_opt_t opt = RANDOM_OPTION;
while (res == -ENOTSUP) {
res = dev->driver->set_option(dev, opt, &value, value_len);
opt = (opt + 1) % OPTION_NUMBER;
}
TEST_ASSERT_EQUAL_INT(-EOVERFLOW, res);
TEST_ASSERT_EQUAL_INT((unsigned int)TEST_UINT32, value);
}
static void test_netdev_dummy_set_option_not_supported(void)
{
unsigned int value = (unsigned int)TEST_UINT32;
TEST_ASSERT_EQUAL_INT(-ENOTSUP, dev->driver->set_option(dev,
(netdev_opt_t)0xffffffff, &value, sizeof(unsigned int)));
TEST_ASSERT_EQUAL_INT((unsigned int)TEST_UINT32, value);
}
static void test_netdev_dummy_set_get_channel(void)
{
unsigned int value = (unsigned int)TEST_UINT32;
size_t value_len = sizeof(unsigned int);
TEST_ASSERT_EQUAL_INT(0, dev->driver->set_option(dev, NETDEV_OPT_CHANNEL,
&value, sizeof(unsigned int)));
value = 0;
TEST_ASSERT_EQUAL_INT(0, dev->driver->get_option(dev, NETDEV_OPT_CHANNEL,
&value, &value_len));
TEST_ASSERT_EQUAL_INT((unsigned int)TEST_UINT32, value);
TEST_ASSERT_EQUAL_INT(sizeof(unsigned int), value_len);
}
static void test_netdev_dummy_set_get_address(void)
{
char value[UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN];
size_t value_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
#if UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN < 12
strncpy(value, TEST_STRING12, UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN);
#else
strncpy(value, TEST_STRING12, 12);
#endif
TEST_ASSERT_EQUAL_INT(0, dev->driver->set_option(dev, NETDEV_OPT_ADDRESS,
value, UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN));
#if UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN < 12
memset(value, 0, UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN);
#else
memset(value, 0, 12);
#endif
TEST_ASSERT_EQUAL_INT(0, dev->driver->get_option(dev, NETDEV_OPT_ADDRESS,
value, &value_len));
#if UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN < 12
TEST_ASSERT(strncmp(value, TEST_STRING12,
UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN) == 0)
#else
TEST_ASSERT(strncmp(value, TEST_STRING12, 12) == 0)
#endif
}
static void test_netdev_dummy_set_get_nid(void)
{
unsigned int value = (unsigned int)TEST_UINT32;
size_t value_len = sizeof(unsigned int);
TEST_ASSERT_EQUAL_INT(0, dev->driver->set_option(dev, NETDEV_OPT_NID,
&value, sizeof(unsigned int)));
value = 0;
TEST_ASSERT_EQUAL_INT(0, dev->driver->get_option(dev, NETDEV_OPT_NID,
&value, &value_len));
TEST_ASSERT_EQUAL_INT((unsigned int)TEST_UINT32, value);
TEST_ASSERT_EQUAL_INT(sizeof(unsigned int), value_len);
}
static void test_netdev_dummy_set_get_long_address(void)
{
char value[UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN];
size_t value_len = UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN;
#if UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN < 12
strncpy(value, TEST_STRING12, UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN);
#else
strncpy(value, TEST_STRING12, 12);
#endif
TEST_ASSERT_EQUAL_INT(0, dev->driver->set_option(dev,
NETDEV_OPT_ADDRESS_LONG, value,
UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN));
#if UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN < 12
memset(value, 0, UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN);
#else
memset(value, 0, 12);
#endif
TEST_ASSERT_EQUAL_INT(0, dev->driver->get_option(dev,
NETDEV_OPT_ADDRESS_LONG, value, &value_len));
#if UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN < 12
TEST_ASSERT(strncmp(value, TEST_STRING12,
UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN) == 0)
#else
TEST_ASSERT(strncmp(value, TEST_STRING12, 12) == 0)
#endif
TEST_ASSERT_EQUAL_INT(UNITTESTS_NETDEV_DUMMY_MAX_LONG_ADDR_LEN, value_len);
}
static void test_netdev_dummy_set_get_tx_power(void)
{
int value = TEST_INT;
size_t value_len = sizeof(int);
TEST_ASSERT_EQUAL_INT(0, dev->driver->set_option(dev, NETDEV_OPT_TX_POWER,
&value, sizeof(int)));
value = 0;
TEST_ASSERT_EQUAL_INT(0, dev->driver->get_option(dev, NETDEV_OPT_TX_POWER,
&value, &value_len));
TEST_ASSERT_EQUAL_INT(TEST_INT, value);
TEST_ASSERT_EQUAL_INT(sizeof(int), value_len);
}
/*********************************************
* driver::get_state tests *
*********************************************/
static void test_netdev_dummy_get_state_dev_null(void)
{
netdev_state_t state;
TEST_ASSERT_EQUAL_INT(-ENODEV, dev->driver->get_state(NULL, &state));
}
static void test_netdev_dummy_get_state_dev_wrong(void)
{
netdev_state_t state;
netdev_t wrong_dev;
TEST_ASSERT_EQUAL_INT(-ENODEV, dev->driver->get_state(&wrong_dev, &state));
}
static void test_netdev_dummy_get_state_null(void)
{
TEST_ASSERT_EQUAL_INT(-EFAULT, dev->driver->get_state(dev, NULL));
}
static void test_netdev_dummy_get_state_value(void)
{
netdev_state_t state;
TEST_ASSERT_EQUAL_INT(0, dev->driver->get_state(dev, &state));
TEST_ASSERT_EQUAL_INT(NETDEV_STATE_POWER_OFF, state);
}
/*********************************************
* driver::set_state tests *
*********************************************/
static void test_netdev_dummy_set_state_dev_null(void)
{
TEST_ASSERT_EQUAL_INT(-ENODEV, dev->driver->set_state(NULL,
NETDEV_STATE_RX_MODE));
}
static void test_netdev_dummy_set_state_dev_wrong(void)
{
netdev_t wrong_dev;
TEST_ASSERT_EQUAL_INT(-ENODEV, dev->driver->set_state(&wrong_dev,
NETDEV_STATE_RX_MODE));
}
static void test_netdev_dummy_set_state_max(void)
{
TEST_ASSERT_EQUAL_INT(-ENOTSUP,
dev->driver->set_state(dev, (netdev_state_t)0xffffffff));
}
static void test_netdev_dummy_set_state_value(void)
{
TEST_ASSERT_EQUAL_INT(0,
dev->driver->set_state(dev, NETDEV_STATE_RX_MODE));
}
static void test_netdev_dummy_set_get_state_value(void)
{
netdev_state_t state;
TEST_ASSERT_EQUAL_INT(0, dev->driver->get_state(dev, &state));
TEST_ASSERT(NETDEV_STATE_POWER_IDLE != state);
state = NETDEV_STATE_POWER_IDLE;
TEST_ASSERT_EQUAL_INT(0, dev->driver->set_state(dev, state));
TEST_ASSERT_EQUAL_INT(0, dev->driver->get_state(dev, &state));
TEST_ASSERT_EQUAL_INT(NETDEV_STATE_POWER_IDLE, state);
}
/*********************************************
* driver::event tests *
*********************************************/
static void test_netdev_dummy_event_dev_null(void)
{
dev->driver->event(NULL, TEST_UINT32);
TEST_ASSERT_EQUAL_INT(0, unittest_netdev_dummy_get_last_event(dev));
}
static void test_netdev_dummy_event_dev_wrong(void)
{
netdev_t wrong_dev;
dev->driver->event(&wrong_dev, TEST_UINT32);
TEST_ASSERT_EQUAL_INT(0, unittest_netdev_dummy_get_last_event(dev));
}
static void test_netdev_dummy_event_value(void)
{
TEST_ASSERT_EQUAL_INT(0, unittest_netdev_dummy_get_last_event(dev));
dev->driver->event(dev, TEST_UINT32);
TEST_ASSERT_EQUAL_INT((unsigned int)TEST_UINT32, unittest_netdev_dummy_get_last_event(dev));
}
/***********************************************
* unittest_netdev_dummy_fire_rcv_event tests *
***********************************************/
static void test_netdev_dummy_fire_rcv_event_dev_null(void)
{
char src[] = TEST_STRING64;
size_t src_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char data[] = TEST_STRING8;
#if UNITTESTS_NETDEV_DUMMY_MAX_PACKET < 8
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET;
#else
size_t data_len = 8;
#endif
TEST_ASSERT_EQUAL_INT(-ENODEV, unittest_netdev_dummy_fire_rcv_event(NULL,
src, src_len, dest, dest_len, data, data_len));
}
static void test_netdev_dummy_fire_rcv_event_dev_wrong(void)
{
char src[] = TEST_STRING64;
size_t src_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char data[] = TEST_STRING8;
#if UNITTESTS_NETDEV_DUMMY_MAX_PACKET < 8
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET;
#else
size_t data_len = 8;
#endif
netdev_t wrong_dev;
TEST_ASSERT_EQUAL_INT(-ENODEV, unittest_netdev_dummy_fire_rcv_event(
&wrong_dev, src, src_len, dest, dest_len, data,
data_len));
}
static void test_netdev_dummy_fire_rcv_event_data_too_long(void)
{
char src[] = TEST_STRING64;
size_t src_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char data[] = TEST_STRING64;
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET + 1;
TEST_ASSERT_EQUAL_INT(-EMSGSIZE, unittest_netdev_dummy_fire_rcv_event(dev,
src, src_len, dest, dest_len, data, data_len));
}
static void test_netdev_dummy_fire_rcv_event_data_null(void)
{
char src[] = TEST_STRING64;
size_t src_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET;
TEST_ASSERT_EQUAL_INT(-EINVAL, unittest_netdev_dummy_fire_rcv_event(dev,
src, src_len, dest, dest_len, NULL, data_len));
}
static void test_netdev_dummy_fire_rcv_event_data_null_data_len_null(void)
{
char src[] = TEST_STRING64;
size_t src_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
TEST_ASSERT_EQUAL_INT(0, unittest_netdev_dummy_fire_rcv_event(dev,
src, src_len, dest, dest_len, NULL, 0));
}
static void test_netdev_dummy_fire_rcv_event_src_too_long(void)
{
char src[] = TEST_STRING64;
size_t src_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN + 1;
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char data[] = TEST_STRING8;
#if UNITTESTS_NETDEV_DUMMY_MAX_PACKET < 8
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET;
#else
size_t data_len = 8;
#endif
TEST_ASSERT_EQUAL_INT(-EAFNOSUPPORT, unittest_netdev_dummy_fire_rcv_event(
dev, src, src_len, dest, dest_len, data, data_len));
}
static void test_netdev_dummy_fire_rcv_event_src_null(void)
{
size_t src_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char data[] = TEST_STRING64;
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET;
TEST_ASSERT_EQUAL_INT(-EINVAL, unittest_netdev_dummy_fire_rcv_event(dev,
NULL, src_len, dest, dest_len, data, data_len));
}
static void test_netdev_dummy_fire_rcv_event_dest_too_long(void)
{
char src[] = TEST_STRING64;
size_t src_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN + 1;
char data[] = TEST_STRING8;
#if UNITTESTS_NETDEV_DUMMY_MAX_PACKET < 8
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET;
#else
size_t data_len = 8;
#endif
TEST_ASSERT_EQUAL_INT(-EAFNOSUPPORT, unittest_netdev_dummy_fire_rcv_event(
dev, src, src_len, dest, dest_len, data,
data_len));
}
static void test_netdev_dummy_fire_rcv_event_dest_null(void)
{
char src[] = TEST_STRING64;
size_t src_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char data[] = TEST_STRING64;
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET;
TEST_ASSERT_EQUAL_INT(-EINVAL, unittest_netdev_dummy_fire_rcv_event(dev,
src, src_len, NULL, dest_len, data, data_len));
}
static void test_netdev_dummy_fire_rcv_event_no_cb(void)
{
char src[] = TEST_STRING64;
size_t src_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char data[] = TEST_STRING8;
#if UNITTESTS_NETDEV_DUMMY_MAX_PACKET < 8
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET;
#else
size_t data_len = 8;
#endif
TEST_ASSERT_EQUAL_INT(0, unittest_netdev_dummy_fire_rcv_event(dev, src,
src_len, dest, dest_len, data, data_len));
}
static void test_netdev_dummy_fire_rcv_event_failing_cb(void)
{
char src[] = TEST_STRING64;
size_t src_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char dest[] = TEST_STRING64;
size_t dest_len = UNITTESTS_NETDEV_DUMMY_MAX_ADDR_LEN;
char data[] = TEST_STRING8;
#if UNITTESTS_NETDEV_DUMMY_MAX_PACKET < 8
size_t data_len = UNITTESTS_NETDEV_DUMMY_MAX_PACKET;
#else
size_t data_len = 8;
#endif
TEST_ASSERT_EQUAL_INT(0, dev->driver->add_receive_data_callback(dev,
_always_wrong));
TEST_ASSERT_EQUAL_INT(-ECANCELED, unittest_netdev_dummy_fire_rcv_event(
dev, src, src_len, dest, dest_len, data, data_len));
}
/***********************************************
* unittest_netdev_dummy_get_last_event tests *
***********************************************/
static void test_netdev_dummy_last_event_dev_null(void)
{
TEST_ASSERT_EQUAL_INT(ENODEV, unittest_netdev_dummy_get_last_event(NULL));
}
static void test_netdev_dummy_last_event_dev_wrong(void)
{
netdev_t wrong_dev;
TEST_ASSERT_EQUAL_INT(ENODEV, unittest_netdev_dummy_get_last_event(&wrong_dev));
}
Test *tests_netdev_dummy_tests(void)
{
EMB_UNIT_TESTFIXTURES(fixtures) {
/* driver::init tests */
new_TestFixture(test_netdev_dummy_init_dev_null),
new_TestFixture(test_netdev_dummy_init_dev_wrong),
/* driver::send_data tests */
new_TestFixture(test_netdev_dummy_send_data_dev_null),
new_TestFixture(test_netdev_dummy_send_data_dev_wrong),
new_TestFixture(test_netdev_dummy_send_data_dest_too_long),
new_TestFixture(test_netdev_dummy_send_data_data_too_long),
new_TestFixture(test_netdev_dummy_send_data_no_ulhs),
#if UNITTESTS_NETDEV_DUMMY_MAX_PACKET > 4
new_TestFixture(test_netdev_dummy_send_data_with_ulhs),
#endif
/* driver::add_receive_data_callback tests */
new_TestFixture(test_netdev_dummy_add_cb_dev_null),
new_TestFixture(test_netdev_dummy_add_cb_dev_wrong),
new_TestFixture(test_netdev_dummy_add_cb_buffer_full),
new_TestFixture(test_netdev_dummy_add_cb_successful),
/* driver::rem_receive_data_callback tests */
new_TestFixture(test_netdev_dummy_rem_cb_dev_null),
new_TestFixture(test_netdev_dummy_rem_cb_dev_wrong),
new_TestFixture(test_netdev_dummy_rem_cb_unknown_cb),
new_TestFixture(test_netdev_dummy_rem_cb_successful),
new_TestFixture(test_netdev_dummy_rem_cb_multiple_added),
/* driver::get_option tests */
new_TestFixture(test_netdev_dummy_get_option_dev_null),
new_TestFixture(test_netdev_dummy_get_option_dev_wrong),
new_TestFixture(test_netdev_dummy_get_option_null_value),
new_TestFixture(test_netdev_dummy_get_option_null_value_len),
new_TestFixture(test_netdev_dummy_get_option_overflow),
new_TestFixture(test_netdev_dummy_get_option_not_supported),
new_TestFixture(test_netdev_dummy_get_channel),
new_TestFixture(test_netdev_dummy_get_address),
new_TestFixture(test_netdev_dummy_get_nid),
new_TestFixture(test_netdev_dummy_get_long_address),
new_TestFixture(test_netdev_dummy_get_tx_power),
/* driver::set_option tests */
new_TestFixture(test_netdev_dummy_set_option_dev_null),
new_TestFixture(test_netdev_dummy_set_option_dev_wrong),
new_TestFixture(test_netdev_dummy_set_option_null_value),
new_TestFixture(test_netdev_dummy_set_option_inval),
new_TestFixture(test_netdev_dummy_set_option_overflow),
new_TestFixture(test_netdev_dummy_set_option_not_supported),
new_TestFixture(test_netdev_dummy_set_get_channel),
new_TestFixture(test_netdev_dummy_set_get_address),
new_TestFixture(test_netdev_dummy_set_get_nid),
new_TestFixture(test_netdev_dummy_set_get_long_address),
new_TestFixture(test_netdev_dummy_set_get_tx_power),
/* driver::get_state tests */
new_TestFixture(test_netdev_dummy_get_state_dev_null),
new_TestFixture(test_netdev_dummy_get_state_dev_wrong),
new_TestFixture(test_netdev_dummy_get_state_null),
new_TestFixture(test_netdev_dummy_get_state_value),
/* driver::set_state tests */
new_TestFixture(test_netdev_dummy_set_state_dev_null),
new_TestFixture(test_netdev_dummy_set_state_dev_wrong),
new_TestFixture(test_netdev_dummy_set_state_max),
new_TestFixture(test_netdev_dummy_set_state_value),
new_TestFixture(test_netdev_dummy_set_get_state_value),
/* driver::event tests */
new_TestFixture(test_netdev_dummy_event_dev_null),
new_TestFixture(test_netdev_dummy_event_dev_wrong),
new_TestFixture(test_netdev_dummy_event_value),
/* unittest_netdev_dummy_fire_rcv_event tests */
new_TestFixture(test_netdev_dummy_fire_rcv_event_dev_null),
new_TestFixture(test_netdev_dummy_fire_rcv_event_dev_wrong),
new_TestFixture(test_netdev_dummy_fire_rcv_event_data_too_long),
new_TestFixture(test_netdev_dummy_fire_rcv_event_data_null),
new_TestFixture(test_netdev_dummy_fire_rcv_event_data_null_data_len_null),
new_TestFixture(test_netdev_dummy_fire_rcv_event_src_too_long),
new_TestFixture(test_netdev_dummy_fire_rcv_event_src_null),
new_TestFixture(test_netdev_dummy_fire_rcv_event_dest_too_long),
new_TestFixture(test_netdev_dummy_fire_rcv_event_dest_null),
new_TestFixture(test_netdev_dummy_fire_rcv_event_no_cb),
new_TestFixture(test_netdev_dummy_fire_rcv_event_failing_cb),
/* unittest_netdev_dummy_get_last_event tests */
new_TestFixture(test_netdev_dummy_last_event_dev_null),
new_TestFixture(test_netdev_dummy_last_event_dev_wrong),
};
EMB_UNIT_TESTCALLER(netdev_dummy_tests, set_up, tear_down,
fixtures);
return (Test *)&netdev_dummy_tests;
}
void tests_netdev_dummy(void)
{
TESTS_RUN(tests_netdev_dummy_tests());
}

37
tests/unittests/tests-netdev_dummy/tests-netdev_dummy.h Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright (C) 2014 Martin Lenders
*
* 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.
*/
/**
* @addtogroup unittests
* @{
*
* @file tests-netdev_dummy.h
* @brief Unittests for the ``netdev_dummy`` module
*
* @author Martine Lenders <mlenders@inf.fu-berlin.de>
*/
#ifndef __TESTS_NETDEV_DUMMY_H_
#define __TESTS_NETDEV_DUMMY_H_
#include "../unittests.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief The entry point of this test suite.
*/
void tests_netdev_dummy(void);
#ifdef __cplusplus
}
#endif
#endif /* __TESTS_NETDEV_DUMMY_H_ */
/** @} */