RIOT-OS/RIOT
RIOT-OS/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2024-12-29 04:50:03 +01:00
Code Releases Activity
b318d2607c
RIOT/tests/netdev/main.c
Joakim Gebart 7203013040 tests/netdev: Add missing inttypes.h include
2015-07-07 00:53:27 +02:00

1086 lines
29 KiB
C
Raw Blame History

/*
* Copyright (C) 2014 Martine Lenders <mlenders@inf.fu-berlin.de>
*
* 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.
*/
/**
* @ingroup tests
* @{
*
* @file
* @brief Tests for general network device interface
*
*
* @author Martine Lenders <mlenders@inf.fu-berlin.de>
*
* @}
*/
#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <inttypes.h>
#ifdef MODULE_NATIVENET
#include "nativenet.h"
#endif
#include "net_help.h"
#include "netdev/base.h"
#include "netdev/default.h"
#ifdef NETDEV_DEFAULT
#define SHELL_BUFSIZE (UART0_BUFSIZE)
static size_t dev_address_len = 0;
static netdev_t *dev = NULL;
/***********************************
* helper functions *
***********************************/
static inline int _got_uint8_value(char *param_name, uint8_t *value_ptr, size_t value_len,
uint8_t check_value, uint8_t value_exp)
{
printf("Got %s of value %" PRIu8 " of length %zu\n", param_name, *value_ptr, value_len);
if (check_value) {
return (*value_ptr == value_exp) ? 1 : 0;
}
else {
return 1;
}
}
static inline int _got_uint16_value(char *param_name, uint16_t *value_ptr, size_t value_len,
uint8_t check_value, uint16_t value_exp)
{
printf("Got %s of value %" PRIu16 " of length %zu\n", param_name, *value_ptr, value_len);
if (check_value) {
return (*value_ptr == value_exp) ? 1 : 0;
}
else {
return 1;
}
}
static inline int _got_uint32_value(char *param_name, uint32_t *value_ptr, size_t value_len,
uint8_t check_value, uint32_t value_exp)
{
printf("Got %s of value %" PRIu32 " of length %zu\n", param_name, *value_ptr, value_len);
if (check_value) {
return (*value_ptr == value_exp) ? 1 : 0;
}
else {
return 1;
}
}
static inline int _got_uint64_value(char *param_name, uint64_t *value_ptr, size_t value_len,
uint8_t check_value, uint64_t value_exp)
{
printf("Got %s of value %" PRIu64 " of length %zu\n", param_name, *value_ptr, value_len);
if (check_value) {
return (*value_ptr == value_exp) ? 1 : 0;
}
else {
return 1;
}
}
/***********************************
* test channel *
***********************************/
static int init_channel(void)
{
uint8_t channel = NETDEV_TEST_CHANNEL;
int res = dev->driver->set_option(dev, NETDEV_OPT_CHANNEL,
&channel, sizeof(uint8_t));
switch (res) {
case 0:
printf("Channel was set to %" PRIu8 "\n", channel);
return 1;
case -EINVAL:
printf("Channel %" PRIu8 " not supported\n", channel);
break;
case -ENODEV:
puts("Device was not initialized");
break;
case -ENOTSUP:
puts("Does not support setting the channel");
return 2;
case -EOVERFLOW:
puts("1 byte overflows o_o?!!?");
break;
default:
puts("unknown error");
break;
}
return 0;
}
static int check_channel(void)
{
uint8_t channel[sizeof(uint64_t)];
size_t channel_len = sizeof(uint64_t);
int res = dev->driver->get_option(dev, NETDEV_OPT_CHANNEL,
&channel, &channel_len);
switch (res) {
case 0:
switch (channel_len) {
case 1:
return _got_uint8_value("channel", (uint8_t *)channel, channel_len, 1, NETDEV_TEST_CHANNEL);
case 2:
return _got_uint16_value("channel", (uint16_t *)channel, channel_len, 1, NETDEV_TEST_CHANNEL);
case 4:
return _got_uint32_value("channel", (uint32_t *)channel, channel_len, 1, NETDEV_TEST_CHANNEL);
case 8:
return _got_uint64_value("channel", (uint64_t *)channel, channel_len, 1, NETDEV_TEST_CHANNEL);
default:
printf("Unexpected channel type of length %u:", channel_len);
for (size_t i = 0; i < channel_len; i++) {
printf(" %02x", channel[i]);
}
printf("\n");
return 0;
}
case -ENODEV:
puts("Device was not initialized");
break;
case -ENOTSUP:
puts("Does not support getting of channel");
return 2;
case -EOVERFLOW:
puts("Channel type bigger then 64 bit.");
break;
default:
puts("unknown error");
break;
}
return 0;
}
/***********************************
* test address *
***********************************/
static int init_address(void)
{
uint8_t address = NETDEV_TEST_ADDRESS;
int res = dev->driver->set_option(dev, NETDEV_OPT_ADDRESS,
&address, sizeof(uint8_t));
switch (res) {
case 0:
printf("Address was set to %" PRIu8 "\n", address);
return 1;
case -EINVAL:
printf("Address %" PRIu8 " not supported\n", address);
break;
case -ENODEV:
puts("Device was not initialized");
break;
case -ENOTSUP:
puts("Does not support setting the address");
return 2;
case -EOVERFLOW:
puts("1 byte overflows o_o?!!?");
break;
default:
puts("unknown error");
break;
}
return 0;
}
static int check_address(void)
{
uint8_t address[sizeof(uint64_t)];
size_t address_len = sizeof(uint64_t);
int res = dev->driver->get_option(dev, NETDEV_OPT_ADDRESS,
&address, &address_len);
switch (res) {
case 0:
dev_address_len = address_len;
switch (address_len) {
case 1:
return _got_uint8_value("address", (uint8_t *)address, address_len, 1, NETDEV_TEST_ADDRESS);
case 2:
return _got_uint16_value("address", (uint16_t *)address, address_len, 1, NETDEV_TEST_ADDRESS);
case 4:
return _got_uint32_value("address", (uint32_t *)address, address_len, 1, NETDEV_TEST_ADDRESS);
case 6:
printf("Got address of length %u of value: ", address_len);
for (size_t i = 0; i < address_len; i++) {
printf(" %02x", address[i]);
}
printf("\n");
return 1;
case 8:
return _got_uint64_value("address", (uint64_t *)address, address_len, 1, NETDEV_TEST_ADDRESS);
default:
printf("Unexpected address type of length %u:", address_len);
for (size_t i = 0; i < address_len; i++) {
printf(" %02x", address[i]);
}
printf("\n");
return 0;
}
case -ENODEV:
puts("Device was not initialized");
break;
case -ENOTSUP:
puts("Does not support getting the address");
return 2;
case -EOVERFLOW:
puts("Address type bigger then 64 bit.");
break;
default:
puts("unknown error");
break;
}
return 0;
}
/***********************************
* test long address *
***********************************/
static int init_long_address(void)
{
uint8_t address = NETDEV_TEST_ADDRESS;
int res = dev->driver->set_option(dev, NETDEV_OPT_ADDRESS_LONG,
&address, sizeof(uint8_t));
switch (res) {
case 0:
printf("Long address was set to %" PRIu8 "\n", address);
return 1;
case -EINVAL:
printf("Long address %" PRIu8 " not supported\n", address);
break;
case -ENODEV:
puts("Device was not initialized");
break;
case -ENOTSUP:
puts("Does not support setting the long address");
return 2;
case -EOVERFLOW:
puts("1 byte overflows o_o?!!?");
break;
default:
puts("unknown error");
break;
}
return 0;
}
static int check_long_address(void)
{
uint8_t address[sizeof(uint64_t)];
size_t address_len = sizeof(uint64_t);
int res = dev->driver->get_option(dev, NETDEV_OPT_ADDRESS_LONG,
&address, &address_len);
switch (res) {
case 0:
switch (address_len) {
case 1:
return _got_uint8_value("long address", (uint8_t *)address, address_len, 1, NETDEV_TEST_ADDRESS);
case 2:
return _got_uint16_value("long address", (uint16_t *)address, address_len, 1, NETDEV_TEST_ADDRESS);
case 4:
return _got_uint32_value("long address", (uint32_t *)address, address_len, 1, NETDEV_TEST_ADDRESS);
case 6:
printf("Got long address of length %u of value: ", address_len);
for (size_t i = 0; i < address_len; i++) {
printf(" %02x", address[i]);
}
printf("\n");
return 1;
case 8:
return _got_uint64_value("long address", (uint64_t *)address, address_len, 1, NETDEV_TEST_ADDRESS);
default:
printf("Unexpected long address type of length %u:", address_len);
for (size_t i = 0; i < address_len; i++) {
printf(" %02x", address[i]);
}
printf("\n");
return 0;
}
case -ENODEV:
puts("Device was not initialized");
break;
case -ENOTSUP:
puts("Does not support getting the long address");
return 2;
case -EOVERFLOW:
puts("Long address type bigger then 64 bit.");
break;
default:
puts("unknown error");
break;
}
return 0;
}
/***********************************
* test network ID *
***********************************/
static int init_nid(void)
{
uint8_t nid = NETDEV_TEST_NID;
int res = dev->driver->set_option(dev, NETDEV_OPT_NID,
&nid, sizeof(uint8_t));
switch (res) {
case 0:
printf("Network ID was set to %" PRIu8 "\n", nid);
return 1;
case -EINVAL:
printf("Network ID %" PRIu8 " not supported\n", nid);
break;
case -ENODEV:
puts("Device was not initialized");
break;
case -ENOTSUP:
puts("Does not support setting the network ID");
return 2;
case -EOVERFLOW:
puts("1 byte overflows o_o?!!?");
break;
default:
puts("unknown error");
break;
}
return 0;
}
static int check_nid(void)
{
uint8_t nid[sizeof(uint64_t)];
size_t nid_len = sizeof(uint64_t);
int res = dev->driver->get_option(dev, NETDEV_OPT_NID,
&nid, &nid_len);
switch (res) {
case 0:
switch (nid_len) {
case 1:
return _got_uint8_value("network ID", (uint8_t *)nid, nid_len, 1, NETDEV_TEST_NID);
case 2:
return _got_uint16_value("network ID", (uint16_t *)nid, nid_len, 1, NETDEV_TEST_NID);
case 4:
return _got_uint32_value("network ID", (uint32_t *)nid, nid_len, 1, NETDEV_TEST_NID);
case 8:
return _got_uint64_value("network ID", (uint64_t *)nid, nid_len, 1, NETDEV_TEST_NID);
default:
printf("Unexpected network ID type of length %u:", nid_len);
for (size_t i = 0; i < nid_len; i++) {
printf(" %02x", nid[i]);
}
printf("\n");
return 0;
}
case -ENODEV:
puts("Device was not initialized");
break;
case -ENOTSUP:
puts("Does not support getting the network ID");
return 2;
case -EOVERFLOW:
puts("Network ID type bigger then 64 bit.");
break;
default:
puts("unknown error");
break;
}
return 0;
}
/***********************************
* test maximum packet size *
***********************************/
static int check_max_packet_size(void)
{
uint8_t mps[sizeof(uint64_t)];
size_t mps_len = sizeof(uint64_t);
int res = dev->driver->get_option(dev, NETDEV_OPT_MAX_PACKET_SIZE,
&mps, &mps_len);
switch (res) {
case 0:
switch (mps_len) {
case 1:
return _got_uint8_value("maximum packet size", (uint8_t *)mps, mps_len, 0, 0);
case 2:
return _got_uint16_value("maximum packet size", (uint16_t *)mps, mps_len, 0, 0);
case 4:
return _got_uint32_value("maximum packet size", (uint32_t *)mps, mps_len, 0, 0);
case 8:
return _got_uint64_value("maximum packet size", (uint64_t *)mps, mps_len, 0, 0);
default:
printf("Unexpected maximum packet size type of length %u:", mps_len);
for (size_t i = 0; i < mps_len; i++) {
printf(" %02x", mps[i]);
}
printf("\n");
return 0;
}
case -ENODEV:
puts("Device was not initialized");
break;
case -ENOTSUP:
puts("Does not support getting the maximum packet size");
return 2;
case -EOVERFLOW:
puts("Maximum packet size type bigger then 64 bit.");
break;
default:
puts("unknown error");
break;
}
return 0;
}
/***********************************
* test protocol *
***********************************/
static int check_protocol(void)
{
netdev_proto_t protocol;
size_t protocol_len = sizeof(netdev_proto_t);
int res = dev->driver->get_option(dev, NETDEV_OPT_PROTO,
&protocol, &protocol_len);
switch (res) {
case 0:
if (protocol_len != sizeof(netdev_proto_t)) {
puts("Protocol type is not of length sizeof(netdev_proto_t)");
return 0;
}
switch (protocol) {
case NETDEV_PROTO_UNKNOWN:
puts("Got protocol: Unknown communication type");
return 1;
case NETDEV_PROTO_RADIO:
puts("Got protocol: Radio");
return 1;
case NETDEV_PROTO_802154:
puts("Got protocol: IEEE 802.15.4");
return 1;
case NETDEV_PROTO_6LOWPAN:
puts("Got protocol: 6LoWPAN");
return 1;
case NETDEV_PROTO_IPV6:
puts("Got protocol: IPv6");
return 1;
case NETDEV_PROTO_UDP:
puts("Got protocol: UDP");
return 1;
case NETDEV_PROTO_TCP:
puts("Got protocol: TCP");
return 1;
case NETDEV_PROTO_CCNL:
puts("Got protocol: CCN lite");
return 1;
case NETDEV_PROTO_CC110X:
puts("Got protocol: CC110x");
return 1;
default:
puts("You probably have to update this switch-case.");
return 0;
}
case -ENODEV:
puts("Device was not initialized");
break;
case -ENOTSUP:
puts("Does not support getting the protocol");
return 2;
case -EOVERFLOW:
puts("Protocol type bigger then 64 bit.");
break;
default:
puts("unknown error");
break;
}
return 0;
}
/*************************************
* state tests *
*************************************/
static int init_state(void)
{
int res = dev->driver->set_state(dev, NETDEV_STATE_RX_MODE);
switch (res) {
case 0:
puts("Device was set to RX mode");
return 1;
case -ENODEV:
puts("Device was not initialized");
break;
case -ENOTSUP:
puts("Device does not have a RX mode");
return 2;
case -ETIME:
puts("Device timed out setting to RX mode");
break;
default:
puts("unknown error");
break;
}
return 0;
}
static int check_state(void)
{
netdev_state_t state;
int res = dev->driver->get_state(dev, &state);
switch (res) {
case 0:
switch (state) {
case NETDEV_STATE_POWER_OFF:
puts("Device is powered off");
break;
case NETDEV_STATE_POWER_SLEEP:
puts("Device is sleeping");
break;
case NETDEV_STATE_POWER_IDLE:
puts("Device is idle");
break;
case NETDEV_STATE_RX_MODE:
puts("Device is in RX mode");
break;
case NETDEV_STATE_PROMISCUOUS_MODE:
puts("Device is in promiscous mode");
break;
default:
puts("Device is in unknown state");
return 0;
}
return 1;
case -ENODEV:
puts("Device was not initialized");
break;
case -ETIME:
puts("Device timed out getting to RX mode");
break;
default:
puts("unknown error");
break;
}
return 0;
}
#ifdef SENDER
static int send_packet(void)
{
netdev_hlist_t *hlist = NULL;
netdev_hlist_t header1 = {NULL, NULL, NETDEV_PROTO_UNKNOWN, "header 1,", 9};
netdev_hlist_t header2 = {NULL, NULL, NETDEV_PROTO_UNKNOWN, "header 2,", 9};
char payload[] = "payload";
netdev_hlist_add(&hlist, &header2);
netdev_hlist_add(&hlist, &header1);
printf("Sending \"%s%s%s\" to", (char *)header1.header, (char *)header2.header,
payload);
switch (dev_address_len) {
case 1:
do { /* open block to reduce scope of variable */
uint8_t dest = NETDEV_TEST_RECEIVER;
printf(" %" PRIu8 "\n", dest);
dev->driver->send_data(dev, &dest, dev_address_len,
hlist, payload, strlen(payload));
} while (0);
break;
case 2:
do { /* open block to reduce scope of variable */
uint16_t dest = NETDEV_TEST_RECEIVER;
printf(" %" PRIu16 "\n", dest);
dev->driver->send_data(dev, &dest, dev_address_len,
hlist, payload, strlen(payload));
} while (0);
break;
case 3:
do { /* open block to reduce scope of variable */
uint16_t dest_int = HTONS(NETDEV_TEST_RECEIVER);
uint8_t dest[dev_address_len];
memset(dest, 0, dev_address_len - sizeof(uint16_t));
memcpy(&(dest[dev_address_len - sizeof(uint16_t)]), &dest_int,
sizeof(uint16_t));
for (size_t i = 0; i < dev_address_len; i++) {
printf(" %02x", dest[i]);
}
puts("");
dev->driver->send_data(dev, &dest, dev_address_len,
hlist, payload, strlen(payload));
} while (0);
case 4:
do { /* open block to reduce scope of variable */
uint32_t dest = NETDEV_TEST_RECEIVER;
printf(" %" PRIu32 "\n", dest);
dev->driver->send_data(dev, &dest, dev_address_len, hlist,
payload, strlen(payload));
} while (0);
break;
case 8:
do { /* open block to reduce scope of variable */
uint64_t dest = NETDEV_TEST_RECEIVER;
printf(" %" PRIu64 "\n", dest);
dev->driver->send_data(dev, &dest, dev_address_len,
hlist, payload, strlen(payload));
} while (0);
break;
default:
do { /* open block to reduce scope of variable */
uint32_t dest_int = HTONL(NETDEV_TEST_RECEIVER);
uint8_t dest[dev_address_len];
memset(dest, 0, dev_address_len - sizeof(uint32_t));
memcpy(&(dest[dev_address_len - sizeof(uint32_t)]), &dest_int,
sizeof(uint32_t));
for (size_t i = 0; i < dev_address_len; i++) {
printf(" %02x", dest[i]);
}
puts("");
dev->driver->send_data(dev, &dest, dev_address_len,
hlist, payload, strlen(payload));
} while (0);
break;
}
return 1;
}
#endif
#ifdef RECEIVER
static int test_callback(netdev_t *rcv_dev, void *src, size_t src_len,
void *dest, size_t dest_len, void *payload,
size_t payload_len)
{
uint8_t exp_src[dev_address_len];
uint8_t exp_dest[dev_address_len];
if (rcv_dev != dev) {
printf("cb: Device is not the expected one: %p != %p\n",
(void *)rcv_dev, (void *)dev);
return -EINVAL;
}
switch (dev_address_len) {
case 1:
exp_src[0] = NETDEV_TEST_SENDER;
exp_dest[0] = NETDEV_TEST_RECEIVER;
break;
case 2:
do { /* open block to reduce scope of variable */
uint16_t *exp_src_ptr = (uint16_t *)exp_src;
uint16_t *exp_dest_ptr = (uint16_t *)exp_dest;
*exp_src_ptr = NETDEV_TEST_SENDER;
*exp_dest_ptr = NETDEV_TEST_RECEIVER;
} while (0);
break;
case 3:
do { /* open block to reduce scope of variable */
uint16_t exp_src_int = HTONS(NETDEV_TEST_SENDER);
uint16_t exp_dest_int = HTONS(NETDEV_TEST_RECEIVER);
memset(exp_dest, 0, dev_address_len - sizeof(uint16_t));
memset(exp_src, 0, dev_address_len - sizeof(uint16_t));
memcpy(&(exp_dest[dev_address_len - sizeof(uint16_t)]),
&exp_dest_int, sizeof(uint16_t));
memcpy(&(exp_src[dev_address_len - sizeof(uint16_t)]),
&exp_src_int, sizeof(uint16_t));
} while (0);
break;
case 4:
do { /* open block to reduce scope of variable */
uint32_t *exp_src_ptr = (uint32_t *)exp_src;
uint32_t *exp_dest_ptr = (uint32_t *)exp_dest;
*exp_src_ptr = NETDEV_TEST_SENDER;
*exp_dest_ptr = NETDEV_TEST_RECEIVER;
} while (0);
break;
case 8:
do { /* open block to reduce scope of variable */
uint64_t *exp_src_ptr = (uint64_t *)exp_src;
uint64_t *exp_dest_ptr = (uint64_t *)exp_dest;
*exp_src_ptr = NETDEV_TEST_SENDER;
*exp_dest_ptr = NETDEV_TEST_RECEIVER;
} while (0);
break;
default:
do { /* open block to reduce scope of variable */
uint32_t exp_src_int = HTONL(NETDEV_TEST_SENDER);
uint32_t exp_dest_int = HTONL(NETDEV_TEST_RECEIVER);
memset(exp_dest, 0, dev_address_len - sizeof(uint32_t));
memset(exp_src, 0, dev_address_len - sizeof(uint32_t));
memcpy(&(exp_dest[dev_address_len - sizeof(uint32_t)]),
&exp_dest_int, sizeof(uint32_t));
memcpy(&(exp_src[dev_address_len - sizeof(uint32_t)]),
&exp_src_int, sizeof(uint32_t));
} while (0);
break;
}
if (src_len != dev_address_len || memcmp(exp_src, src, src_len) != 0) {
printf("cb: src is not from sender %d\n", NETDEV_TEST_SENDER);
return -EINVAL;
}
if (dest_len != dev_address_len || memcmp(exp_dest, dest, dest_len) != 0) {
printf("cb: dest is not for receiver %d\n", NETDEV_TEST_SENDER);
return -EINVAL;
}
if (strcmp(payload, "header 1,header 2,payload") != 0) {
puts("cb: payload is not as expected (\"header 1,header 2,payload\")");
return -EINVAL;
}
printf("Received \"");
for (size_t i = 0; i < payload_len; i++) {
printf("%c", ((char *)payload)[i]);
}
printf("\"\n");
printf("Sender was");
for (size_t i = 0; i < src_len; i++) {
printf(" %02x", ((char *)src)[i]);
}
printf("\n");
return payload_len;
}
static int init_receiver_callback(void)
{
int res = dev->driver->add_receive_data_callback(dev, test_callback);
switch (res) {
case 0:
puts("Added receive callback successfully.");
return 1;
case -ENODEV:
puts("Device was not initialized");
break;
case -ENOBUFS:
puts("Can not add callback: no slot left");
break;
default:
puts("Unknown error");
break;
}
return 0;
}
#endif
int main(void)
{
int init_res;
puts("\nRIOT netdev test");
dev = NETDEV_DEFAULT;
if (dev == NULL) {
puts("Default device was NULL");
return 1;
}
printf("Initialized dev ");
switch (dev->type) {
case NETDEV_TYPE_UNKNOWN:
printf("of unknown type\n");
break;
case NETDEV_TYPE_BASE:
printf("as basic device\n");
break;
default:
printf("of undefined type\n");
break;
}
if (dev->driver == NULL) {
puts("Default driver is defined as NULL!");
return 1;
}
dev->driver->init(dev);
if (!(init_res = init_channel())) {
return 1;
}
if (check_channel() == 0) {
printf("Channel is not as expected. ");
if (init_res == 2) {
printf("But initialization is not supported. Continuing.\n");
}
else {
printf("Aborting\n");
return 1;
}
}
if (!(init_res = init_address())) {
return 1;
}
if (check_address() == 0) {
printf("Address is not as expected. ");
if (init_res == 2) {
printf("But initialization is not supported. Continuing.\n");
}
else {
printf("Aborting\n");
return 1;
}
}
if (!(init_res = init_long_address())) {
return 1;
}
if (check_long_address() == 0) {
printf("Long address is not as expected. ");
if (init_res == 2) {
printf("But initialization is not supported. Continuing.\n");
}
else {
printf("Aborting\n");
return 1;
}
}
if (!(init_res = init_nid())) {
return 1;
}
if (check_nid() == 0) {
printf("Network ID is not as expected. ");
if (init_res == 2) {
printf("But initialization is not supported. Continuing.\n");
}
else {
printf("Aborting\n");
return 1;
}
}
if (check_max_packet_size() == 0) {
return 1;
}
if (check_protocol() == 0) {
return 1;
}
if (!init_state()) {
return 1;
}
if (!check_state()) {
return 1;
}
#ifdef SENDER
if (!send_packet()) {
return 1;
}
#elif RECEIVER
if (!init_receiver_callback()) {
return 1;
}
#endif
return 0;
}
#else
int main(void)
{
puts("\nRIOT netdev test");
puts("Default netdev type and driver unknown!");
return 0;
}
#endif /* !NETDEV_DEFAULT */
View Git Blame Copy Permalink