mirror of https://github.com/ARMmbed/mbed-os.git
622 lines
21 KiB
C
622 lines
21 KiB
C
/*
|
|
* Copyright (c) 2015 ARM Limited. All rights reserved.
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
* Licensed under the Apache License, Version 2.0 (the License); you may
|
|
* not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/**
|
|
* \file \test_libCoap\Test.c
|
|
*
|
|
* \brief Unit tests for libCoap
|
|
*/
|
|
#include "ns_types.h"
|
|
#include "sn_nsdl.h"
|
|
#include "sn_coap_header.h"
|
|
#include "sn_coap_protocol.h"
|
|
#include "sn_coap_header_internal.h"
|
|
|
|
#include "unity.h"
|
|
#include "string.h"
|
|
#include "stdlib.h"
|
|
|
|
static uint8_t *message_ptr = 0;
|
|
static uint16_t message_len = 0;
|
|
static sn_coap_hdr_s coap_header;
|
|
sn_nsdl_addr_s coap_address;
|
|
static uint8_t address[16] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
|
|
|
|
/* CoAP parameters to be used */
|
|
static uint8_t option_short[3] = {0x61, 0x62, 0x63};
|
|
static uint32_t option_short_value = 0x616263;
|
|
static uint8_t option_path[5] = {0x62, 0x63, 0x2f, 0x61, 0x62};
|
|
static uint8_t option_30[30];
|
|
static uint8_t option_300[300];
|
|
static uint8_t option_600[600];
|
|
static uint8_t option_800[800];
|
|
|
|
/* Resultat sju rätt är: */
|
|
static uint8_t coap_message_no_options[4] = {0x60, 0x44, 0x12, 0x34};
|
|
static uint8_t coap_message_token_payload[11] = {0x63, 0x44, 0x12, 0x34, 0x61, 0x62, 0x63, 0xff, 0x61, 0x62, 0x63};
|
|
static uint8_t coap_message_wrong_version[4] = {0xe0, 0x44, 0x12, 0x34};
|
|
static uint8_t coap_message_malformed[4] = {0x60, 0xae, 0x43, 0x11};
|
|
static uint8_t coap_message_option_short[9] = {0x60, 0x44, 0x12, 0x34, 0xd3, 0x16, 0x61, 0x62, 0x63}; // option number 35
|
|
static uint8_t coap_message_option_30[7] = {0x60, 0x44, 0x12, 0x34, 0xdd, 0x16, 0x11}; // option number 35, length 30
|
|
static uint8_t coap_message_option_300[8] = {0x60, 0x44, 0x12, 0x34, 0xde, 0x16, 0x00, 0x1f}; // option number 35, length 300
|
|
static uint8_t coap_message_option_600[8] = {0x60, 0x44, 0x12, 0x34, 0xde, 0x16, 0x01, 0x4b}; // option number 35, length 600
|
|
static uint8_t coap_message_option_800[8] = {0x60, 0x44, 0x12, 0x34, 0xde, 0x16, 0x02, 0x13}; // option number 35, length 800
|
|
/* Options = Token - 3 bytes, max age - 14 - 3 bytes, Uri path - 11 - 2 x 2 bytes, Uri host - 3 - 3 bytes */
|
|
static uint8_t coap_message_multiple_options[21] = {0x63, 0x44, 0x12, 0x34, 0x61, 0x62, 0x63, 0x33, 0x61, 0x62, 0x63, 0x82, 0x62, 0x63, 0x02, 0x61, 0x62, 0x33, 0x61, 0x62, 0x63};
|
|
|
|
static uint8_t coap_message_empty_con[4] = {0x40, 0x00, 0x12, 0x34};
|
|
static uint8_t coap_message_wrong_code_1[4] = {0x40, 0x24, 0x12, 0x34};
|
|
static uint8_t coap_message_wrong_code_6[4] = {0x40, 0xc4, 0x12, 0x34};
|
|
static uint8_t coap_message_wrong_code_7[4] = {0x40, 0xe4, 0x12, 0x34};
|
|
|
|
|
|
void *own_alloc(uint16_t size);
|
|
void own_free(void *ptr);
|
|
|
|
struct coap_s *handle;
|
|
|
|
uint8_t tx_function(uint8_t *data_ptr, uint16_t data_len, sn_nsdl_addr_s *address_ptr, void *param);
|
|
int8_t rx_callback(sn_coap_hdr_s *coap_header_ptr, sn_nsdl_addr_s *address_ptr, void *param);
|
|
|
|
/* non-test function declarations */
|
|
void fill_with_random(uint8_t *ptr, uint16_t len);
|
|
|
|
/* Unity test code starts */
|
|
void setUp(void)
|
|
{
|
|
//This is run before EACH TEST
|
|
|
|
}
|
|
|
|
void tearDown(void)
|
|
{
|
|
|
|
}
|
|
|
|
void test_libcoap_init(void)
|
|
{
|
|
handle = sn_coap_protocol_init(&own_alloc, &own_free, &tx_function, &rx_callback);
|
|
|
|
TEST_ASSERT_NOT_NULL(handle);
|
|
}
|
|
|
|
|
|
/**
|
|
* \fn test_libcoap_builder_no_options(void)
|
|
*
|
|
* \brief Build CoAP message - ACK - Changed
|
|
*
|
|
*/
|
|
void test_libcoap_builder_no_options(void)
|
|
{
|
|
memset(&coap_header, 0, sizeof(sn_coap_hdr_s));
|
|
coap_header.msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
|
|
coap_header.msg_code = COAP_MSG_CODE_RESPONSE_CHANGED;
|
|
coap_header.msg_id = 0x1234;
|
|
|
|
coap_header.options_list_ptr = malloc(sizeof(sn_coap_options_list_s));
|
|
memset(coap_header.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
|
|
|
|
message_len = sn_coap_builder_calc_needed_packet_data_size(&coap_header);
|
|
message_ptr = malloc(message_len);
|
|
sn_coap_builder(message_ptr, &coap_header);
|
|
|
|
TEST_ASSERT_EQUAL(sizeof(coap_message_no_options), message_len);
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(coap_message_no_options, message_ptr, sizeof(coap_message_no_options));
|
|
|
|
free(message_ptr);
|
|
message_ptr = 0;
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_builder_token_and_payload(void)
|
|
*
|
|
* \brief Build CoAP message - ACK - changed - token - payload
|
|
*
|
|
*/
|
|
void test_libcoap_builder_token_and_payload(void)
|
|
{
|
|
memset(&coap_header, 0, sizeof(sn_coap_hdr_s));
|
|
coap_header.msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
|
|
coap_header.msg_code = COAP_MSG_CODE_RESPONSE_CHANGED;
|
|
coap_header.msg_id = 0x1234;
|
|
coap_header.token_len = sizeof(option_short);
|
|
coap_header.token_ptr = option_short;
|
|
coap_header.payload_len = sizeof(option_short);
|
|
coap_header.payload_ptr = option_short;
|
|
|
|
coap_header.options_list_ptr = malloc(sizeof(sn_coap_options_list_s));
|
|
memset(coap_header.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
|
|
|
|
message_len = sn_coap_builder_calc_needed_packet_data_size(&coap_header);
|
|
message_ptr = malloc(message_len);
|
|
sn_coap_builder(message_ptr, &coap_header);
|
|
|
|
TEST_ASSERT_EQUAL(sizeof(coap_message_token_payload), message_len);
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(coap_message_token_payload, message_ptr, sizeof(coap_message_token_payload));
|
|
|
|
free(message_ptr);
|
|
message_ptr = 0;
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_builder_short_option(void)
|
|
*
|
|
* \brief Build CoAP message - ACK - changed - short proxy URI option
|
|
*
|
|
*/
|
|
void test_libcoap_builder_short_option(void)
|
|
{
|
|
coap_header.token_len = 0;
|
|
coap_header.token_ptr = 0;
|
|
coap_header.payload_len = 0;
|
|
coap_header.payload_ptr = 0;
|
|
|
|
coap_header.options_list_ptr->proxy_uri_len = sizeof(option_short);
|
|
coap_header.options_list_ptr->proxy_uri_ptr = option_short;
|
|
|
|
message_len = sn_coap_builder_calc_needed_packet_data_size(&coap_header);
|
|
message_ptr = malloc(message_len);
|
|
sn_coap_builder(message_ptr, &coap_header);
|
|
|
|
TEST_ASSERT_EQUAL(sizeof(coap_message_option_short), message_len);
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(coap_message_option_short, message_ptr, sizeof(coap_message_option_short));
|
|
|
|
free(message_ptr);
|
|
message_ptr = 0;
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_builder_option_30(void)
|
|
*
|
|
* \brief Build CoAP message - ACK - changed - proxy URI option, length 30 bytes
|
|
*
|
|
*/
|
|
void test_libcoap_builder_option_30(void)
|
|
{
|
|
fill_with_random(option_30, sizeof(option_30));
|
|
coap_header.options_list_ptr->proxy_uri_len = sizeof(option_30);
|
|
coap_header.options_list_ptr->proxy_uri_ptr = option_30;
|
|
|
|
message_len = sn_coap_builder_calc_needed_packet_data_size(&coap_header);
|
|
message_ptr = malloc(message_len);
|
|
sn_coap_builder(message_ptr, &coap_header);
|
|
|
|
TEST_ASSERT_EQUAL((sizeof(coap_message_option_30) + sizeof(option_30)), message_len);
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(coap_message_option_30, message_ptr, sizeof(coap_message_option_30));
|
|
|
|
free(message_ptr);
|
|
message_ptr = 0;
|
|
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_builder_option_300(void)
|
|
*
|
|
* \brief Build CoAP message - ACK - changed - proxy URI option, length 300 bytes
|
|
*
|
|
*/
|
|
void test_libcoap_builder_option_300(void)
|
|
{
|
|
fill_with_random(option_300, sizeof(option_300));
|
|
coap_header.options_list_ptr->proxy_uri_len = sizeof(option_300);
|
|
coap_header.options_list_ptr->proxy_uri_ptr = option_300;
|
|
|
|
message_len = sn_coap_builder_calc_needed_packet_data_size(&coap_header);
|
|
message_ptr = malloc(message_len);
|
|
sn_coap_builder(message_ptr, &coap_header);
|
|
|
|
TEST_ASSERT_EQUAL(sizeof(coap_message_option_300) + sizeof(option_300), message_len);
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(coap_message_option_300, message_ptr, sizeof(coap_message_option_300));
|
|
|
|
free(message_ptr);
|
|
message_ptr = 0;
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_builder_option_600(void)
|
|
*
|
|
* \brief Build CoAP message - ACK - changed - proxy URI option, length 600 bytes
|
|
*
|
|
*/
|
|
|
|
void test_libcoap_builder_option_600(void)
|
|
{
|
|
fill_with_random(option_600, sizeof(option_600));
|
|
coap_header.options_list_ptr->proxy_uri_len = sizeof(option_600);
|
|
coap_header.options_list_ptr->proxy_uri_ptr = option_600;
|
|
|
|
message_len = sn_coap_builder_calc_needed_packet_data_size(&coap_header);
|
|
message_ptr = malloc(message_len);
|
|
sn_coap_builder(message_ptr, &coap_header);
|
|
|
|
TEST_ASSERT_EQUAL(sizeof(coap_message_option_600) + sizeof(option_600), message_len);
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(coap_message_option_600, message_ptr, sizeof(coap_message_option_600));
|
|
|
|
free(message_ptr);
|
|
message_ptr = 0;
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_builder_option_800(void)
|
|
*
|
|
* \brief Build CoAP message - ACK - changed - proxy URI option, length 800 bytes
|
|
*
|
|
*/
|
|
void test_libcoap_builder_option_800(void)
|
|
{
|
|
fill_with_random(option_800, sizeof(option_800));
|
|
coap_header.options_list_ptr->proxy_uri_len = sizeof(option_800);
|
|
coap_header.options_list_ptr->proxy_uri_ptr = option_800;
|
|
|
|
message_len = sn_coap_builder_calc_needed_packet_data_size(&coap_header);
|
|
message_ptr = malloc(message_len);
|
|
sn_coap_builder(message_ptr, &coap_header);
|
|
|
|
TEST_ASSERT_EQUAL(sizeof(coap_message_option_800) + sizeof(option_800), message_len);
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(coap_message_option_800, message_ptr, sizeof(coap_message_option_800));
|
|
|
|
free(message_ptr);
|
|
message_ptr = 0;
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_builder_message_with_multiple_options(void)
|
|
*
|
|
* \brief Build CoAP message - ACK - changed - URI host - URI path - max age - token
|
|
*
|
|
*/
|
|
void test_libcoap_builder_message_with_multiple_options(void)
|
|
{
|
|
coap_header.options_list_ptr->proxy_uri_len = 0;
|
|
coap_header.options_list_ptr->proxy_uri_ptr = 0;
|
|
|
|
coap_header.options_list_ptr->uri_host_len = sizeof(option_short);
|
|
coap_header.options_list_ptr->uri_host_ptr = option_short;
|
|
|
|
coap_header.uri_path_len = sizeof(option_path);
|
|
coap_header.uri_path_ptr = option_path;
|
|
|
|
coap_header.options_list_ptr->max_age = option_short_value;
|
|
|
|
coap_header.token_len = sizeof(option_short);
|
|
coap_header.token_ptr = option_short;
|
|
|
|
message_len = sn_coap_builder_calc_needed_packet_data_size(&coap_header);
|
|
message_ptr = malloc(message_len);
|
|
sn_coap_builder(message_ptr, &coap_header);
|
|
|
|
TEST_ASSERT_EQUAL(sizeof(coap_message_multiple_options), message_len);
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(coap_message_multiple_options, message_ptr, sizeof(coap_message_multiple_options));
|
|
|
|
free(message_ptr);
|
|
message_ptr = 0;
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/*** CoAP PARSER TEST ***/
|
|
/*******************************************************************************/
|
|
|
|
/**
|
|
* \fn test_libcoap_parser_parse_message_without_options(void)
|
|
*
|
|
* \brief call coap protocol parser with message without options (ACK - changed)
|
|
*
|
|
*/
|
|
void test_libcoap_parser_parse_message_without_options(void)
|
|
{
|
|
coap_address.addr_ptr = address;
|
|
|
|
sn_coap_hdr_s *coap_header_ptr = sn_coap_protocol_parse(handle, &coap_address, sizeof(coap_message_no_options), coap_message_no_options, NULL);
|
|
|
|
TEST_ASSERT_NOT_NULL(coap_header_ptr);
|
|
|
|
TEST_ASSERT_EQUAL(COAP_MSG_TYPE_ACKNOWLEDGEMENT, coap_header_ptr->msg_type);
|
|
TEST_ASSERT_EQUAL(COAP_MSG_CODE_RESPONSE_CHANGED, coap_header_ptr->msg_code);
|
|
TEST_ASSERT_EQUAL(0x1234, coap_header_ptr->msg_id);
|
|
|
|
sn_coap_parser_release_allocated_coap_msg_mem(handle, coap_header_ptr);
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_parser_parse_message_with_payload_and_token(void)
|
|
*
|
|
* \brief call coap protocol parser with message with token option and small payload (ACK - changed)
|
|
*
|
|
*/
|
|
void test_libcoap_parser_parse_message_with_payload_and_token(void)
|
|
{
|
|
coap_address.addr_ptr = address;
|
|
|
|
sn_coap_hdr_s *coap_header_ptr = sn_coap_protocol_parse(handle, &coap_address, sizeof(coap_message_token_payload), coap_message_token_payload, NULL);
|
|
|
|
TEST_ASSERT_NOT_NULL(coap_header_ptr);
|
|
|
|
TEST_ASSERT_EQUAL(COAP_MSG_TYPE_ACKNOWLEDGEMENT, coap_header_ptr->msg_type);
|
|
TEST_ASSERT_EQUAL(COAP_MSG_CODE_RESPONSE_CHANGED, coap_header_ptr->msg_code);
|
|
TEST_ASSERT_EQUAL(0x1234, coap_header_ptr->msg_id);
|
|
|
|
TEST_ASSERT_EQUAL(3, coap_header_ptr->token_len);
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(option_short, coap_header_ptr->token_ptr, sizeof(option_short));
|
|
|
|
TEST_ASSERT_EQUAL(3, coap_header_ptr->payload_len);
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(option_short, coap_header_ptr->payload_ptr, sizeof(option_short));
|
|
|
|
sn_coap_parser_release_allocated_coap_msg_mem(handle, coap_header_ptr);
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_parser_parse_message_with_small_option(void)
|
|
*
|
|
* \brief call coap protocol parser with message with small option (ACK - changed - URI query)
|
|
*
|
|
*/
|
|
void test_libcoap_parser_parse_message_with_small_option(void)
|
|
{
|
|
coap_address.addr_ptr = address;
|
|
|
|
sn_coap_hdr_s *coap_header_ptr = sn_coap_protocol_parse(handle, &coap_address, sizeof(coap_message_option_short), coap_message_option_short, NULL);
|
|
|
|
TEST_ASSERT_NOT_NULL(coap_header_ptr);
|
|
TEST_ASSERT_NOT_NULL(coap_header_ptr->options_list_ptr);
|
|
|
|
TEST_ASSERT_EQUAL(COAP_MSG_TYPE_ACKNOWLEDGEMENT, coap_header_ptr->msg_type);
|
|
TEST_ASSERT_EQUAL(COAP_MSG_CODE_RESPONSE_CHANGED, coap_header_ptr->msg_code);
|
|
TEST_ASSERT_EQUAL(0x1234, coap_header_ptr->msg_id);
|
|
|
|
TEST_ASSERT_EQUAL(sizeof(option_short), coap_header_ptr->options_list_ptr->proxy_uri_len);
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(option_short, coap_header_ptr->options_list_ptr->proxy_uri_ptr, sizeof(option_short));
|
|
|
|
sn_coap_parser_release_allocated_coap_msg_mem(handle, coap_header_ptr);
|
|
}
|
|
|
|
|
|
/**
|
|
* \fn test_libcoap_parser_parse_message_with_multiple_options(void)
|
|
*
|
|
* \brief call coap protocol parser with message with multiple options (ACK - changed - token - max age - URI path - URI host)
|
|
*
|
|
*/
|
|
void test_libcoap_parser_parse_message_with_multiple_options(void)
|
|
{
|
|
coap_address.addr_ptr = address;
|
|
|
|
sn_coap_hdr_s *coap_header_ptr = sn_coap_protocol_parse(handle, &coap_address, sizeof(coap_message_multiple_options), coap_message_multiple_options, NULL);
|
|
|
|
TEST_ASSERT_NOT_NULL(coap_header_ptr);
|
|
TEST_ASSERT_NOT_NULL(coap_header_ptr->options_list_ptr);
|
|
|
|
TEST_ASSERT_EQUAL(COAP_MSG_TYPE_ACKNOWLEDGEMENT, coap_header_ptr->msg_type);
|
|
TEST_ASSERT_EQUAL(COAP_MSG_CODE_RESPONSE_CHANGED, coap_header_ptr->msg_code);
|
|
TEST_ASSERT_EQUAL(0x1234, coap_header_ptr->msg_id);
|
|
|
|
|
|
TEST_ASSERT_EQUAL(sizeof(option_short), coap_header_ptr->options_list_ptr->uri_host_len);
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(option_short, coap_header_ptr->options_list_ptr->uri_host_ptr, sizeof(option_short));
|
|
|
|
TEST_ASSERT_EQUAL(sizeof(option_path), coap_header_ptr->uri_path_len);
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(option_path, coap_header_ptr->uri_path_ptr, sizeof(option_path));
|
|
|
|
TEST_ASSERT_EQUAL(option_short_value, coap_header_ptr->options_list_ptr->max_age);
|
|
|
|
TEST_ASSERT_EQUAL(sizeof(option_short), coap_header_ptr->token_len);
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(option_short, coap_header_ptr->token_ptr, sizeof(option_short));
|
|
|
|
|
|
sn_coap_parser_release_allocated_coap_msg_mem(handle, coap_header_ptr);
|
|
}
|
|
|
|
/*******************************************************************************/
|
|
/*** NEGATIVE TEST CASES ***/
|
|
/*******************************************************************************/
|
|
|
|
/**
|
|
* \fn test_libcoap_negative_build_with_null_pointer(void)
|
|
*
|
|
* \brief - Call sn_coap_builder_calc_needed_packet_data_size with null pointer parameter
|
|
* - Call sn_coap_builder with null pointer parameter
|
|
*
|
|
*/
|
|
void test_libcoap_negative_build_with_null_pointer(void)
|
|
{
|
|
int16_t ret_val_1 = 0;
|
|
int16_t ret_val_2 = 0;
|
|
|
|
message_len = sn_coap_builder_calc_needed_packet_data_size(NULL);
|
|
ret_val_1 = sn_coap_builder(message_ptr, NULL);
|
|
ret_val_2 = sn_coap_builder(NULL, &coap_header);
|
|
|
|
TEST_ASSERT_EQUAL(0, message_len);
|
|
TEST_ASSERT_EQUAL(-2, ret_val_1);
|
|
TEST_ASSERT_EQUAL(-2, ret_val_2);
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_negative_parse_with_null_pointer(void)
|
|
*
|
|
* \brief - Call sn_coap_protocol_parse with null pointer parameter
|
|
*
|
|
*/
|
|
void test_libcoap_negative_parse_with_null_pointer(void)
|
|
{
|
|
coap_address.addr_ptr = address;
|
|
|
|
sn_coap_hdr_s *coap_header_ptr = sn_coap_protocol_parse(handle, NULL, sizeof(coap_message_no_options), coap_message_no_options, NULL);
|
|
TEST_ASSERT_NULL(coap_header_ptr);
|
|
|
|
coap_header_ptr = sn_coap_protocol_parse(NULL, &coap_address, sizeof(coap_message_no_options), coap_message_no_options, NULL);
|
|
TEST_ASSERT_NULL(coap_header_ptr);
|
|
|
|
coap_header_ptr = sn_coap_protocol_parse(handle, &coap_address, sizeof(coap_message_no_options), NULL, NULL);
|
|
TEST_ASSERT_NULL(coap_header_ptr);
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_negative_parse_with_coap_packet_len_null(void)
|
|
*
|
|
* \brief - Call sn_coap_protocol_parse with parameter length = 0
|
|
*
|
|
*/
|
|
void test_libcoap_negative_parse_with_coap_packet_len_null(void)
|
|
{
|
|
coap_address.addr_ptr = address;
|
|
|
|
sn_coap_hdr_s *coap_header_ptr = sn_coap_protocol_parse(handle, &coap_address, 0, coap_message_no_options, NULL);
|
|
TEST_ASSERT_NULL(coap_header_ptr);
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_negative_parse_with_wrong_coap_packet_len(void)
|
|
*
|
|
* \brief - Call sn_coap_protocol_parse with wrong packet length
|
|
*
|
|
*/
|
|
void test_libcoap_negative_parse_with_wrong_coap_packet_len(void)
|
|
{
|
|
coap_address.addr_ptr = address;
|
|
|
|
sn_coap_hdr_s *coap_header_ptr = sn_coap_protocol_parse(handle, &coap_address, (sizeof(coap_message_multiple_options) - 1), coap_message_multiple_options, NULL);
|
|
TEST_ASSERT_NULL(coap_header_ptr);
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_negative_parse_with_wrong_coap_version(void)
|
|
*
|
|
* \brief - Call sn_coap_protocol_parse with wrong CoAP version
|
|
*
|
|
*/
|
|
void test_libcoap_negative_parse_with_wrong_coap_version(void)
|
|
{
|
|
coap_address.addr_ptr = address;
|
|
|
|
sn_coap_hdr_s *coap_header_ptr = sn_coap_protocol_parse(handle, &coap_address, sizeof(coap_message_wrong_version), coap_message_wrong_version, NULL);
|
|
TEST_ASSERT_NULL(coap_header_ptr);
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_negative_parse_malformed_coap(void)
|
|
*
|
|
* \brief - Call sn_coap_protocol_parse with malformed CoAP message
|
|
*
|
|
*/
|
|
void test_libcoap_negative_parse_malformed_coap(void)
|
|
{
|
|
coap_address.addr_ptr = address;
|
|
|
|
sn_coap_hdr_s *coap_header_ptr = sn_coap_protocol_parse(handle, &coap_address, sizeof(coap_message_malformed), coap_message_malformed, NULL);
|
|
TEST_ASSERT_NULL(coap_header_ptr);
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_negative_parse_empty_con(void)
|
|
*
|
|
* \brief - Call sn_coap_protocol_parse with "CoAP ping" message. Should return RST
|
|
*
|
|
*/
|
|
void test_libcoap_negative_parse_empty_con(void)
|
|
{
|
|
coap_address.addr_ptr = address;
|
|
|
|
sn_coap_hdr_s *coap_header_ptr = sn_coap_protocol_parse(handle, &coap_address, sizeof(coap_message_empty_con), coap_message_empty_con, NULL);
|
|
TEST_ASSERT_NULL(coap_header_ptr);
|
|
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_negative_parse_wrong_code_1(void)
|
|
*
|
|
* \brief - Call sn_coap_protocol_parse with wrong message code. Should return RST
|
|
*
|
|
*/
|
|
void test_libcoap_negative_parse_wrong_code_1(void)
|
|
{
|
|
coap_address.addr_ptr = address;
|
|
|
|
sn_coap_hdr_s *coap_header_ptr = sn_coap_protocol_parse(handle, &coap_address, sizeof(coap_message_wrong_code_1), coap_message_wrong_code_1, NULL);
|
|
TEST_ASSERT_NULL(coap_header_ptr);
|
|
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_negative_parse_wrong_code_6(void)
|
|
*
|
|
* \brief - Call sn_coap_protocol_parse with wrong message code. Should return RST
|
|
*
|
|
*/
|
|
void test_libcoap_negative_parse_wrong_code_6(void)
|
|
{
|
|
coap_address.addr_ptr = address;
|
|
|
|
sn_coap_hdr_s *coap_header_ptr = sn_coap_protocol_parse(handle, &coap_address, sizeof(coap_message_wrong_code_6), coap_message_wrong_code_6, NULL);
|
|
TEST_ASSERT_NULL(coap_header_ptr);
|
|
|
|
}
|
|
|
|
/**
|
|
* \fn test_libcoap_negative_parse_wrong_code_7(void)
|
|
*
|
|
* \brief - Call sn_coap_protocol_parse with wrong message code. Should return RST
|
|
*
|
|
*/
|
|
void test_libcoap_negative_parse_wrong_code_7(void)
|
|
{
|
|
coap_address.addr_ptr = address;
|
|
|
|
sn_coap_hdr_s *coap_header_ptr = sn_coap_protocol_parse(handle, &coap_address, sizeof(coap_message_wrong_code_7), coap_message_wrong_code_7, NULL);
|
|
TEST_ASSERT_NULL(coap_header_ptr);
|
|
|
|
}
|
|
|
|
|
|
/*******************************/
|
|
/*** non-test functions ***/
|
|
/*******************************/
|
|
|
|
void fill_with_random(uint8_t *ptr, uint16_t len)
|
|
{
|
|
while (len--) {
|
|
*(ptr + len) = 'a';
|
|
}
|
|
}
|
|
|
|
void *own_alloc(uint16_t size)
|
|
{
|
|
return malloc(size);
|
|
}
|
|
|
|
void own_free(void *ptr)
|
|
{
|
|
free(ptr);
|
|
}
|
|
|
|
uint8_t tx_function(uint8_t *data_ptr, uint16_t data_len, sn_nsdl_addr_s *address_ptr, void *param)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int8_t rx_callback(sn_coap_hdr_s *coap_header_ptr, sn_nsdl_addr_s *address_ptr, void *param)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|