mirror of
https://github.com/RIOT-OS/RIOT.git
synced 2024-12-29 04:50:03 +01:00
539 lines
14 KiB
C
539 lines
14 KiB
C
/*
|
|
* Copyright (C) 2014 Martine Lenders <mail@martine-lenders.eu>
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
/**
|
|
* @{
|
|
*
|
|
* @file tests-pktbuf.c
|
|
*/
|
|
#include <errno.h>
|
|
#include <stdint.h>
|
|
|
|
#include "embUnit/embUnit.h"
|
|
|
|
#include "pktbuf.h"
|
|
|
|
#include "tests-pktbuf.h"
|
|
|
|
typedef struct __attribute__((packed)) {
|
|
uint8_t u8;
|
|
uint16_t u16;
|
|
uint32_t u32;
|
|
uint64_t u64;
|
|
int8_t s8;
|
|
int16_t s16;
|
|
int32_t s32;
|
|
int64_t s64;
|
|
} test_pktbuf_struct_t;
|
|
|
|
static void tear_down(void)
|
|
{
|
|
pktbuf_reset();
|
|
}
|
|
|
|
static void test_pktbuf_alloc_0(void)
|
|
{
|
|
TEST_ASSERT_NULL(pktbuf_alloc(0));
|
|
}
|
|
|
|
static void test_pktbuf_alloc_memfull(void)
|
|
{
|
|
for (int i = 0; i < 9; i++) {
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc((PKTBUF_SIZE / 10) + 4));
|
|
/* Why 4? Because: http://xkcd.com/221/, thats why ;-) */
|
|
}
|
|
|
|
TEST_ASSERT_NULL(pktbuf_alloc((PKTBUF_SIZE / 10) + 4));
|
|
}
|
|
|
|
static void test_pktbuf_alloc_success(void)
|
|
{
|
|
void *data, *data_prev = NULL;
|
|
|
|
for (int i = 0; i < 9; i++) {
|
|
data = pktbuf_alloc((PKTBUF_SIZE / 10) + 4);
|
|
|
|
TEST_ASSERT(data_prev < data);
|
|
|
|
data_prev = data;
|
|
}
|
|
}
|
|
|
|
static void test_pktbuf_realloc_0(void)
|
|
{
|
|
void *data = pktbuf_alloc(512);
|
|
|
|
TEST_ASSERT_NULL(pktbuf_realloc(data, 0));
|
|
}
|
|
|
|
static void test_pktbuf_realloc_memfull(void)
|
|
{
|
|
void *data = pktbuf_alloc(512);
|
|
|
|
TEST_ASSERT_NULL(pktbuf_realloc(data, PKTBUF_SIZE + 1));
|
|
}
|
|
|
|
static void test_pktbuf_realloc_memfull2(void)
|
|
{
|
|
void *data = pktbuf_alloc(512);
|
|
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(512));
|
|
TEST_ASSERT_NULL(pktbuf_realloc(data, PKTBUF_SIZE - 512));
|
|
}
|
|
|
|
static void test_pktbuf_realloc_memfull3(void)
|
|
{
|
|
void *data;
|
|
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(25));
|
|
|
|
data = pktbuf_alloc(512);
|
|
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(73));
|
|
|
|
TEST_ASSERT_NULL(pktbuf_realloc(data, PKTBUF_SIZE - 512));
|
|
}
|
|
|
|
static void test_pktbuf_realloc_smaller(void)
|
|
{
|
|
void *data;
|
|
|
|
data = pktbuf_alloc(512);
|
|
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(25));
|
|
|
|
TEST_ASSERT(data == pktbuf_realloc(data, 128));
|
|
}
|
|
|
|
static void test_pktbuf_realloc_memenough(void)
|
|
{
|
|
void *data;
|
|
|
|
data = pktbuf_alloc(128);
|
|
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
|
|
TEST_ASSERT(data == pktbuf_realloc(data, 200));
|
|
}
|
|
|
|
static void test_pktbuf_realloc_memenough2(void)
|
|
{
|
|
void *data, *data2;
|
|
|
|
data = pktbuf_alloc(128);
|
|
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
|
|
data2 = pktbuf_alloc(128);
|
|
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(25));
|
|
|
|
pktbuf_release(data2);
|
|
|
|
TEST_ASSERT(data == pktbuf_realloc(data, 200));
|
|
}
|
|
|
|
static void test_pktbuf_realloc_nomemenough(void)
|
|
{
|
|
void *data, *data2;
|
|
|
|
data = pktbuf_alloc(128);
|
|
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
|
|
data2 = pktbuf_alloc(128);
|
|
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(25));
|
|
|
|
pktbuf_release(data2);
|
|
|
|
TEST_ASSERT(data != pktbuf_realloc(data, 512));
|
|
}
|
|
|
|
static void test_pktbuf_realloc_unknown_ptr(void)
|
|
{
|
|
char *data = "abcd", *new_data = pktbuf_realloc(data, 5);
|
|
|
|
TEST_ASSERT_NOT_NULL(new_data);
|
|
TEST_ASSERT(data != new_data);
|
|
TEST_ASSERT_EQUAL_STRING(data, new_data);
|
|
}
|
|
|
|
static void test_pktbuf_insert_size_0(void)
|
|
{
|
|
TEST_ASSERT_NULL(pktbuf_insert("", 0));
|
|
}
|
|
|
|
static void test_pktbuf_insert_data_NULL(void)
|
|
{
|
|
TEST_ASSERT_NULL(pktbuf_insert(NULL, 4));
|
|
}
|
|
|
|
static void test_pktbuf_insert_memfull(void)
|
|
{
|
|
while (pktbuf_insert("abc", 4));
|
|
|
|
TEST_ASSERT_NULL(pktbuf_insert("abc", 4));
|
|
}
|
|
|
|
static void test_pktbuf_insert_success(void)
|
|
{
|
|
char *data, *data_prev = NULL;
|
|
|
|
for (int i = 0; i < 10; i++) {
|
|
data = (char *)pktbuf_insert("abc", 4);
|
|
|
|
TEST_ASSERT(data_prev < data);
|
|
TEST_ASSERT_EQUAL_STRING("abc", data);
|
|
|
|
data_prev = data;
|
|
}
|
|
}
|
|
|
|
#ifdef DEVELHELP
|
|
static void test_pktbuf_copy_efault(void)
|
|
{
|
|
char *data = (char *)pktbuf_insert("abcd", 5);
|
|
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_EQUAL_INT(-EFAULT, pktbuf_copy(data, NULL, 3));
|
|
TEST_ASSERT_EQUAL_STRING("abcd", data);
|
|
}
|
|
#endif
|
|
|
|
static void test_pktbuf_copy_data_len_too_long(void)
|
|
{
|
|
char *data = (char *)pktbuf_insert("ab", 3);
|
|
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_EQUAL_INT(-ENOMEM, pktbuf_copy(data, "cdef", 5));
|
|
TEST_ASSERT_EQUAL_STRING("ab", data);
|
|
}
|
|
|
|
static void test_pktbuf_copy_data_len_too_long2(void)
|
|
{
|
|
char *data = (char *)pktbuf_insert("abcd", 5);
|
|
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_EQUAL_INT(-ENOMEM, pktbuf_copy(data + 2, "efgh", 5));
|
|
TEST_ASSERT_EQUAL_STRING("abcd", data);
|
|
}
|
|
|
|
static void test_pktbuf_copy_data_len_0(void)
|
|
{
|
|
char *data = (char *)pktbuf_insert("abcd", 5);
|
|
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_EQUAL_INT(0, pktbuf_copy(data, "ef", 0));
|
|
TEST_ASSERT_EQUAL_STRING("abcd", data);
|
|
}
|
|
|
|
static void test_pktbuf_copy_success(void)
|
|
{
|
|
char *data = (char *)pktbuf_insert("abcd", 5);
|
|
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_EQUAL_INT(3, pktbuf_copy(data, "ef", 3));
|
|
TEST_ASSERT_EQUAL_STRING("ef", data);
|
|
}
|
|
|
|
static void test_pktbuf_copy_success2(void)
|
|
{
|
|
char *data = (char *)pktbuf_insert("abcdef", 7);
|
|
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_EQUAL_INT(2, pktbuf_copy(data + 3, "gh", 2));
|
|
TEST_ASSERT_EQUAL_STRING("abcghf", data);
|
|
}
|
|
|
|
static void test_pktbuf_hold_ptr_null(void)
|
|
{
|
|
char *data;
|
|
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(25));
|
|
data = (char *)pktbuf_insert("abcd", 5);
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(16));
|
|
|
|
TEST_ASSERT_EQUAL_INT(3, pktbuf_packets_allocated());
|
|
|
|
pktbuf_hold(NULL);
|
|
pktbuf_release(data);
|
|
|
|
TEST_ASSERT_EQUAL_INT(2, pktbuf_packets_allocated());
|
|
TEST_ASSERT_EQUAL_STRING("abcd", data);
|
|
}
|
|
|
|
static void test_pktbuf_hold_wrong_ptr(void)
|
|
{
|
|
char *data, wrong;
|
|
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(25));
|
|
data = (char *)pktbuf_insert("abcd", 5);
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(16));
|
|
|
|
TEST_ASSERT_EQUAL_INT(3, pktbuf_packets_allocated());
|
|
|
|
pktbuf_hold(&wrong);
|
|
pktbuf_release(data);
|
|
|
|
TEST_ASSERT_EQUAL_INT(2, pktbuf_packets_allocated());
|
|
TEST_ASSERT_EQUAL_STRING("abcd", data);
|
|
}
|
|
|
|
static void test_pktbuf_hold_success(void)
|
|
{
|
|
char *data;
|
|
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(25));
|
|
data = (char *)pktbuf_insert("abcd", 5);
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(16));
|
|
|
|
pktbuf_hold(data);
|
|
pktbuf_release(data);
|
|
|
|
TEST_ASSERT_EQUAL_INT(3, pktbuf_copy(data, "ef", 3));
|
|
TEST_ASSERT_EQUAL_STRING("ef", data);
|
|
}
|
|
|
|
static void test_pktbuf_hold_success2(void)
|
|
{
|
|
char *data;
|
|
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(25));
|
|
data = (char *)pktbuf_insert("abcd", 5);
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(16));
|
|
|
|
pktbuf_hold(data + 4);
|
|
pktbuf_release(data + 4);
|
|
|
|
TEST_ASSERT_EQUAL_INT(3, pktbuf_copy(data, "ef", 3));
|
|
TEST_ASSERT_EQUAL_STRING("ef", data);
|
|
}
|
|
|
|
static void test_pktbuf_release_ptr_null(void)
|
|
{
|
|
char *data;
|
|
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(25));
|
|
data = (char *)pktbuf_insert("abcd", 5);
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(16));
|
|
|
|
pktbuf_release(NULL);
|
|
|
|
TEST_ASSERT_EQUAL_INT(3, pktbuf_copy(data, "ef", 3));
|
|
TEST_ASSERT_EQUAL_STRING("ef", data);
|
|
}
|
|
|
|
static void test_pktbuf_release_wrong_ptr(void)
|
|
{
|
|
char *data, wrong;
|
|
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(25));
|
|
data = (char *)pktbuf_insert("abcd", 5);
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(16));
|
|
|
|
pktbuf_release(&wrong);
|
|
|
|
TEST_ASSERT_EQUAL_INT(3, pktbuf_copy(data, "ef", 3));
|
|
TEST_ASSERT_EQUAL_STRING("ef", data);
|
|
}
|
|
|
|
static void test_pktbuf_release_success(void)
|
|
{
|
|
char *data;
|
|
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(25));
|
|
data = (char *)pktbuf_insert("abcd", 5);
|
|
TEST_ASSERT_NOT_NULL(data);
|
|
TEST_ASSERT_NOT_NULL(pktbuf_alloc(16));
|
|
|
|
TEST_ASSERT_EQUAL_INT(3, pktbuf_packets_allocated());
|
|
|
|
pktbuf_hold(data);
|
|
pktbuf_hold(data);
|
|
pktbuf_release(data + 3);
|
|
pktbuf_release(data + 4);
|
|
pktbuf_release(data + 2);
|
|
|
|
TEST_ASSERT_EQUAL_INT(2, pktbuf_packets_allocated());
|
|
}
|
|
|
|
static void test_pktbuf_release_success2(void)
|
|
{
|
|
char *data1, *data2, *data3;
|
|
|
|
data1 = (char *)pktbuf_insert("abcd", 5);
|
|
TEST_ASSERT_NOT_NULL(data1);
|
|
data2 = (char *)pktbuf_insert("ef", 3);
|
|
TEST_ASSERT_NOT_NULL(data2);
|
|
data3 = (char *)pktbuf_insert("ghijkl", 7);
|
|
TEST_ASSERT_NOT_NULL(data3);
|
|
|
|
TEST_ASSERT_EQUAL_INT(3, pktbuf_packets_allocated());
|
|
|
|
pktbuf_release(data2);
|
|
|
|
TEST_ASSERT_EQUAL_INT(2, pktbuf_packets_allocated());
|
|
TEST_ASSERT_EQUAL_INT(2, pktbuf_copy(data1, "m", 2));
|
|
TEST_ASSERT_EQUAL_STRING("m", data1);
|
|
TEST_ASSERT_EQUAL_INT(4, pktbuf_copy(data3, "nop", 4));
|
|
TEST_ASSERT_EQUAL_STRING("nop", data3);
|
|
}
|
|
|
|
static void test_pktbuf_release_success3(void)
|
|
{
|
|
char *data1, *data2, *data3;
|
|
|
|
data1 = (char *)pktbuf_insert("abcd", 5);
|
|
TEST_ASSERT_NOT_NULL(data1);
|
|
data2 = (char *)pktbuf_insert("ef", 3);
|
|
TEST_ASSERT_NOT_NULL(data2);
|
|
data3 = (char *)pktbuf_insert("ghijkl", 7);
|
|
TEST_ASSERT_NOT_NULL(data3);
|
|
|
|
TEST_ASSERT_EQUAL_INT(3, pktbuf_packets_allocated());
|
|
|
|
pktbuf_release(data1);
|
|
|
|
TEST_ASSERT_EQUAL_INT(2, pktbuf_packets_allocated());
|
|
TEST_ASSERT_EQUAL_INT(2, pktbuf_copy(data2, "m", 2));
|
|
TEST_ASSERT_EQUAL_STRING("m", data2);
|
|
TEST_ASSERT_EQUAL_INT(4, pktbuf_copy(data3, "nop", 4));
|
|
TEST_ASSERT_EQUAL_STRING("nop", data3);
|
|
}
|
|
|
|
static void test_pktbuf_release_success4(void)
|
|
{
|
|
char *data1, *data2, *data3;
|
|
|
|
data1 = (char *)pktbuf_insert("abcd", 5);
|
|
TEST_ASSERT_NOT_NULL(data1);
|
|
data2 = (char *)pktbuf_insert("ef", 3);
|
|
TEST_ASSERT_NOT_NULL(data2);
|
|
data3 = (char *)pktbuf_insert("ghijkl", 7);
|
|
TEST_ASSERT_NOT_NULL(data3);
|
|
|
|
TEST_ASSERT_EQUAL_INT(3, pktbuf_packets_allocated());
|
|
|
|
pktbuf_release(data3);
|
|
|
|
TEST_ASSERT_EQUAL_INT(2, pktbuf_packets_allocated());
|
|
TEST_ASSERT_EQUAL_INT(2, pktbuf_copy(data1, "m", 2));
|
|
TEST_ASSERT_EQUAL_STRING("m", data1);
|
|
TEST_ASSERT_EQUAL_INT(1, pktbuf_copy(data2, "", 1));
|
|
TEST_ASSERT_EQUAL_STRING("", data2);
|
|
}
|
|
|
|
static void test_pktbuf_insert_packed_struct(void)
|
|
{
|
|
test_pktbuf_struct_t data = { 0x4d, 0xef43, 0xacdef574, 0x43644305695afde5,
|
|
34, -4469, 149699748, -46590430597
|
|
};
|
|
test_pktbuf_struct_t *data_cpy;
|
|
|
|
data_cpy = (test_pktbuf_struct_t *)pktbuf_insert(&data, sizeof(test_pktbuf_struct_t));
|
|
|
|
TEST_ASSERT_EQUAL_INT(data.u8, data_cpy->u8);
|
|
TEST_ASSERT_EQUAL_INT(data.u16, data_cpy->u16);
|
|
TEST_ASSERT_EQUAL_INT(data.u32, data_cpy->u32);
|
|
TEST_ASSERT_EQUAL_INT(data.u64, data_cpy->u64);
|
|
TEST_ASSERT_EQUAL_INT(data.s8, data_cpy->s8);
|
|
TEST_ASSERT_EQUAL_INT(data.s16, data_cpy->s16);
|
|
TEST_ASSERT_EQUAL_INT(data.s32, data_cpy->s32);
|
|
TEST_ASSERT_EQUAL_INT(data.s64, data_cpy->s64);
|
|
}
|
|
|
|
static void test_pktbuf_alloc_off_by_one1(void)
|
|
{
|
|
char *data1, *data2, *data3, *data4;
|
|
|
|
data1 = (char *)pktbuf_insert("1234567890a", 12);
|
|
TEST_ASSERT_NOT_NULL(data1);
|
|
data2 = (char *)pktbuf_alloc(44);
|
|
TEST_ASSERT_NOT_NULL(data2);
|
|
data4 = (char *)pktbuf_alloc(4);
|
|
TEST_ASSERT_NOT_NULL(data4);
|
|
TEST_ASSERT_EQUAL_INT(3, pktbuf_packets_allocated());
|
|
TEST_ASSERT_EQUAL_INT(12 + 44 + 4, pktbuf_bytes_allocated());
|
|
|
|
pktbuf_release(data1);
|
|
|
|
TEST_ASSERT_EQUAL_INT(2, pktbuf_packets_allocated());
|
|
TEST_ASSERT_EQUAL_INT(44 + 4, pktbuf_bytes_allocated());
|
|
|
|
data3 = (char *)pktbuf_insert("bcdefghijklm", 13);
|
|
TEST_ASSERT_NOT_NULL(data3);
|
|
TEST_ASSERT(data1 != data3);
|
|
|
|
TEST_ASSERT_EQUAL_INT(3, pktbuf_packets_allocated());
|
|
TEST_ASSERT_EQUAL_INT(44 + 4 + 13, pktbuf_bytes_allocated());
|
|
}
|
|
|
|
Test *tests_pktbuf_tests(void)
|
|
{
|
|
EMB_UNIT_TESTFIXTURES(fixtures) {
|
|
new_TestFixture(test_pktbuf_alloc_0),
|
|
new_TestFixture(test_pktbuf_alloc_memfull),
|
|
new_TestFixture(test_pktbuf_alloc_success),
|
|
new_TestFixture(test_pktbuf_realloc_0),
|
|
new_TestFixture(test_pktbuf_realloc_memfull),
|
|
new_TestFixture(test_pktbuf_realloc_memfull2),
|
|
new_TestFixture(test_pktbuf_realloc_memfull3),
|
|
new_TestFixture(test_pktbuf_realloc_smaller),
|
|
new_TestFixture(test_pktbuf_realloc_memenough),
|
|
new_TestFixture(test_pktbuf_realloc_memenough2),
|
|
new_TestFixture(test_pktbuf_realloc_nomemenough),
|
|
new_TestFixture(test_pktbuf_realloc_unknown_ptr),
|
|
new_TestFixture(test_pktbuf_insert_size_0),
|
|
new_TestFixture(test_pktbuf_insert_data_NULL),
|
|
new_TestFixture(test_pktbuf_insert_memfull),
|
|
new_TestFixture(test_pktbuf_insert_success),
|
|
#ifdef DEVELHELP
|
|
new_TestFixture(test_pktbuf_copy_efault),
|
|
#endif
|
|
new_TestFixture(test_pktbuf_copy_data_len_too_long),
|
|
new_TestFixture(test_pktbuf_copy_data_len_too_long2),
|
|
new_TestFixture(test_pktbuf_copy_data_len_0),
|
|
new_TestFixture(test_pktbuf_copy_success),
|
|
new_TestFixture(test_pktbuf_copy_success2),
|
|
new_TestFixture(test_pktbuf_hold_ptr_null),
|
|
new_TestFixture(test_pktbuf_hold_wrong_ptr),
|
|
new_TestFixture(test_pktbuf_hold_success),
|
|
new_TestFixture(test_pktbuf_hold_success2),
|
|
new_TestFixture(test_pktbuf_release_ptr_null),
|
|
new_TestFixture(test_pktbuf_release_wrong_ptr),
|
|
new_TestFixture(test_pktbuf_release_success),
|
|
new_TestFixture(test_pktbuf_release_success2),
|
|
new_TestFixture(test_pktbuf_release_success3),
|
|
new_TestFixture(test_pktbuf_release_success4),
|
|
new_TestFixture(test_pktbuf_insert_packed_struct),
|
|
new_TestFixture(test_pktbuf_alloc_off_by_one1),
|
|
};
|
|
|
|
EMB_UNIT_TESTCALLER(pktbuf_tests, NULL, tear_down, fixtures);
|
|
|
|
return (Test *)&pktbuf_tests;
|
|
}
|
|
|
|
void tests_pktbuf(void)
|
|
{
|
|
TESTS_RUN(tests_pktbuf_tests());
|
|
}
|
|
/** @} */
|