mirror of
https://github.com/obgm/libcoap.git
synced 2026-11-05 01:12:55 +03:00
Olaf Bergmann
774fc01ec1
Some unit tests in tests/test_options.c and tests/test_pdu.c check for error cases, causing warning messages to be emitted by the library code. As the expected result is checked separately, the warnings can be suppressed to avoid confusion.
997 lines
27 KiB
C
997 lines
27 KiB
C
/* libcoap unit tests
|
|
*
|
|
* Copyright (C) 2012,2015 Olaf Bergmann <bergmann@tzi.org>
|
|
*
|
|
* This file is part of the CoAP library libcoap. Please see
|
|
* README for terms of use.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <coap.h>
|
|
#include "test_options.h"
|
|
|
|
/************************************************************************
|
|
** decoder tests
|
|
************************************************************************/
|
|
|
|
static void
|
|
t_parse_option1(void) {
|
|
/* delta == 0, length == 0, value == 0 */
|
|
str teststr = { 1, (unsigned char *)"" };
|
|
|
|
size_t result;
|
|
coap_option_t option;
|
|
|
|
/* result = coap_opt_parse(teststr.s, teststr.s + teststr.length, &option); */
|
|
result = coap_opt_parse(teststr.s, teststr.length, &option);
|
|
CU_ASSERT(result == 1);
|
|
CU_ASSERT(option.delta == 0);
|
|
CU_ASSERT(option.length == 0);
|
|
/* FIXME: value? */
|
|
}
|
|
|
|
static void
|
|
t_parse_option2(void) {
|
|
/* delta == 12, length == 1, value == 0 */
|
|
str teststr = { 2, (unsigned char *)"\xc1" };
|
|
|
|
size_t result;
|
|
coap_option_t option;
|
|
|
|
result = coap_opt_parse(teststr.s, teststr.length, &option);
|
|
CU_ASSERT(result == 2);
|
|
CU_ASSERT(option.delta == 12);
|
|
CU_ASSERT(option.length == 1);
|
|
CU_ASSERT(option.value == teststr.s + 1);
|
|
}
|
|
|
|
static void
|
|
t_parse_option3(void) {
|
|
/* delta == 3, length == 12, value == 0 */
|
|
str teststr = { 13, (unsigned char *)"\x3c\x00\x01\x02\x03\x04"
|
|
"\x05\x06\x07\x08\x09\x0a\x0b" };
|
|
|
|
size_t result;
|
|
coap_option_t option;
|
|
|
|
result = coap_opt_parse(teststr.s, teststr.length, &option);
|
|
CU_ASSERT(result == 13);
|
|
CU_ASSERT(option.delta == 3);
|
|
CU_ASSERT(option.length == 12);
|
|
CU_ASSERT(option.value == teststr.s + 1);
|
|
/* CU_ASSERT(memcmp(option.value, teststr.s + 1, 12) == 0); */
|
|
}
|
|
|
|
static void
|
|
t_parse_option4(void) {
|
|
/* delta == 15, length == 3, value == 0 */
|
|
str teststr = { 2, (unsigned char *)"\xf3" };
|
|
|
|
size_t result;
|
|
coap_option_t option;
|
|
|
|
result = coap_opt_parse(teststr.s, teststr.length, &option);
|
|
CU_ASSERT(result == 0);
|
|
}
|
|
|
|
static void
|
|
t_parse_option5(void) {
|
|
/* delta == 3, length == 15, value == 0 */
|
|
str teststr = { 2, (unsigned char *)"\x3f" };
|
|
|
|
size_t result;
|
|
coap_option_t option;
|
|
|
|
result = coap_opt_parse(teststr.s, teststr.length, &option);
|
|
CU_ASSERT(result == 0);
|
|
}
|
|
|
|
static void
|
|
t_parse_option6(void) {
|
|
/* delta == 15, length == 15 */
|
|
str teststr = { 1, (unsigned char *)"\xff" };
|
|
|
|
size_t result;
|
|
coap_option_t option;
|
|
|
|
result = coap_opt_parse(teststr.s, teststr.length, &option);
|
|
CU_ASSERT(result == 0);
|
|
}
|
|
|
|
static void
|
|
t_parse_option7(void) {
|
|
/* delta == 20, length == 0 */
|
|
str teststr = { 2, (unsigned char *)"\xd0\x07" };
|
|
|
|
size_t result;
|
|
coap_option_t option;
|
|
|
|
result = coap_opt_parse(teststr.s, teststr.length, &option);
|
|
CU_ASSERT(result == 2);
|
|
CU_ASSERT(option.delta == 20);
|
|
CU_ASSERT(option.length == 0);
|
|
}
|
|
|
|
static void
|
|
t_parse_option8(void) {
|
|
/* delta == 780, length == 0 */
|
|
str teststr = { 3, (unsigned char *)"\xe0\x01\xff" };
|
|
|
|
size_t result;
|
|
coap_option_t option;
|
|
|
|
result = coap_opt_parse(teststr.s, teststr.length, &option);
|
|
CU_ASSERT(result == 3);
|
|
CU_ASSERT(option.delta == 780);
|
|
CU_ASSERT(option.length == 0);
|
|
}
|
|
|
|
static void
|
|
t_parse_option9(void) {
|
|
/* delta == 65535, length == 0 */
|
|
str teststr = { 3, (unsigned char *)"\xe0\xfe\xf2" };
|
|
|
|
size_t result;
|
|
coap_option_t option;
|
|
|
|
result = coap_opt_parse(teststr.s, teststr.length, &option);
|
|
CU_ASSERT(result == 3);
|
|
CU_ASSERT(option.delta == 65535);
|
|
}
|
|
|
|
static void
|
|
t_parse_option10(void) {
|
|
/* delta > 65535 (illegal), length == 0 */
|
|
str teststr = { 3, (unsigned char *)"\xe0\xff\xff" };
|
|
|
|
size_t result;
|
|
coap_option_t option;
|
|
|
|
result = coap_opt_parse(teststr.s, teststr.length, &option);
|
|
CU_ASSERT(result == 0);
|
|
}
|
|
|
|
static void
|
|
t_parse_option11(void) {
|
|
/* illegal delta value (option too short) */
|
|
str teststr = { 1, (unsigned char *)"\xd0" };
|
|
|
|
size_t result;
|
|
coap_option_t option;
|
|
|
|
result = coap_opt_parse(teststr.s, teststr.length, &option);
|
|
CU_ASSERT(result == 0);
|
|
}
|
|
|
|
static void
|
|
t_parse_option12(void) {
|
|
/* delta == 280, length == 500 */
|
|
str teststr = { 3, (unsigned char *)"\xee\xff\x0b" };
|
|
|
|
size_t result;
|
|
coap_option_t option;
|
|
|
|
result = coap_opt_parse(teststr.s, teststr.length, &option);
|
|
CU_ASSERT(result == 0);
|
|
}
|
|
|
|
static void
|
|
t_parse_option13(void) {
|
|
/* delta == 280, length == 500 */
|
|
unsigned char _data[505];
|
|
str teststr = { sizeof(_data), _data };
|
|
teststr.s[0] = 0xee;
|
|
teststr.s[1] = 0x00;
|
|
teststr.s[2] = 0x0b;
|
|
teststr.s[3] = 0x00;
|
|
teststr.s[4] = 0xe7;
|
|
|
|
size_t result;
|
|
coap_option_t option;
|
|
|
|
result = coap_opt_parse(teststr.s, teststr.length, &option);
|
|
CU_ASSERT(result == sizeof(_data));
|
|
CU_ASSERT(option.delta == 280);
|
|
CU_ASSERT(option.length == 500);
|
|
CU_ASSERT(option.value == &_data[5]);
|
|
}
|
|
|
|
static void
|
|
t_parse_option14(void) {
|
|
/* delta == 268, length == 65535 */
|
|
unsigned char *data;
|
|
unsigned int length = 4 + 65535;
|
|
|
|
data = (unsigned char *)malloc(length);
|
|
if (!data) {
|
|
CU_FAIL("internal error in test framework -- insufficient memory\n");
|
|
return;
|
|
}
|
|
|
|
data[0] = 0xde;
|
|
data[1] = 0xff;
|
|
data[2] = 0xfe;
|
|
data[3] = 0xf2;
|
|
|
|
size_t result;
|
|
coap_option_t option;
|
|
|
|
result = coap_opt_parse(data, length, &option);
|
|
CU_ASSERT(result == length);
|
|
CU_ASSERT(option.delta == 268);
|
|
CU_ASSERT(option.length == 65535);
|
|
CU_ASSERT(option.value == &data[4]);
|
|
}
|
|
|
|
/************************************************************************
|
|
** encoder tests
|
|
************************************************************************/
|
|
|
|
static void
|
|
t_encode_option1(void) {
|
|
char teststr[] = { 0x00 };
|
|
unsigned char buf[40];
|
|
size_t result;
|
|
|
|
result = coap_opt_setheader((coap_opt_t *)buf, sizeof(buf), 0, 0);
|
|
CU_ASSERT(result == sizeof(teststr));
|
|
|
|
CU_ASSERT(memcmp(buf, teststr, result) == 0);
|
|
}
|
|
|
|
static void
|
|
t_encode_option2(void) {
|
|
uint8_t teststr[] = { 0x5d, 0xff };
|
|
unsigned char buf[40];
|
|
size_t result;
|
|
|
|
result = coap_opt_setheader((coap_opt_t *)buf, sizeof(buf), 5, 268);
|
|
CU_ASSERT(result == sizeof(teststr));
|
|
|
|
CU_ASSERT(memcmp(buf, teststr, result) == 0);
|
|
}
|
|
|
|
static void
|
|
t_encode_option3(void) {
|
|
uint8_t teststr[] = { 0xd1, 0x01 };
|
|
unsigned char buf[40];
|
|
size_t result;
|
|
|
|
result = coap_opt_setheader((coap_opt_t *)buf, sizeof(buf), 14, 1);
|
|
CU_ASSERT(result == sizeof(teststr));
|
|
|
|
CU_ASSERT(memcmp(buf, teststr, result) == 0);
|
|
}
|
|
|
|
static void
|
|
t_encode_option4(void) {
|
|
uint8_t teststr[] = { 0xdd, 0xff, 0xab };
|
|
unsigned char buf[40];
|
|
size_t result;
|
|
|
|
result = coap_opt_setheader((coap_opt_t *)buf, sizeof(buf), 268, 184);
|
|
CU_ASSERT(result == sizeof(teststr));
|
|
|
|
CU_ASSERT(memcmp(buf, teststr, result) == 0);
|
|
}
|
|
|
|
static void
|
|
t_encode_option5(void) {
|
|
uint8_t teststr[] = { 0xed, 0x13, 0x00, 0xff };
|
|
unsigned char buf[40];
|
|
size_t result;
|
|
|
|
result = coap_opt_setheader((coap_opt_t *)buf, sizeof(buf), 5133, 268);
|
|
CU_ASSERT(result == sizeof(teststr));
|
|
|
|
CU_ASSERT(memcmp(buf, teststr, result) == 0);
|
|
}
|
|
|
|
static void
|
|
t_encode_option6(void) {
|
|
uint8_t teststr[] = { 0xee, 0xfe, 0xf2, 0xfe, 0xf2 };
|
|
unsigned char buf[40];
|
|
size_t result;
|
|
|
|
result = coap_opt_setheader((coap_opt_t *)buf, sizeof(buf), 65535, 65535);
|
|
CU_ASSERT(result == sizeof(teststr));
|
|
|
|
CU_ASSERT(memcmp(buf, teststr, result) == 0);
|
|
}
|
|
|
|
static void
|
|
t_encode_option7(void) {
|
|
uint8_t teststr[] = { 0x35, 'v', 'a', 'l', 'u', 'e' };
|
|
const size_t valoff = 1;
|
|
unsigned char buf[40];
|
|
size_t result;
|
|
|
|
result = coap_opt_encode((coap_opt_t *)buf, sizeof(buf), 3,
|
|
(unsigned char *)teststr + valoff,
|
|
sizeof(teststr) - valoff);
|
|
|
|
CU_ASSERT(result == sizeof(teststr));
|
|
|
|
CU_ASSERT(memcmp(buf, teststr, result) == 0);
|
|
}
|
|
|
|
static void
|
|
t_encode_option8(void) {
|
|
/* value does not fit in message buffer */
|
|
unsigned char buf[40];
|
|
size_t result;
|
|
|
|
result = coap_opt_encode((coap_opt_t *)buf, 8, 15,
|
|
(unsigned char *)"something", 9);
|
|
|
|
CU_ASSERT(result == 0);
|
|
|
|
result = coap_opt_encode((coap_opt_t *)buf, 1, 15,
|
|
(unsigned char *)"something", 9);
|
|
|
|
CU_ASSERT(result == 0);
|
|
}
|
|
|
|
/************************************************************************
|
|
** accessor tests
|
|
************************************************************************/
|
|
|
|
static void
|
|
t_access_option1(void) {
|
|
const uint8_t teststr[] = { 0x12, 'a', 'b' };
|
|
|
|
CU_ASSERT(coap_opt_delta((coap_opt_t *)teststr) == 1);
|
|
CU_ASSERT(coap_opt_length((coap_opt_t *)teststr) == 2);
|
|
CU_ASSERT_PTR_EQUAL(coap_opt_value((coap_opt_t *)teststr), teststr + 1);
|
|
CU_ASSERT(coap_opt_size((coap_opt_t *)teststr) == sizeof(teststr));
|
|
}
|
|
|
|
static void
|
|
t_access_option2(void) {
|
|
const uint8_t teststr[] = { 0xe2, 0x18, 0xfd, 'a', 'b' };
|
|
|
|
CU_ASSERT(coap_opt_delta((coap_opt_t *)teststr) == 6666);
|
|
CU_ASSERT(coap_opt_length((coap_opt_t *)teststr) == 2);
|
|
CU_ASSERT_PTR_EQUAL(coap_opt_value((coap_opt_t *)teststr), teststr + 3);
|
|
CU_ASSERT(coap_opt_size((coap_opt_t *)teststr) == sizeof(teststr));
|
|
}
|
|
|
|
static void
|
|
t_access_option3(void) {
|
|
const uint8_t teststr[] = { 0xed, 0x18, 0x0a, 0x00, 'a', 'b', 'c', 'd',
|
|
'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
|
|
'm'
|
|
};
|
|
|
|
CU_ASSERT(coap_opt_delta((coap_opt_t *)teststr) == 6423);
|
|
CU_ASSERT(coap_opt_length((coap_opt_t *)teststr) == 13);
|
|
CU_ASSERT_PTR_EQUAL(coap_opt_value((coap_opt_t *)teststr), teststr + 4);
|
|
CU_ASSERT(coap_opt_size((coap_opt_t *)teststr) == sizeof(teststr));
|
|
}
|
|
|
|
static void
|
|
t_access_option4(void) {
|
|
const uint8_t teststr[] = { 0xde, 0xff, 0xfe, 0xf2, 'a', 'b', 'c' };
|
|
|
|
CU_ASSERT(coap_opt_delta((coap_opt_t *)teststr) == 268);
|
|
CU_ASSERT(coap_opt_length((coap_opt_t *)teststr) == 65535);
|
|
CU_ASSERT_PTR_EQUAL(coap_opt_value((coap_opt_t *)teststr), teststr + 4);
|
|
CU_ASSERT(coap_opt_size((coap_opt_t *)teststr) == 65535 + 4);
|
|
}
|
|
|
|
static void
|
|
t_access_option5(void) {
|
|
const uint8_t teststr[] = { 0xee, 0xfe, 0xf2, 0x00, 0xdd, 'a', 'b', 'c' };
|
|
|
|
CU_ASSERT(coap_opt_delta((coap_opt_t *)teststr) == 65535);
|
|
CU_ASSERT(coap_opt_length((coap_opt_t *)teststr) == 490);
|
|
CU_ASSERT_PTR_EQUAL(coap_opt_value((coap_opt_t *)teststr), teststr + 5);
|
|
CU_ASSERT(coap_opt_size((coap_opt_t *)teststr) == 495);
|
|
}
|
|
|
|
static void
|
|
t_access_option6(void) {
|
|
coap_log_t level = coap_get_log_level();
|
|
const uint8_t teststr[] = { 0xf2, 'a', 'b' };
|
|
|
|
coap_set_log_level(LOG_CRIT);
|
|
CU_ASSERT(coap_opt_delta((coap_opt_t *)teststr) == 0);
|
|
coap_set_log_level(level);
|
|
CU_ASSERT(coap_opt_length((coap_opt_t *)teststr) == 0);
|
|
CU_ASSERT_PTR_EQUAL(coap_opt_value((coap_opt_t *)teststr), NULL);
|
|
CU_ASSERT(coap_opt_size((coap_opt_t *)teststr) == 0);
|
|
}
|
|
|
|
static void
|
|
t_access_option7(void) {
|
|
const uint8_t teststr[] = { 0x2f, 'a', 'b' };
|
|
|
|
CU_ASSERT(coap_opt_delta((coap_opt_t *)teststr) == 2);
|
|
CU_ASSERT(coap_opt_length((coap_opt_t *)teststr) == 0);
|
|
CU_ASSERT_PTR_EQUAL(coap_opt_value((coap_opt_t *)teststr), NULL);
|
|
CU_ASSERT(coap_opt_size((coap_opt_t *)teststr) == 0);
|
|
}
|
|
|
|
/************************************************************************
|
|
** accessor tests
|
|
************************************************************************/
|
|
|
|
#define TEST_MAX_SIZE 1000
|
|
|
|
static void
|
|
t_iterate_option1(void) {
|
|
/* CoAP PDU without token, options, or data */
|
|
uint8_t teststr[] __attribute__ ((aligned (8))) = {
|
|
0x00, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
coap_pdu_t pdu = {
|
|
.max_size = TEST_MAX_SIZE,
|
|
.hdr = (coap_hdr_t *)teststr,
|
|
.length = sizeof(teststr)
|
|
};
|
|
coap_opt_iterator_t oi, *result;
|
|
coap_opt_t *option;
|
|
|
|
result = coap_option_iterator_init(&pdu, &oi, COAP_OPT_ALL);
|
|
|
|
CU_ASSERT(result == NULL);
|
|
CU_ASSERT(oi.bad == 1);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 1);
|
|
CU_ASSERT(option == NULL);
|
|
}
|
|
|
|
static void
|
|
t_iterate_option2(void) {
|
|
/* CoAP PDU with token but without options and data */
|
|
uint8_t teststr[] __attribute__ ((aligned (8))) = {
|
|
0x03, 0x00, 0x00, 0x00, 't', 'o', 'k'
|
|
};
|
|
|
|
coap_pdu_t pdu = {
|
|
.max_size = TEST_MAX_SIZE,
|
|
.hdr = (coap_hdr_t *)teststr,
|
|
.length = sizeof(teststr)
|
|
};
|
|
coap_opt_iterator_t oi, *result;
|
|
coap_opt_t *option;
|
|
|
|
result = coap_option_iterator_init(&pdu, &oi, COAP_OPT_ALL);
|
|
|
|
CU_ASSERT(result == NULL);
|
|
CU_ASSERT(oi.bad == 1);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 1);
|
|
CU_ASSERT(option == NULL);
|
|
}
|
|
|
|
static void
|
|
t_iterate_option3(void) {
|
|
/* CoAP PDU with token and options */
|
|
uint8_t teststr[] __attribute__ ((aligned (8))) = {
|
|
0x03, 0x00, 0x00, 0x00, 't', 'o', 'k', 0x13,
|
|
'o', 'p', 't', 0x00, 0xd1, 0x10, 'x'
|
|
};
|
|
|
|
coap_pdu_t pdu = {
|
|
.max_size = TEST_MAX_SIZE,
|
|
.hdr = (coap_hdr_t *)teststr,
|
|
.length = sizeof(teststr)
|
|
};
|
|
coap_opt_iterator_t oi, *result;
|
|
coap_opt_t *option;
|
|
|
|
result = coap_option_iterator_init(&pdu, &oi, COAP_OPT_ALL);
|
|
|
|
CU_ASSERT_PTR_EQUAL(result, &oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
CU_ASSERT(oi.type == 1);
|
|
CU_ASSERT_PTR_EQUAL(option, teststr + 7);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
CU_ASSERT(oi.type == 1);
|
|
CU_ASSERT_PTR_EQUAL(option, teststr + 11);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
CU_ASSERT(oi.type == 30);
|
|
CU_ASSERT_PTR_EQUAL(option, teststr + 12);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 1);
|
|
CU_ASSERT_PTR_EQUAL(option, NULL);
|
|
}
|
|
|
|
static void
|
|
t_iterate_option4(void) {
|
|
/* CoAP PDU with token, options, and data */
|
|
uint8_t teststr[] __attribute__ ((aligned (8))) = {
|
|
0x03, 0x00, 0x00, 0x00, 't', 'o', 'k', 0x13,
|
|
'o', 'p', 't', 0x00, 0xd1, 0x10, 'x', 0xff,
|
|
'd', 'a', 't', 'a'
|
|
};
|
|
|
|
coap_pdu_t pdu = {
|
|
.max_size = TEST_MAX_SIZE,
|
|
.hdr = (coap_hdr_t *)teststr,
|
|
.length = sizeof(teststr)
|
|
};
|
|
coap_opt_iterator_t oi, *result;
|
|
coap_opt_t *option;
|
|
|
|
result = coap_option_iterator_init(&pdu, &oi, COAP_OPT_ALL);
|
|
|
|
CU_ASSERT_PTR_EQUAL(result, &oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
CU_ASSERT(oi.type == 1);
|
|
CU_ASSERT_PTR_EQUAL(option, teststr + 7);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
CU_ASSERT(oi.type == 1);
|
|
CU_ASSERT_PTR_EQUAL(option, teststr + 11);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
CU_ASSERT(oi.type == 30);
|
|
CU_ASSERT_PTR_EQUAL(option, teststr + 12);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 1);
|
|
CU_ASSERT_PTR_EQUAL(option, NULL);
|
|
}
|
|
|
|
static void
|
|
t_iterate_option5(void) {
|
|
/* CoAP PDU with malformed option */
|
|
uint8_t teststr[] __attribute__ ((aligned (8))) = {
|
|
0x00, 0x00, 0x00, 0x00, 0x52, 'o', 'p', 0xee,
|
|
0x12, 0x03, 0x00
|
|
};
|
|
|
|
coap_pdu_t pdu = {
|
|
.max_size = TEST_MAX_SIZE,
|
|
.hdr = (coap_hdr_t *)teststr,
|
|
.length = sizeof(teststr)
|
|
};
|
|
coap_opt_iterator_t oi, *result;
|
|
coap_opt_t *option;
|
|
|
|
result = coap_option_iterator_init(&pdu, &oi, COAP_OPT_ALL);
|
|
|
|
CU_ASSERT_PTR_EQUAL(result, &oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
CU_ASSERT(oi.type == 5);
|
|
CU_ASSERT_PTR_EQUAL(option, teststr + 4);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 1);
|
|
CU_ASSERT_PTR_EQUAL(option, NULL);
|
|
}
|
|
|
|
static void
|
|
t_iterate_option6(void) {
|
|
/* option filter */
|
|
/* CoAP PDU with token, options, and data */
|
|
uint8_t teststr[] __attribute__ ((aligned (8))) = {
|
|
0x00, 0x00, 0x00, 0x00, 0x80, 0x20, 0x00, 0x00,
|
|
0xc0, 0x00
|
|
};
|
|
|
|
coap_pdu_t pdu = {
|
|
.max_size = TEST_MAX_SIZE,
|
|
.hdr = (coap_hdr_t *)teststr,
|
|
.length = sizeof(teststr)
|
|
};
|
|
coap_opt_iterator_t oi, *result;
|
|
coap_opt_t *option;
|
|
coap_opt_filter_t filter;
|
|
|
|
coap_option_filter_clear(filter);
|
|
coap_option_setb(filter, 10); /* option nr 10 only */
|
|
result = coap_option_iterator_init(&pdu, &oi, filter);
|
|
|
|
CU_ASSERT_PTR_EQUAL(result, &oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
CU_ASSERT(oi.type == 10);
|
|
CU_ASSERT_PTR_EQUAL(option, teststr + 5);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
CU_ASSERT(oi.type == 10);
|
|
CU_ASSERT_PTR_EQUAL(option, teststr + 6);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
CU_ASSERT(oi.type == 10);
|
|
CU_ASSERT_PTR_EQUAL(option, teststr + 7);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 1);
|
|
CU_ASSERT_PTR_EQUAL(option, NULL);
|
|
}
|
|
|
|
static void
|
|
t_iterate_option7(void) {
|
|
/* option filter */
|
|
uint8_t teststr[] __attribute__ ((aligned (8))) = {
|
|
0x00, 0x00, 0x00, 0x00, 0x80, 0x20, 0x00, 0x00,
|
|
0xc0, 0x00, 0x10, 0x10, 0x00
|
|
};
|
|
|
|
coap_pdu_t pdu = {
|
|
.max_size = TEST_MAX_SIZE,
|
|
.hdr = (coap_hdr_t *)teststr,
|
|
.length = sizeof(teststr)
|
|
};
|
|
coap_opt_iterator_t oi, *result;
|
|
coap_opt_t *option;
|
|
coap_opt_filter_t filter;
|
|
|
|
/* search options nr 8 and 22 */
|
|
coap_option_filter_clear(filter);
|
|
coap_option_setb(filter, 8);
|
|
coap_option_setb(filter, 22);
|
|
result = coap_option_iterator_init(&pdu, &oi, filter);
|
|
|
|
CU_ASSERT_PTR_EQUAL(result, &oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
CU_ASSERT(oi.type == 8);
|
|
CU_ASSERT_PTR_EQUAL(option, teststr + 4);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
CU_ASSERT(oi.type == 22);
|
|
CU_ASSERT_PTR_EQUAL(option, teststr + 8);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
CU_ASSERT(oi.type == 22);
|
|
CU_ASSERT_PTR_EQUAL(option, teststr + 9);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 1);
|
|
CU_ASSERT_PTR_EQUAL(option, NULL);
|
|
}
|
|
|
|
static void
|
|
t_iterate_option8(void) {
|
|
/* option filter */
|
|
uint8_t teststr[] __attribute__ ((aligned (8))) = {
|
|
0x00, 0x00, 0x00, 0x00, 0x80, 0x20, 0x00, 0x00,
|
|
0xc0, 0x00, 0x10, 0x10, 0x00
|
|
};
|
|
|
|
coap_pdu_t pdu = {
|
|
.max_size = TEST_MAX_SIZE,
|
|
.hdr = (coap_hdr_t *)teststr,
|
|
.length = sizeof(teststr)
|
|
};
|
|
coap_opt_iterator_t oi, *result;
|
|
coap_opt_t *option;
|
|
coap_opt_filter_t filter;
|
|
|
|
/* search option nr 36 */
|
|
coap_option_filter_clear(filter);
|
|
coap_option_setb(filter, 36);
|
|
result = coap_option_iterator_init(&pdu, &oi, filter);
|
|
|
|
CU_ASSERT_PTR_EQUAL(result, &oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 1);
|
|
CU_ASSERT_PTR_EQUAL(option, NULL);
|
|
}
|
|
|
|
static void
|
|
t_iterate_option9(void) {
|
|
/* options filter: option number too large for filter */
|
|
uint8_t teststr[] __attribute__ ((aligned (8))) = {
|
|
0x00, 0x00, 0x00, 0x00, 0x80, 0x20, 0x00, 0x00,
|
|
0xc0, 0x00, 0x10, 0x10, 0x00
|
|
};
|
|
|
|
coap_pdu_t pdu = {
|
|
.max_size = TEST_MAX_SIZE,
|
|
.hdr = (coap_hdr_t *)teststr,
|
|
.length = sizeof(teststr)
|
|
};
|
|
coap_opt_iterator_t oi, *result;
|
|
coap_opt_t *option;
|
|
coap_opt_filter_t filter;
|
|
|
|
/* search option nr 100 */
|
|
coap_option_filter_clear(filter);
|
|
coap_option_setb(filter, 100);
|
|
result = coap_option_iterator_init(&pdu, &oi, filter);
|
|
|
|
CU_ASSERT_PTR_EQUAL(result, &oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 1);
|
|
CU_ASSERT_PTR_EQUAL(option, NULL);
|
|
}
|
|
|
|
static void
|
|
t_iterate_option10(void) {
|
|
/* options filter: option numbers in PDU exceed filter size */
|
|
uint8_t teststr[] __attribute__ ((aligned (8))) = {
|
|
0x00, 0x00, 0x00, 0x00, 0x80, 0x20, 0x00, 0x00,
|
|
0xd0, 0x26, 0xe0, 0x10, 0x00
|
|
};
|
|
|
|
coap_pdu_t pdu = {
|
|
.max_size = TEST_MAX_SIZE,
|
|
.hdr = (coap_hdr_t *)teststr,
|
|
.length = sizeof(teststr)
|
|
};
|
|
coap_opt_iterator_t oi, *result;
|
|
coap_opt_t *option;
|
|
coap_opt_filter_t filter;
|
|
|
|
/* search option nr 61 */
|
|
coap_option_filter_clear(filter);
|
|
coap_option_setb(filter, 61);
|
|
result = coap_option_iterator_init(&pdu, &oi, filter);
|
|
|
|
CU_ASSERT_PTR_EQUAL(result, &oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 0);
|
|
CU_ASSERT_PTR_EQUAL(option, teststr + 8);
|
|
|
|
option = coap_option_next(&oi);
|
|
CU_ASSERT(oi.bad == 1);
|
|
CU_ASSERT_PTR_EQUAL(option, NULL);
|
|
}
|
|
|
|
/************************************************************************
|
|
** filter tests
|
|
************************************************************************/
|
|
|
|
static void
|
|
t_filter_option1(void) {
|
|
coap_opt_filter_t filter;
|
|
|
|
coap_option_filter_clear(filter);
|
|
|
|
CU_ASSERT(coap_option_filter_set(filter, 0) == 1);
|
|
CU_ASSERT(coap_option_filter_set(filter, 37) == 1);
|
|
CU_ASSERT(coap_option_filter_set(filter, 37) == 1);
|
|
CU_ASSERT(coap_option_filter_set(filter, 43) == 1);
|
|
CU_ASSERT(coap_option_filter_set(filter, 290) == 1);
|
|
CU_ASSERT(coap_option_filter_set(filter, 65535) == 1);
|
|
|
|
CU_ASSERT(coap_option_filter_get(filter, 0) == 1);
|
|
CU_ASSERT(coap_option_filter_get(filter, 37) == 1);
|
|
CU_ASSERT(coap_option_filter_get(filter, 43) == 1);
|
|
CU_ASSERT(coap_option_filter_get(filter, 290) == 1);
|
|
CU_ASSERT(coap_option_filter_get(filter, 65535) == 1);
|
|
|
|
CU_ASSERT(coap_option_filter_unset(filter, 37) == 1);
|
|
|
|
CU_ASSERT(coap_option_filter_get(filter, 0) == 1);
|
|
CU_ASSERT(coap_option_filter_get(filter, 43) == 1);
|
|
CU_ASSERT(coap_option_filter_get(filter, 290) == 1);
|
|
CU_ASSERT(coap_option_filter_get(filter, 65535) == 1);
|
|
|
|
CU_ASSERT(coap_option_filter_get(filter, 37) == 0);
|
|
CU_ASSERT(coap_option_filter_get(filter, 89) == 0);
|
|
}
|
|
|
|
static void
|
|
t_filter_option2(void) {
|
|
coap_opt_filter_t filter;
|
|
int s;
|
|
|
|
coap_option_filter_clear(filter);
|
|
|
|
/* fill all COAP_OPT_FILTER_SHORT slots */
|
|
for (s = 0; s < COAP_OPT_FILTER_SHORT; s++) {
|
|
CU_ASSERT(coap_option_filter_set(filter, s));
|
|
}
|
|
|
|
/* adding a short option type must fail */
|
|
CU_ASSERT(coap_option_filter_set(filter, COAP_OPT_FILTER_SHORT) == 0);
|
|
|
|
/* adding a long option type must succeed */
|
|
CU_ASSERT(coap_option_filter_set(filter, 256) == 1);
|
|
}
|
|
|
|
static void
|
|
t_filter_option3(void) {
|
|
coap_opt_filter_t filter;
|
|
int l;
|
|
|
|
coap_option_filter_clear(filter);
|
|
|
|
/* set COAP_OPT_FILTER_LONG long filters */
|
|
for (l = 0; l < COAP_OPT_FILTER_LONG; l++) {
|
|
CU_ASSERT(coap_option_filter_set(filter, 256 + l) == 1);
|
|
}
|
|
|
|
/* the next must fail and must not be found */
|
|
CU_ASSERT(coap_option_filter_set(filter, 256 + COAP_OPT_FILTER_LONG) == 0);
|
|
CU_ASSERT(coap_option_filter_get(filter, 256 + COAP_OPT_FILTER_LONG) == 0);
|
|
|
|
/* remove one item */
|
|
CU_ASSERT(coap_option_filter_unset(filter, 256) == 1);
|
|
CU_ASSERT(coap_option_filter_get(filter, 256) == 0);
|
|
|
|
/* now, storing a new filter must succeed */
|
|
CU_ASSERT(coap_option_filter_set(filter, 256 + COAP_OPT_FILTER_LONG) == 1);
|
|
CU_ASSERT(coap_option_filter_get(filter, 256 + COAP_OPT_FILTER_LONG) == 1);
|
|
|
|
/* and all other items must be available as well */
|
|
for (l = 0; l < COAP_OPT_FILTER_LONG; l++) {
|
|
CU_ASSERT(coap_option_filter_get(filter, 256 + l + 1) == 1);
|
|
}
|
|
|
|
/* set COAP_OPT_FILTER_SHORT short filters */
|
|
for (l = 0; l < COAP_OPT_FILTER_SHORT; l++) {
|
|
CU_ASSERT(coap_option_filter_set(filter, l) == 1);
|
|
}
|
|
|
|
/* the next must fail and must not be found */
|
|
CU_ASSERT(coap_option_filter_set(filter, COAP_OPT_FILTER_SHORT) == 0);
|
|
CU_ASSERT(coap_option_filter_get(filter, COAP_OPT_FILTER_SHORT) == 0);
|
|
|
|
/* remove one item */
|
|
CU_ASSERT(coap_option_filter_unset(filter, 0) == 1);
|
|
CU_ASSERT(coap_option_filter_get(filter, 0) == 0);
|
|
|
|
/* now, storing a new filter must succeed */
|
|
CU_ASSERT(coap_option_filter_set(filter, COAP_OPT_FILTER_SHORT) == 1);
|
|
CU_ASSERT(coap_option_filter_get(filter, COAP_OPT_FILTER_SHORT) == 1);
|
|
|
|
/* and all other items must be available as well */
|
|
for (l = 0; l < COAP_OPT_FILTER_SHORT; l++) {
|
|
CU_ASSERT(coap_option_filter_get(filter, l + 1) == 1);
|
|
}
|
|
}
|
|
|
|
/************************************************************************
|
|
** initialization
|
|
************************************************************************/
|
|
|
|
CU_pSuite
|
|
t_init_option_tests(void) {
|
|
CU_pSuite suite[5];
|
|
|
|
suite[0] = CU_add_suite("option parser", NULL, NULL);
|
|
if (!suite[0]) { /* signal error */
|
|
fprintf(stderr, "W: cannot add option parser test suite (%s)\n",
|
|
CU_get_error_msg());
|
|
|
|
return NULL;
|
|
}
|
|
|
|
#define OPTION_TEST(n,s) \
|
|
if (!CU_add_test(suite[0], s, t_parse_option##n)) { \
|
|
fprintf(stderr, "W: cannot add option parser test (%s)\n", \
|
|
CU_get_error_msg()); \
|
|
}
|
|
|
|
OPTION_TEST(1, "parse option #1");
|
|
OPTION_TEST(2, "parse option #2");
|
|
OPTION_TEST(3, "parse option #3");
|
|
OPTION_TEST(4, "parse option #4");
|
|
OPTION_TEST(5, "parse option #5");
|
|
OPTION_TEST(6, "parse option #6");
|
|
OPTION_TEST(7, "parse option #7");
|
|
OPTION_TEST(8, "parse option #8");
|
|
OPTION_TEST(9, "parse option #9");
|
|
OPTION_TEST(10, "parse option #10");
|
|
OPTION_TEST(11, "parse option #11");
|
|
OPTION_TEST(12, "parse option #12");
|
|
OPTION_TEST(13, "parse option #13");
|
|
OPTION_TEST(14, "parse option #14");
|
|
|
|
if ((suite[1] = CU_add_suite("option encoder", NULL, NULL))) {
|
|
#define OPTION_ENCODER_TEST(n,s) \
|
|
if (!CU_add_test(suite[1], s, t_encode_option##n)) { \
|
|
fprintf(stderr, "W: cannot add option encoder test (%s)\n", \
|
|
CU_get_error_msg()); \
|
|
}
|
|
|
|
OPTION_ENCODER_TEST(1, "encode option #1");
|
|
OPTION_ENCODER_TEST(2, "encode option #2");
|
|
OPTION_ENCODER_TEST(3, "encode option #3");
|
|
OPTION_ENCODER_TEST(4, "encode option #4");
|
|
OPTION_ENCODER_TEST(5, "encode option #5");
|
|
OPTION_ENCODER_TEST(6, "encode option #6");
|
|
OPTION_ENCODER_TEST(7, "encode option #7");
|
|
OPTION_ENCODER_TEST(8, "encode option #8");
|
|
|
|
} else {
|
|
fprintf(stderr, "W: cannot add option encoder test suite (%s)\n",
|
|
CU_get_error_msg());
|
|
}
|
|
|
|
if ((suite[2] = CU_add_suite("option accessors", NULL, NULL))) {
|
|
#define OPTION_ACCESSOR_TEST(n,s) \
|
|
if (!CU_add_test(suite[2], s, t_access_option##n)) { \
|
|
fprintf(stderr, "W: cannot add option accessor function test (%s)\n", \
|
|
CU_get_error_msg()); \
|
|
}
|
|
|
|
OPTION_ACCESSOR_TEST(1, "access option #1");
|
|
OPTION_ACCESSOR_TEST(2, "access option #2");
|
|
OPTION_ACCESSOR_TEST(3, "access option #3");
|
|
OPTION_ACCESSOR_TEST(4, "access option #4");
|
|
OPTION_ACCESSOR_TEST(5, "access option #5");
|
|
OPTION_ACCESSOR_TEST(6, "access option #6");
|
|
OPTION_ACCESSOR_TEST(7, "access option #7");
|
|
|
|
} else {
|
|
fprintf(stderr, "W: cannot add option acessor function test suite (%s)\n",
|
|
CU_get_error_msg());
|
|
}
|
|
|
|
if ((suite[3] = CU_add_suite("option iterator", NULL, NULL))) {
|
|
#define OPTION_ITERATOR_TEST(n,s) \
|
|
if (!CU_add_test(suite[3], s, t_iterate_option##n)) { \
|
|
fprintf(stderr, "W: cannot add option iterator test (%s)\n", \
|
|
CU_get_error_msg()); \
|
|
}
|
|
|
|
OPTION_ITERATOR_TEST(1, "option iterator #1");
|
|
OPTION_ITERATOR_TEST(2, "option iterator #2");
|
|
OPTION_ITERATOR_TEST(3, "option iterator #3");
|
|
OPTION_ITERATOR_TEST(4, "option iterator #4");
|
|
OPTION_ITERATOR_TEST(5, "option iterator #5");
|
|
OPTION_ITERATOR_TEST(6, "option iterator #6");
|
|
OPTION_ITERATOR_TEST(7, "option iterator #7");
|
|
OPTION_ITERATOR_TEST(8, "option iterator #8");
|
|
OPTION_ITERATOR_TEST(9, "option iterator #9");
|
|
OPTION_ITERATOR_TEST(10, "option iterator #10");
|
|
|
|
} else {
|
|
fprintf(stderr, "W: cannot add option iterator test suite (%s)\n",
|
|
CU_get_error_msg());
|
|
}
|
|
|
|
if ((suite[4] = CU_add_suite("option filter", NULL, NULL))) {
|
|
#define OPTION_FILTER_TEST(n,s) \
|
|
if (!CU_add_test(suite[4], s, t_filter_option##n)) { \
|
|
fprintf(stderr, "W: cannot add option filter test (%s)\n", \
|
|
CU_get_error_msg()); \
|
|
}
|
|
|
|
OPTION_FILTER_TEST(1, "option filter #1");
|
|
OPTION_FILTER_TEST(2, "option filter #2");
|
|
OPTION_FILTER_TEST(3, "option filter #3");
|
|
|
|
} else {
|
|
fprintf(stderr, "W: cannot add option filter test suite (%s)\n",
|
|
CU_get_error_msg());
|
|
}
|
|
|
|
return suite[0];
|
|
}
|
|
|