mirror of
https://gitlab.com/d3tn/ud3tn.git
synced 2026-08-13 12:33:27 +02:00
591 lines
16 KiB
C
591 lines
16 KiB
C
// SPDX-License-Identifier: BSD-3-Clause OR Apache-2.0
|
|
/**
|
|
* Unit Test for BPbis parser
|
|
*
|
|
* Raw CBOR data is loaded from "test_bundle7Data.c".
|
|
*/
|
|
|
|
#include "bundle7/bundle_age.h"
|
|
#include "bundle7/eid.h"
|
|
#include "bundle7/hopcount.h"
|
|
#include "bundle7/parser.h"
|
|
#include "bundle7/reports.h"
|
|
|
|
#include "ud3tn/bundle.h"
|
|
#include "ud3tn/report_manager.h"
|
|
|
|
#include "testud3tn_unity.h"
|
|
#include "testud3tn_eid_helpers.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
|
|
TEST_GROUP(bundle7Parser);
|
|
|
|
extern uint8_t cbor_simple_bundle[];
|
|
extern size_t len_simple_bundle;
|
|
|
|
static struct bundle *bundle;
|
|
|
|
static void send_callback(struct bundle *_bundle, void *param)
|
|
{
|
|
(void)param;
|
|
bundle = _bundle;
|
|
}
|
|
|
|
|
|
TEST_SETUP(bundle7Parser)
|
|
{
|
|
bundle = NULL;
|
|
}
|
|
|
|
|
|
TEST_TEAR_DOWN(bundle7Parser)
|
|
{
|
|
if (bundle != NULL) {
|
|
bundle_free(bundle);
|
|
bundle = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
TEST(bundle7Parser, eid_parser)
|
|
{
|
|
struct eid eid;
|
|
|
|
// dtn
|
|
const uint8_t sat_1[] = { 0x82, 0x01, 0x64, 0x2f, 0x2f, 0x54, 0x31 };
|
|
// ipn 2-element
|
|
const uint8_t ipn[] = { 0x82, 0x02, 0x82, 0x18, 0x2a, 0x18, 0x48 };
|
|
const uint8_t ipn2[] = { 0x82, 0x02, 0x82, 0x18, 0x2a, 0x00 };
|
|
const uint8_t ipn3[] = { 0x82, 0x02, 0x82, 0x00, 0x00 }; // ipn 2-elem null
|
|
const uint8_t ipn4[] = {
|
|
0x82, 0x02, 0x82,
|
|
0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
};
|
|
// ipn 3-element
|
|
const uint8_t ipn_31[] = { 0x82, 0x02, 0x83, 0x00, 0x18, 0x2a, 0x18, 0x48 };
|
|
const uint8_t ipn_32[] = { 0x82, 0x02, 0x83, 0x18, 0x2a, 0x00, 0x00 };
|
|
const uint8_t ipn_33[] = { 0x82, 0x02, 0x83, 0x00, 0x00, 0x00, 0x00 }; // ipn 3-elem null
|
|
const uint8_t ipn_34[] = {
|
|
0x82, 0x02, 0x83,
|
|
0x1a, 0xff, 0xff, 0xff, 0xff,
|
|
0x1a, 0xff, 0xff, 0xff, 0xff,
|
|
0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
};
|
|
// dtn:none
|
|
const uint8_t none[] = { 0x82, 0x01, 0x00 };
|
|
|
|
eid = bundle7_eid_parse(sat_1, sizeof(sat_1));
|
|
TEST_ASSERT_FALSE(eid_is_error(eid));
|
|
TEST_ASSERT(eid_eq(EID_DTN("dtn://T1"), eid));
|
|
eid_free(eid);
|
|
|
|
eid = bundle7_eid_parse(ipn, sizeof(ipn));
|
|
TEST_ASSERT_FALSE(eid_is_error(eid));
|
|
TEST_ASSERT(eid_eq(EID_IPN_S("ipn:42.72"), eid));
|
|
eid_free(eid);
|
|
|
|
eid = bundle7_eid_parse(ipn2, sizeof(ipn2));
|
|
TEST_ASSERT_FALSE(eid_is_error(eid));
|
|
TEST_ASSERT(eid_eq(EID_IPN_S("ipn:42.0"), eid));
|
|
eid_free(eid);
|
|
|
|
eid = bundle7_eid_parse(ipn3, sizeof(ipn3));
|
|
TEST_ASSERT_FALSE(eid_is_error(eid));
|
|
TEST_ASSERT(eid_is_null(eid));
|
|
TEST_ASSERT_EQUAL_AEID(EID_IPN_S("ipn:0.0"), eid);
|
|
TEST_ASSERT(eid_eq(EID_NULL_DTN, eid));
|
|
TEST_ASSERT(eid_eq(EID_NULL_IPN, eid));
|
|
eid_free(eid);
|
|
|
|
eid = bundle7_eid_parse(ipn4, sizeof(ipn4));
|
|
TEST_ASSERT_FALSE(eid_is_error(eid));
|
|
TEST_ASSERT(eid_eq(EID_IPN_S("ipn:18446744073709551615.18446744073709551615"), eid));
|
|
eid_free(eid);
|
|
|
|
eid = bundle7_eid_parse(ipn_31, sizeof(ipn_31));
|
|
TEST_ASSERT_FALSE(eid_is_error(eid));
|
|
TEST_ASSERT_EQUAL_AEID(EID_IPN_3(0, 42, 72), eid);
|
|
eid_free(eid);
|
|
|
|
eid = bundle7_eid_parse(ipn_32, sizeof(ipn_32));
|
|
TEST_ASSERT_FALSE(eid_is_error(eid));
|
|
TEST_ASSERT_EQUAL_AEID(EID_IPN_3(42, 0, 0), eid);
|
|
eid_free(eid);
|
|
|
|
eid = bundle7_eid_parse(ipn_33, sizeof(ipn_33));
|
|
TEST_ASSERT_FALSE(eid_is_error(eid));
|
|
TEST_ASSERT_EQUAL_AEID(EID_IPN_S("ipn:0.0.0"), eid);
|
|
eid_free(eid);
|
|
|
|
eid = bundle7_eid_parse(ipn_34, sizeof(ipn_34));
|
|
TEST_ASSERT_FALSE(eid_is_error(eid));
|
|
TEST_ASSERT(eid_eq(EID_IPN(18446744073709551615ULL, 18446744073709551615ULL), eid));
|
|
eid_free(eid);
|
|
|
|
eid = bundle7_eid_parse(none, sizeof(none));
|
|
TEST_ASSERT_FALSE(eid_is_error(eid));
|
|
TEST_ASSERT(eid_is_null(eid));
|
|
TEST_ASSERT(eid_eq(EID_IPN_S("ipn:0.0"), eid));
|
|
TEST_ASSERT(eid_eq(EID_NULL_DTN, eid));
|
|
TEST_ASSERT(eid_eq(EID_NULL_IPN, eid));
|
|
eid_free(eid);
|
|
}
|
|
|
|
static void parse_bundle_chunked(const size_t chunk_size)
|
|
{
|
|
struct bundle7_parser state;
|
|
struct parser *parser = bundle7_parser_init(
|
|
&state,
|
|
&send_callback,
|
|
NULL
|
|
);
|
|
|
|
TEST_ASSERT_NOT_NULL(parser);
|
|
|
|
size_t read = 0;
|
|
size_t chunk = chunk_size;
|
|
|
|
while (read < len_simple_bundle && state.basedata->status == PARSER_STATUS_GOOD) {
|
|
if (state.basedata->flags & PARSER_FLAG_BULK_READ) {
|
|
TEST_ASSERT_TRUE(read + state.basedata->next_bytes
|
|
< len_simple_bundle);
|
|
|
|
// Bulk read operation
|
|
memcpy(state.basedata->next_buffer,
|
|
cbor_simple_bundle + read,
|
|
state.basedata->next_bytes);
|
|
|
|
// Advance parsing pointer
|
|
read += state.basedata->next_bytes;
|
|
|
|
// Deactivate bulk read mode
|
|
state.basedata->flags &= ~PARSER_FLAG_BULK_READ;
|
|
} else {
|
|
if (chunk + read >= len_simple_bundle)
|
|
chunk = len_simple_bundle - read;
|
|
|
|
size_t parsed = bundle7_parser_read(&state,
|
|
cbor_simple_bundle + read,
|
|
chunk);
|
|
|
|
if (parsed == 0) {
|
|
chunk *= 2;
|
|
} else {
|
|
chunk = chunk_size;
|
|
read += parsed;
|
|
}
|
|
}
|
|
|
|
TEST_ASSERT_NOT_EQUAL(state.basedata->status,
|
|
PARSER_STATUS_ERROR);
|
|
}
|
|
|
|
TEST_ASSERT_EQUAL(PARSER_STATUS_DONE, state.basedata->status);
|
|
TEST_ASSERT_FALSE(state.basedata->flags & PARSER_FLAG_CRC_INVALID);
|
|
TEST_ASSERT_NULL(state.bundle);
|
|
TEST_ASSERT_NOT_NULL(bundle);
|
|
|
|
// Creation Timestamp 2020-11-12T09:51:03
|
|
TEST_ASSERT_EQUAL(658489863000, bundle->creation_timestamp_ms);
|
|
|
|
// Primary block CRC
|
|
TEST_ASSERT_EQUAL(BUNDLE_CRC_TYPE_NONE, bundle->crc_type);
|
|
|
|
// Bundle Processing flags
|
|
TEST_ASSERT_TRUE(bundle->proc_flags
|
|
& BUNDLE_FLAG_MUST_NOT_BE_FRAGMENTED);
|
|
TEST_ASSERT_TRUE(bundle->proc_flags
|
|
& BUNDLE_FLAG_REPORT_DELIVERY);
|
|
TEST_ASSERT_FALSE(bundle->proc_flags
|
|
& BUNDLE_FLAG_IS_FRAGMENT);
|
|
TEST_ASSERT_FALSE(bundle->proc_flags
|
|
& BUNDLE_FLAG_ADMINISTRATIVE_RECORD);
|
|
TEST_ASSERT_FALSE(bundle->proc_flags
|
|
& BUNDLE_FLAG_ACKNOWLEDGEMENT_REQUESTED);
|
|
TEST_ASSERT_FALSE(bundle->proc_flags
|
|
& BUNDLE_V6_FLAG_NORMAL_PRIORITY);
|
|
TEST_ASSERT_FALSE(bundle->proc_flags
|
|
& BUNDLE_V6_FLAG_EXPEDITED_PRIORITY);
|
|
TEST_ASSERT_FALSE(bundle->proc_flags
|
|
& BUNDLE_FLAG_REPORT_RECEPTION);
|
|
TEST_ASSERT_FALSE(bundle->proc_flags
|
|
& BUNDLE_FLAG_REPORT_FORWARDING);
|
|
TEST_ASSERT_FALSE(bundle->proc_flags
|
|
& BUNDLE_FLAG_REPORT_DELETION);
|
|
TEST_ASSERT_FALSE(bundle->proc_flags
|
|
& BUNDLE_FLAG_REPORT_STATUS_TIME);
|
|
|
|
struct bundle_block_list *block_element = bundle->blocks;
|
|
|
|
// Previous node block
|
|
TEST_ASSERT_EQUAL(BUNDLE_BLOCK_TYPE_PREVIOUS_NODE,
|
|
block_element->data->type);
|
|
TEST_ASSERT_EQUAL(BUNDLE_BLOCK_FLAG_NONE,
|
|
block_element->data->flags);
|
|
TEST_ASSERT_EQUAL(6, block_element->data->length);
|
|
|
|
uint8_t previous_node[6] = {
|
|
0x82, 0x01, 0x63, 0x47, 0x53, 0x34
|
|
};
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(previous_node,
|
|
block_element->data->data, 6);
|
|
TEST_ASSERT_EQUAL(BUNDLE_CRC_TYPE_NONE, block_element->data->crc_type);
|
|
|
|
// Hop count block
|
|
block_element = block_element->next;
|
|
TEST_ASSERT_EQUAL(BUNDLE_BLOCK_TYPE_HOP_COUNT,
|
|
block_element->data->type);
|
|
TEST_ASSERT_EQUAL(4, block_element->data->length);
|
|
|
|
uint8_t hop_count[4] = {
|
|
0x82, 0x18, 0x1e, 0x00
|
|
};
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(hop_count, block_element->data->data, 4);
|
|
TEST_ASSERT_EQUAL(BUNDLE_CRC_TYPE_NONE, block_element->data->crc_type);
|
|
|
|
// Bundle age block
|
|
block_element = block_element->next;
|
|
TEST_ASSERT_EQUAL(BUNDLE_BLOCK_TYPE_BUNDLE_AGE,
|
|
block_element->data->type);
|
|
TEST_ASSERT_EQUAL(1, block_element->data->length);
|
|
|
|
uint8_t bundle_age[1] = { 0x00 };
|
|
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(bundle_age, block_element->data->data, 1);
|
|
|
|
// Payload
|
|
block_element = block_element->next;
|
|
TEST_ASSERT_EQUAL_PTR(block_element->data,
|
|
bundle->payload_block);
|
|
|
|
// Payload block must be the last block
|
|
TEST_ASSERT_NULL(block_element->next);
|
|
|
|
uint8_t payload[] = {
|
|
'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!',
|
|
};
|
|
|
|
TEST_ASSERT_EQUAL(sizeof(payload), bundle->payload_block->length);
|
|
TEST_ASSERT_EQUAL_INT8_ARRAY(payload,
|
|
bundle->payload_block->data, 12);
|
|
TEST_ASSERT_EQUAL(BUNDLE_CRC_TYPE_NONE, block_element->data->crc_type);
|
|
|
|
TEST_ASSERT_EQUAL(len_simple_bundle,
|
|
bundle_get_serialized_size(bundle));
|
|
|
|
// Assert that serialized length is correct after recalculation
|
|
bundle_recalculate_header_length(bundle);
|
|
|
|
TEST_ASSERT_EQUAL(len_simple_bundle,
|
|
bundle_get_serialized_size(bundle));
|
|
|
|
bundle7_parser_reset(&state);
|
|
bundle_free(state.bundle);
|
|
free(parser);
|
|
}
|
|
|
|
TEST(bundle7Parser, bundle_parser)
|
|
{
|
|
for (size_t chunk = 1; chunk < len_simple_bundle; ++chunk) {
|
|
parse_bundle_chunked(chunk);
|
|
|
|
// Clear bundle
|
|
bundle_free(bundle);
|
|
bundle = NULL;
|
|
}
|
|
}
|
|
|
|
// -------------------------
|
|
// CRC 16 AX.25 Verification
|
|
// -------------------------
|
|
//
|
|
extern uint8_t cbor_crc16_primary_block[];
|
|
extern uint8_t cbor_crc16_payload_block[];
|
|
extern size_t len_crc16_primary_block;
|
|
extern size_t len_crc16_payload_block;
|
|
|
|
TEST(bundle7Parser, crc16_verification)
|
|
{
|
|
struct bundle7_parser state;
|
|
struct parser *parser = bundle7_parser_init(
|
|
&state,
|
|
&send_callback,
|
|
NULL
|
|
);
|
|
|
|
TEST_ASSERT_NOT_NULL(parser);
|
|
|
|
//
|
|
// CRC 16 primary block checksum
|
|
// -----------------------------
|
|
//
|
|
size_t parsed = bundle7_parser_read(&state, cbor_crc16_primary_block,
|
|
len_crc16_primary_block);
|
|
|
|
TEST_ASSERT_EQUAL(PARSER_STATUS_DONE, state.basedata->status);
|
|
TEST_ASSERT_FALSE(state.basedata->flags & PARSER_FLAG_CRC_INVALID);
|
|
TEST_ASSERT_EQUAL(parsed, len_crc16_primary_block);
|
|
TEST_ASSERT_NULL(state.bundle);
|
|
TEST_ASSERT_NOT_NULL(bundle);
|
|
|
|
TEST_ASSERT_EQUAL(bundle->crc.checksum, 0xb196);
|
|
|
|
// Clear bundle
|
|
bundle_free(bundle);
|
|
bundle = NULL;
|
|
|
|
//
|
|
// CRC 16 payload block checksum
|
|
// -----------------------------
|
|
//
|
|
bundle7_parser_reset(&state);
|
|
|
|
parsed = bundle7_parser_read(&state, cbor_crc16_payload_block,
|
|
len_crc16_payload_block);
|
|
|
|
TEST_ASSERT_EQUAL(PARSER_STATUS_DONE, state.basedata->status);
|
|
TEST_ASSERT_FALSE(state.basedata->flags & PARSER_FLAG_CRC_INVALID);
|
|
TEST_ASSERT_EQUAL(parsed, len_crc16_payload_block);
|
|
TEST_ASSERT_NULL(state.bundle);
|
|
TEST_ASSERT_NOT_NULL(bundle);
|
|
|
|
TEST_ASSERT_EQUAL(bundle->payload_block->crc.checksum, 0x60d7);
|
|
|
|
// Clear bundle
|
|
bundle_free(bundle);
|
|
bundle = NULL;
|
|
|
|
free(parser);
|
|
}
|
|
|
|
// ------------------------------
|
|
// CRC 32 Castagnoli Verification
|
|
// ------------------------------
|
|
//
|
|
extern uint8_t cbor_crc32_primary_block[];
|
|
extern uint8_t cbor_crc32_payload_block[];
|
|
extern size_t len_crc32_primary_block;
|
|
extern size_t len_crc32_payload_block;
|
|
|
|
TEST(bundle7Parser, crc32_verification)
|
|
{
|
|
struct bundle7_parser state;
|
|
struct parser *parser = bundle7_parser_init(
|
|
&state,
|
|
&send_callback,
|
|
NULL
|
|
);
|
|
|
|
TEST_ASSERT_NOT_NULL(parser);
|
|
|
|
//
|
|
// CRC 32 primary block checksum
|
|
// -----------------------------
|
|
//
|
|
size_t parsed = bundle7_parser_read(&state, cbor_crc32_primary_block,
|
|
len_crc32_primary_block);
|
|
|
|
TEST_ASSERT_EQUAL(PARSER_STATUS_DONE, state.basedata->status);
|
|
TEST_ASSERT_FALSE(state.basedata->flags & PARSER_FLAG_CRC_INVALID);
|
|
TEST_ASSERT_EQUAL(parsed, len_crc32_primary_block);
|
|
TEST_ASSERT_NULL(state.bundle);
|
|
TEST_ASSERT_NOT_NULL(bundle);
|
|
|
|
TEST_ASSERT_EQUAL(bundle->crc.checksum, 0xb05c7c1e);
|
|
|
|
// Clear bundle
|
|
bundle_free(bundle);
|
|
bundle = NULL;
|
|
|
|
//
|
|
// CRC 32 payload block checksum
|
|
// -----------------------------
|
|
//
|
|
bundle7_parser_reset(&state);
|
|
|
|
parsed = bundle7_parser_read(&state, cbor_crc32_payload_block,
|
|
len_crc32_payload_block);
|
|
|
|
TEST_ASSERT_EQUAL(PARSER_STATUS_DONE, state.basedata->status);
|
|
TEST_ASSERT_FALSE(state.basedata->flags & PARSER_FLAG_CRC_INVALID);
|
|
TEST_ASSERT_EQUAL(parsed, len_crc32_payload_block);
|
|
TEST_ASSERT_NULL(state.bundle);
|
|
TEST_ASSERT_NOT_NULL(bundle);
|
|
|
|
TEST_ASSERT_EQUAL(bundle->payload_block->crc.checksum, 0xc3aec552);
|
|
|
|
// Clear bundle
|
|
bundle_free(bundle);
|
|
bundle = NULL;
|
|
|
|
free(parser);
|
|
}
|
|
|
|
// --------------------
|
|
// Invalid CRC Handling
|
|
// --------------------
|
|
|
|
extern uint8_t cbor_invalid_crc16[];
|
|
extern size_t len_invalid_crc16;
|
|
|
|
TEST(bundle7Parser, invalid_crc_handling)
|
|
{
|
|
struct bundle7_parser state;
|
|
struct parser *parser = bundle7_parser_init(
|
|
&state,
|
|
&send_callback,
|
|
NULL
|
|
);
|
|
|
|
TEST_ASSERT_NOT_NULL(parser);
|
|
|
|
size_t parsed = bundle7_parser_read(&state, cbor_invalid_crc16,
|
|
len_invalid_crc16);
|
|
|
|
// The bundle must be parsed completely
|
|
TEST_ASSERT_EQUAL(PARSER_STATUS_DONE, state.basedata->status);
|
|
TEST_ASSERT_EQUAL(parsed, len_invalid_crc16);
|
|
|
|
// but the CRC_INVALID flag must be set
|
|
TEST_ASSERT_TRUE(state.basedata->flags & PARSER_FLAG_CRC_INVALID);
|
|
|
|
// and the bundle must not be send callback must not be called
|
|
TEST_ASSERT_NULL(state.bundle);
|
|
TEST_ASSERT_NULL(bundle);
|
|
|
|
free(parser);
|
|
}
|
|
|
|
static const uint8_t cbor_status_report[] = {
|
|
// [
|
|
// 1, // Record type code
|
|
// [
|
|
// [ // bundle status information
|
|
// [true, 10], // Reporting node received bundle
|
|
// [false], // Reporting node forwarded the bundle
|
|
// [false], // Reporting node delivered the bundle
|
|
// [false] // Reporting node deleted the bundle
|
|
// ],
|
|
// 0, // bundle status report reason code
|
|
// [1, 0], // Source node ID of reported bundle
|
|
// [2165, 12] // Creation time of the reported bundle
|
|
// ]
|
|
// ]
|
|
// ]
|
|
0x82, 0x01, 0x84, 0x84, 0x82, 0xf5, 0x0a, 0x81, 0xf4, 0x81,
|
|
0xf4, 0x81, 0xf4, 0x00, 0x82, 0x01, 0x00, 0x82, 0x19, 0x08, 0x75, 0x0c
|
|
};
|
|
|
|
TEST(bundle7Parser, status_report_parser)
|
|
{
|
|
struct bundle *bundle = bundle_init();
|
|
|
|
TEST_ASSERT_NOT_NULL(bundle);
|
|
|
|
// Primary Block
|
|
bundle->proc_flags = BUNDLE_FLAG_REPORT_STATUS_TIME
|
|
| BUNDLE_FLAG_ADMINISTRATIVE_RECORD;
|
|
bundle->creation_timestamp_ms = 4200;
|
|
bundle->sequence_number = 0;
|
|
bundle->lifetime_ms = 86400;
|
|
|
|
struct bundle_block *payload;
|
|
struct bundle_block_list *entry;
|
|
|
|
// Payload
|
|
payload = bundle_block_create(BUNDLE_BLOCK_TYPE_PAYLOAD);
|
|
entry = bundle_block_entry_create(payload);
|
|
|
|
payload->length = sizeof(cbor_status_report);
|
|
payload->data = malloc(payload->length);
|
|
memcpy(payload->data, cbor_status_report, sizeof(cbor_status_report));
|
|
|
|
bundle->blocks = entry;
|
|
bundle->payload_block = payload;
|
|
|
|
// Parser payload
|
|
struct bundle_administrative_record *record =
|
|
bundle7_parse_administrative_record(
|
|
bundle->payload_block->data,
|
|
bundle->payload_block->length
|
|
);
|
|
|
|
TEST_ASSERT_NOT_NULL(record);
|
|
TEST_ASSERT_NOT_NULL(record->status_report);
|
|
TEST_ASSERT_EQUAL(BUNDLE_AR_STATUS_REPORT, record->type);
|
|
TEST_ASSERT_EQUAL(0, record->flags);
|
|
|
|
TEST_ASSERT_EQUAL(2165, record->bundle_creation_timestamp_ms);
|
|
TEST_ASSERT_EQUAL(12, record->bundle_sequence_number);
|
|
|
|
TEST_ASSERT_EQUAL(10, record->status_report->bundle_received_time);
|
|
TEST_ASSERT_EQUAL(BUNDLE_SR_FLAG_BUNDLE_RECEIVED,
|
|
record->status_report->status);
|
|
TEST_ASSERT_EQUAL(BUNDLE_SR_REASON_NO_INFO,
|
|
record->status_report->reason);
|
|
|
|
free_administrative_record(record);
|
|
bundle_free(bundle);
|
|
}
|
|
|
|
|
|
// [30, 4]
|
|
static const uint8_t cbor_hop_count[] = { 0x82, 0x18, 0x1e, 0x04 };
|
|
|
|
TEST(bundle7Parser, hop_count)
|
|
{
|
|
struct bundle_hop_count hop_count;
|
|
|
|
// Try to parse empty buffer
|
|
TEST_ASSERT_FALSE(bundle7_hop_count_parse(&hop_count, NULL, 0));
|
|
|
|
// Try to parse wrong CBOR structure
|
|
TEST_ASSERT_FALSE(bundle7_hop_count_parse(&hop_count,
|
|
cbor_status_report, sizeof(cbor_status_report)));
|
|
|
|
// Parse valid CBOR structure
|
|
TEST_ASSERT_TRUE(bundle7_hop_count_parse(&hop_count,
|
|
cbor_hop_count, sizeof(cbor_hop_count)));
|
|
|
|
TEST_ASSERT_EQUAL(30, hop_count.limit);
|
|
TEST_ASSERT_EQUAL(4, hop_count.count);
|
|
}
|
|
|
|
|
|
// 42000
|
|
static const uint8_t cbor_bundle_age[] = { 0x19, 0xa4, 0x10 };
|
|
|
|
TEST(bundle7Parser, bundle_age)
|
|
{
|
|
uint64_t bundle_age;
|
|
|
|
// Try to parse empty buffer
|
|
TEST_ASSERT_FALSE(bundle_age_parse(&bundle_age, NULL, 0));
|
|
|
|
// Try to parse wrong CBOR structure
|
|
TEST_ASSERT_FALSE(bundle_age_parse(&bundle_age,
|
|
cbor_status_report, sizeof(cbor_status_report)));
|
|
|
|
// Parse valid CBOR structure
|
|
TEST_ASSERT_TRUE(bundle_age_parse(&bundle_age,
|
|
cbor_bundle_age, sizeof(cbor_bundle_age)));
|
|
|
|
TEST_ASSERT_EQUAL(42000, bundle_age);
|
|
}
|
|
|
|
|
|
TEST_GROUP_RUNNER(bundle7Parser)
|
|
{
|
|
RUN_TEST_CASE(bundle7Parser, eid_parser);
|
|
RUN_TEST_CASE(bundle7Parser, bundle_parser);
|
|
RUN_TEST_CASE(bundle7Parser, crc16_verification);
|
|
RUN_TEST_CASE(bundle7Parser, crc32_verification);
|
|
RUN_TEST_CASE(bundle7Parser, invalid_crc_handling);
|
|
RUN_TEST_CASE(bundle7Parser, status_report_parser);
|
|
RUN_TEST_CASE(bundle7Parser, hop_count);
|
|
RUN_TEST_CASE(bundle7Parser, bundle_age);
|
|
}
|