dali/bacnet_stack
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dbed4040ae83d427bbf2b06fae267683632ff83c
bacnet_stack/test/bacnet/datalink/bvlc/src/main.c
T
Greg Shue eb36033fd8 [OSCBS-41] Update to Zephyr v3.2.0 (#382) 
Updating to integrate with Zephyr v3.2.0 required:

- Update `west.yml` to import Zephyr v3.2.0 manifest
- Prefix include pathname of ztest.h with `zephyr/`
- Prefix every Zephyr header included pathname with `zephyr/`
- Change all Zephyr tests/samples to use `find_package`
- For unit_testing, use a distinct prj.conf which only references
  Kconfigs defined in the Zephyr repo. (Zephyr constraint.)
- Move ztest headers into a zephyr-prefixed pathname

Co-authored-by: Gregory Shue <gregory.shue@legrand.com>
2023-01-18 08:50:31 -08:00

876 lines
30 KiB
C
Raw Blame History

/*
* Copyright (c) 2020 Legrand North America, LLC.
*
* SPDX-License-Identifier: MIT
*/
/* @file
* @brief test BACnet integer encode/decode APIs
*/
#include <stdlib.h> /* For calloc() */
#include <zephyr/ztest.h>
#include <bacnet/bactext.h>
#include <bacnet/datalink/bvlc.h>
/**
* @addtogroup bacnet_tests
* @{
*/
/**
* @brief Test
*/
static void test_BVLC_Address(
BACNET_IP_ADDRESS *bip_address_1,
BACNET_IP_ADDRESS *bip_address_2)
{
zassert_false(bvlc_address_different(bip_address_1, bip_address_2), NULL);
}
static void test_BVLC_Broadcast_Distribution_Mask(
BACNET_IP_BROADCAST_DISTRIBUTION_MASK *bd_mask_1,
BACNET_IP_BROADCAST_DISTRIBUTION_MASK *bd_mask_2)
{
zassert_false(
bvlc_broadcast_distribution_mask_different(bd_mask_1, bd_mask_2), NULL);
}
static void test_BVLC_Broadcast_Distribution_Table_Entry(
BACNET_IP_BROADCAST_DISTRIBUTION_TABLE_ENTRY *bdt_entry_1,
BACNET_IP_BROADCAST_DISTRIBUTION_TABLE_ENTRY *bdt_entry_2)
{
if (bdt_entry_1 && bdt_entry_2) {
zassert_equal(bdt_entry_1->valid, bdt_entry_2->valid, NULL);
test_BVLC_Address(
&bdt_entry_1->dest_address, &bdt_entry_2->dest_address);
test_BVLC_Broadcast_Distribution_Mask(
&bdt_entry_1->broadcast_mask, &bdt_entry_2->broadcast_mask);
}
return;
}
static void test_BVLC_Foreign_Device_Table_Entry(
BACNET_IP_FOREIGN_DEVICE_TABLE_ENTRY *fdt_entry_1,
BACNET_IP_FOREIGN_DEVICE_TABLE_ENTRY *fdt_entry_2)
{
if (fdt_entry_1 && fdt_entry_2) {
zassert_equal(fdt_entry_1->valid, fdt_entry_2->valid, NULL);
test_BVLC_Address(
&fdt_entry_1->dest_address, &fdt_entry_2->dest_address);
zassert_equal(fdt_entry_1->ttl_seconds, fdt_entry_2->ttl_seconds, NULL);
zassert_equal(
fdt_entry_1->ttl_seconds_remaining,
fdt_entry_2->ttl_seconds_remaining, NULL);
}
return;
}
static int test_BVLC_Header(
uint8_t *pdu,
uint16_t pdu_len,
uint8_t *message_type,
uint16_t *message_length)
{
int bytes_consumed = 0;
int len = 0;
if (pdu && message_type && message_length) {
len = bvlc_decode_header(pdu, pdu_len, message_type, message_length);
zassert_equal(len, 4, NULL);
bytes_consumed = len;
}
return bytes_consumed;
}
static void test_BVLC_Result_Code(uint16_t result_code)
{
uint8_t pdu[50] = { 0 };
uint16_t test_result_code = 0;
uint8_t message_type = 0;
uint16_t length = 0;
int len = 0, test_len = 0;
len = bvlc_encode_result(pdu, sizeof(pdu), result_code);
zassert_equal(len, 6, NULL);
test_len = test_BVLC_Header(pdu, len, &message_type, &length);
zassert_equal(test_len, 4, NULL);
zassert_equal(message_type, BVLC_RESULT, NULL);
zassert_equal(length, 6, NULL);
test_len += bvlc_decode_result(&pdu[4], length - 4, &test_result_code);
zassert_equal(len, test_len, NULL);
zassert_equal(result_code, test_result_code, NULL);
}
static void test_BVLC_Result(void)
{
uint16_t result_code[] = { BVLC_RESULT_SUCCESSFUL_COMPLETION,
BVLC_RESULT_WRITE_BROADCAST_DISTRIBUTION_TABLE_NAK,
BVLC_RESULT_READ_BROADCAST_DISTRIBUTION_TABLE_NAK,
BVLC_RESULT_REGISTER_FOREIGN_DEVICE_NAK,
BVLC_RESULT_READ_FOREIGN_DEVICE_TABLE_NAK,
BVLC_RESULT_DELETE_FOREIGN_DEVICE_TABLE_ENTRY_NAK,
BVLC_RESULT_DISTRIBUTE_BROADCAST_TO_NETWORK_NAK };
unsigned int i = 0;
size_t result_code_max = sizeof(result_code) / sizeof(result_code[0]);
for (i = 0; i < result_code_max; i++) {
test_BVLC_Result_Code(result_code[i]);
}
}
static void test_BVLC_Original_Unicast_NPDU_Message(
uint8_t *npdu, uint16_t npdu_len)
{
uint8_t test_npdu[50] = { 0 };
uint8_t pdu[60] = { 0 };
uint16_t test_npdu_len = 0;
uint8_t message_type = 0;
uint16_t length = 0;
int len = 0, msg_len = 0, test_len = 0;
uint16_t i = 0;
len = bvlc_encode_original_unicast(pdu, sizeof(pdu), npdu, npdu_len);
msg_len = 4 + npdu_len;
zassert_equal(len, msg_len, NULL);
test_len = test_BVLC_Header(pdu, len, &message_type, &length);
zassert_equal(test_len, 4, NULL);
zassert_equal(message_type, BVLC_ORIGINAL_UNICAST_NPDU, NULL);
zassert_equal(length, msg_len, NULL);
test_len += bvlc_decode_original_unicast(
&pdu[4], length - 4, test_npdu, sizeof(test_npdu), &test_npdu_len);
zassert_equal(len, test_len, NULL);
zassert_equal(msg_len, test_len, NULL);
zassert_equal(npdu_len, test_npdu_len, NULL);
for (i = 0; i < npdu_len; i++) {
zassert_equal(npdu[i], test_npdu[i], NULL);
}
}
static void test_BVLC_Original_Unicast_NPDU(void)
{
uint8_t npdu[50] = { 0 };
uint16_t npdu_len = 0;
uint16_t i = 0;
test_BVLC_Original_Unicast_NPDU_Message(npdu, npdu_len);
/* now with some NPDU data */
for (i = 0; i < sizeof(npdu); i++) {
npdu[i] = i;
}
npdu_len = sizeof(npdu);
test_BVLC_Original_Unicast_NPDU_Message(npdu, npdu_len);
}
static void test_BVLC_Original_Broadcast_NPDU_Message(
uint8_t *npdu, uint16_t npdu_len)
{
uint8_t test_npdu[50] = { 0 };
uint8_t pdu[60] = { 0 };
uint16_t test_npdu_len = 0;
uint8_t message_type = 0;
uint16_t length = 0;
int len = 0, msg_len = 0, test_len = 0;
uint16_t i = 0;
len = bvlc_encode_original_broadcast(pdu, sizeof(pdu), npdu, npdu_len);
msg_len = 4 + npdu_len;
zassert_equal(len, msg_len, NULL);
test_len = test_BVLC_Header(pdu, len, &message_type, &length);
zassert_equal(test_len, 4, NULL);
zassert_equal(message_type, BVLC_ORIGINAL_BROADCAST_NPDU, NULL);
zassert_equal(length, msg_len, NULL);
test_len += bvlc_decode_original_broadcast(
&pdu[4], length - 4, test_npdu, sizeof(test_npdu), &test_npdu_len);
zassert_equal(len, test_len, NULL);
zassert_equal(msg_len, test_len, NULL);
zassert_equal(npdu_len, test_npdu_len, NULL);
for (i = 0; i < npdu_len; i++) {
zassert_equal(npdu[i], test_npdu[i], NULL);
}
}
static void test_BVLC_Original_Broadcast_NPDU(void)
{
uint8_t npdu[50] = { 0 };
uint16_t npdu_len = 0;
uint16_t i = 0;
test_BVLC_Original_Broadcast_NPDU_Message(npdu, npdu_len);
/* now with some NPDU data */
for (i = 0; i < sizeof(npdu); i++) {
npdu[i] = i;
}
npdu_len = sizeof(npdu);
test_BVLC_Original_Broadcast_NPDU_Message(npdu, npdu_len);
}
static void test_BVLC_Forwarded_NPDU_Message(
uint8_t *npdu,
uint16_t npdu_len,
BACNET_IP_ADDRESS *bip_address)
{
uint8_t test_npdu[50] = { 0 };
uint8_t pdu[75] = { 0 };
BACNET_IP_ADDRESS test_bip_address = { 0 };
uint16_t test_npdu_len = 0;
uint8_t message_type = 0;
uint16_t length = 0;
int len = 0, msg_len = 0, test_len = 0;
uint16_t i = 0;
len = bvlc_encode_forwarded_npdu(
pdu, sizeof(pdu), bip_address, npdu, npdu_len);
msg_len = 1 + 1 + 2 + BIP_ADDRESS_MAX + npdu_len;
zassert_equal(len, msg_len, NULL);
test_len = test_BVLC_Header(pdu, len, &message_type, &length);
zassert_equal(test_len, 4, NULL);
zassert_equal(message_type, BVLC_FORWARDED_NPDU, NULL);
zassert_equal(length, msg_len, NULL);
test_len += bvlc_decode_forwarded_npdu(&pdu[4], length - 4,
&test_bip_address, test_npdu, sizeof(test_npdu), &test_npdu_len);
zassert_equal(len, test_len, NULL);
zassert_equal(msg_len, test_len, NULL);
test_BVLC_Address(bip_address, &test_bip_address);
zassert_equal(npdu_len, test_npdu_len, NULL);
for (i = 0; i < npdu_len; i++) {
zassert_equal(npdu[i], test_npdu[i], NULL);
}
}
static void test_BVLC_Forwarded_NPDU(void)
{
uint8_t npdu[50] = { 0 };
BACNET_IP_ADDRESS bip_address = { 0 };
uint16_t npdu_len = 0;
uint16_t i = 0;
test_BVLC_Forwarded_NPDU_Message(npdu, npdu_len, &bip_address);
for (i = 0; i < sizeof(bip_address.address); i++) {
bip_address.address[i] = i;
}
bip_address.port = 47808;
/* now with some NPDU data */
for (i = 0; i < sizeof(npdu); i++) {
npdu[i] = i;
}
npdu_len = sizeof(npdu);
test_BVLC_Forwarded_NPDU_Message(npdu, npdu_len, &bip_address);
}
static void test_BVLC_Register_Foreign_Device_Message(
uint16_t ttl_seconds)
{
uint8_t pdu[60] = { 0 };
uint16_t test_ttl_seconds = 0;
uint8_t message_type = 0;
uint16_t length = 0;
int len = 0, test_len = 0;
const int msg_len = 6;
len = bvlc_encode_register_foreign_device(pdu, sizeof(pdu), ttl_seconds);
zassert_equal(len, msg_len, NULL);
test_len = test_BVLC_Header(pdu, len, &message_type, &length);
zassert_equal(test_len, 4, NULL);
zassert_equal(message_type, BVLC_REGISTER_FOREIGN_DEVICE, NULL);
zassert_equal(length, msg_len, NULL);
test_len += bvlc_decode_register_foreign_device(
&pdu[4], length - 4, &test_ttl_seconds);
zassert_equal(len, test_len, NULL);
zassert_equal(msg_len, test_len, NULL);
zassert_equal(ttl_seconds, test_ttl_seconds, NULL);
}
static void test_BVLC_Register_Foreign_Device(void)
{
uint16_t ttl_seconds = 0;
test_BVLC_Register_Foreign_Device_Message(ttl_seconds);
ttl_seconds = 600;
test_BVLC_Register_Foreign_Device_Message(ttl_seconds);
}
static void test_BVLC_Delete_Foreign_Device_Message(
BACNET_IP_FOREIGN_DEVICE_TABLE_ENTRY *fdt_entry)
{
uint8_t pdu[64] = { 0 };
BACNET_IP_FOREIGN_DEVICE_TABLE_ENTRY test_fdt_entry = { 0 };
uint8_t message_type = 0;
uint16_t length = 0;
int len = 0, test_len = 0;
const int msg_len = 0x000A;
len = bvlc_encode_delete_foreign_device(
pdu, sizeof(pdu), &fdt_entry->dest_address);
zassert_equal(len, msg_len, NULL);
test_len = test_BVLC_Header(pdu, len, &message_type, &length);
zassert_equal(test_len, 4, NULL);
zassert_equal(message_type, BVLC_DELETE_FOREIGN_DEVICE_TABLE_ENTRY, NULL);
zassert_equal(length, msg_len, NULL);
test_len += bvlc_decode_delete_foreign_device(
&pdu[4], length - 4, &test_fdt_entry.dest_address);
zassert_equal(len, test_len, NULL);
zassert_equal(msg_len, test_len, NULL);
if (msg_len != test_len) {
printf("msg:%u test:%u\n", msg_len, test_len);
}
test_BVLC_Address(
&fdt_entry->dest_address, &test_fdt_entry.dest_address);
}
static void test_BVLC_Delete_Foreign_Device(void)
{
BACNET_IP_FOREIGN_DEVICE_TABLE_ENTRY fdt_entry = { 0 };
unsigned int i = 0;
/* test with zeros */
test_BVLC_Delete_Foreign_Device_Message(&fdt_entry);
/* test with valid values */
for (i = 0; i < sizeof(fdt_entry.dest_address.address); i++) {
fdt_entry.dest_address.address[i] = i;
}
fdt_entry.dest_address.port = 47808;
fdt_entry.ttl_seconds = 600;
fdt_entry.ttl_seconds_remaining = 42;
fdt_entry.next = NULL;
test_BVLC_Delete_Foreign_Device_Message(&fdt_entry);
}
static void test_BVLC_Secure_BVLL_Message(
uint8_t *sbuf, uint16_t sbuf_len)
{
uint8_t test_sbuf[50] = { 0 };
uint8_t pdu[60] = { 0 };
uint16_t test_sbuf_len = 0;
uint8_t message_type = 0;
uint16_t length = 0;
int len = 0, msg_len = 0, test_len = 0;
uint16_t i = 0;
len = bvlc_encode_secure_bvll(pdu, sizeof(pdu), sbuf, sbuf_len);
msg_len = 1 + 1 + 2 + sbuf_len;
zassert_equal(len, msg_len, NULL);
test_len = test_BVLC_Header(pdu, len, &message_type, &length);
zassert_equal(test_len, 4, NULL);
zassert_equal(message_type, BVLC_SECURE_BVLL, NULL);
zassert_equal(length, msg_len, NULL);
test_len += bvlc_decode_secure_bvll(
&pdu[4], length - 4, test_sbuf, sizeof(test_sbuf), &test_sbuf_len);
zassert_equal(len, test_len, NULL);
zassert_equal(msg_len, test_len, NULL);
zassert_equal(sbuf_len, test_sbuf_len, NULL);
for (i = 0; i < sbuf_len; i++) {
zassert_equal(sbuf[i], test_sbuf[i], NULL);
}
}
static void test_BVLC_Secure_BVLL(void)
{
uint8_t sbuf[50] = { 0 };
uint16_t sbuf_len = 0;
uint16_t i = 0;
test_BVLC_Secure_BVLL_Message(sbuf, sbuf_len);
/* now with some NPDU data */
for (i = 0; i < sizeof(sbuf); i++) {
sbuf[i] = i;
}
sbuf_len = sizeof(sbuf);
test_BVLC_Secure_BVLL_Message(sbuf, sbuf_len);
}
static void test_BVLC_Read_Broadcast_Distribution_Table_Message(void)
{
uint8_t pdu[60] = { 0 };
uint8_t message_type = 0;
uint16_t length = 0;
int len = 0, msg_len = 0, test_len = 0;
len = bvlc_encode_read_broadcast_distribution_table(pdu, sizeof(pdu));
msg_len = 1 + 1 + 2;
zassert_equal(len, msg_len, NULL);
test_len = test_BVLC_Header(pdu, len, &message_type, &length);
zassert_equal(test_len, 4, NULL);
zassert_equal(message_type, BVLC_READ_BROADCAST_DIST_TABLE, NULL);
zassert_equal(length, msg_len, NULL);
}
static void test_BVLC_Distribute_Broadcast_To_Network_Message(
uint8_t *npdu, uint16_t npdu_len)
{
uint8_t test_npdu[50] = { 0 };
uint8_t pdu[60] = { 0 };
uint16_t test_npdu_len = 0;
uint8_t message_type = 0;
uint16_t length = 0;
int len = 0, msg_len = 0, test_len = 0;
uint16_t i = 0;
len = bvlc_encode_distribute_broadcast_to_network(
pdu, sizeof(pdu), npdu, npdu_len);
msg_len = 4 + npdu_len;
zassert_equal(len, msg_len, NULL);
test_len = test_BVLC_Header(pdu, len, &message_type, &length);
zassert_equal(test_len, 4, NULL);
zassert_equal(message_type, BVLC_DISTRIBUTE_BROADCAST_TO_NETWORK, NULL);
zassert_equal(length, msg_len, NULL);
test_len += bvlc_decode_distribute_broadcast_to_network(
&pdu[4], length - 4, test_npdu, sizeof(test_npdu), &test_npdu_len);
zassert_equal(len, test_len, NULL);
zassert_equal(msg_len, test_len, NULL);
zassert_equal(npdu_len, test_npdu_len, NULL);
for (i = 0; i < npdu_len; i++) {
zassert_equal(npdu[i], test_npdu[i], NULL);
}
}
static void test_BVLC_Distribute_Broadcast_To_Network(void)
{
uint8_t npdu[50] = { 0 };
uint16_t npdu_len = 0;
uint16_t i = 0;
test_BVLC_Distribute_Broadcast_To_Network_Message(npdu, npdu_len);
/* now with some NPDU data */
for (i = 0; i < sizeof(npdu); i++) {
npdu[i] = i;
}
npdu_len = sizeof(npdu);
test_BVLC_Distribute_Broadcast_To_Network_Message(npdu, npdu_len);
}
static void test_BVLC_Broadcast_Distribution_Table_Encode(void)
{
uint8_t apdu[480] = { 0 };
uint16_t apdu_len = 0;
uint16_t test_apdu_len = 0;
uint16_t i = 0;
uint16_t count = 0;
uint16_t test_count = 0;
bool status = false;
BACNET_ERROR_CODE error_code;
BACNET_IP_BROADCAST_DISTRIBUTION_TABLE_ENTRY bdt_list[5] = { 0 };
BACNET_IP_BROADCAST_DISTRIBUTION_TABLE_ENTRY bdt_entry = { 0 };
BACNET_IP_ADDRESS dest_address = { 0 };
BACNET_IP_BROADCAST_DISTRIBUTION_MASK broadcast_mask = { 0 };
BACNET_IP_BROADCAST_DISTRIBUTION_TABLE_ENTRY test_bdt_list[5] = { 0 };
/* configure a BDT entry */
count = sizeof(bdt_list) / sizeof(bdt_list[0]);
bvlc_broadcast_distribution_table_link_array(&bdt_list[0], count);
for (i = 0; i < count; i++) {
status = bvlc_address_port_from_ascii(
&dest_address, "192.168.0.255", "0xBAC0");
zassert_true(status, NULL);
dest_address.port += i;
broadcast_mask.address[0] = 255;
broadcast_mask.address[1] = 255;
broadcast_mask.address[2] = 255;
broadcast_mask.address[3] = 255;
status = bvlc_broadcast_distribution_table_entry_set(
&bdt_entry, &dest_address, &broadcast_mask);
zassert_true(status, NULL);
status = bvlc_broadcast_distribution_table_entry_append(
&bdt_list[0], &bdt_entry);
zassert_true(status, NULL);
}
test_count = bvlc_broadcast_distribution_table_count(&bdt_list[0]);
if (test_count != count) {
printf("size=%u count=%u\n", count, test_count);
}
zassert_equal(test_count, count, NULL);
/* test the encode/decode pair */
apdu_len = bvlc_broadcast_distribution_table_encode(&apdu[0],
sizeof(apdu), &bdt_list[0]);
test_count = sizeof(test_bdt_list) / sizeof(test_bdt_list[0]);
bvlc_broadcast_distribution_table_link_array(&test_bdt_list[0], test_count);
test_apdu_len = bvlc_broadcast_distribution_table_decode(&apdu[0],
apdu_len, &error_code, &test_bdt_list[0]);
zassert_equal(test_apdu_len, apdu_len, NULL);
count = bvlc_broadcast_distribution_table_count(&test_bdt_list[0]);
zassert_equal(test_count, count, NULL);
for (i = 0; i < count; i++) {
status = bvlc_broadcast_distribution_table_entry_different(
&bdt_list[i], &test_bdt_list[i]);
zassert_false(status, NULL);
}
}
static void test_BVLC_Write_Broadcast_Distribution_Table_Message(
uint8_t *npdu,
uint16_t npdu_len,
BACNET_IP_BROADCAST_DISTRIBUTION_TABLE_ENTRY *bdt_list)
{
uint8_t pdu[480] = { 0 };
uint8_t message_type = 0;
uint16_t length = 0;
int len = 0, msg_len = 0, test_len = 0;
BACNET_IP_BROADCAST_DISTRIBUTION_TABLE_ENTRY *test_bdt_list = NULL;
uint16_t i = 0;
uint16_t count = 0;
count = bvlc_broadcast_distribution_table_valid_count(bdt_list);
test_bdt_list =
calloc(count, sizeof(BACNET_IP_BROADCAST_DISTRIBUTION_TABLE_ENTRY));
bvlc_broadcast_distribution_table_link_array(test_bdt_list, count);
/* encode the message */
len = bvlc_encode_write_broadcast_distribution_table(
pdu, sizeof(pdu), bdt_list);
msg_len = 4 + (count * BACNET_IP_BDT_ENTRY_SIZE);
zassert_equal(len, msg_len, NULL);
test_len = test_BVLC_Header(pdu, len, &message_type, &length);
zassert_equal(test_len, 4, NULL);
zassert_equal(message_type, BVLC_WRITE_BROADCAST_DISTRIBUTION_TABLE, NULL);
zassert_equal(length, msg_len, NULL);
test_len += bvlc_decode_write_broadcast_distribution_table(
&pdu[4], length - 4, test_bdt_list);
zassert_equal(msg_len, test_len, NULL);
for (i = 0; i < count; i++) {
test_BVLC_Broadcast_Distribution_Table_Entry(
&bdt_list[i], &test_bdt_list[i]);
}
}
static void test_BVLC_Write_Broadcast_Distribution_Table(void)
{
uint8_t npdu[480] = { 0 };
uint16_t npdu_len = 0;
uint16_t i = 0;
uint16_t count = 0;
uint16_t test_count = 0;
bool status = false;
BACNET_IP_BROADCAST_DISTRIBUTION_TABLE_ENTRY bdt_list[5] = { 0 };
BACNET_IP_BROADCAST_DISTRIBUTION_TABLE_ENTRY bdt_entry = { 0 };
BACNET_IP_ADDRESS dest_address = { 0 };
BACNET_IP_BROADCAST_DISTRIBUTION_MASK broadcast_mask = { 0 };
/* configure a BDT entry */
count = sizeof(bdt_list) / sizeof(bdt_list[0]);
bvlc_broadcast_distribution_table_link_array(&bdt_list[0], count);
for (i = 0; i < count; i++) {
status = bvlc_address_port_from_ascii(
&dest_address, "192.168.0.255", "0xBAC0");
zassert_true(status, NULL);
dest_address.port += i;
broadcast_mask.address[0] = 255;
broadcast_mask.address[1] = 255;
broadcast_mask.address[2] = 255;
broadcast_mask.address[3] = 255;
status = bvlc_broadcast_distribution_table_entry_set(
&bdt_entry, &dest_address, &broadcast_mask);
zassert_true(status, NULL);
status = bvlc_broadcast_distribution_table_entry_append(
&bdt_list[0], &bdt_entry);
zassert_true(status, NULL);
}
test_count = bvlc_broadcast_distribution_table_count(&bdt_list[0]);
if (test_count != count) {
printf("size=%u count=%u\n", count, test_count);
}
zassert_equal(test_count, count, NULL);
test_count = bvlc_broadcast_distribution_table_valid_count(&bdt_list[0]);
zassert_equal(test_count, count, NULL);
for (i = 1; i < 5; i++) {
status = bvlc_broadcast_distribution_table_entry_different(
&bdt_list[0], &bdt_list[i]);
zassert_true(status, NULL);
}
test_BVLC_Write_Broadcast_Distribution_Table_Message(
npdu, npdu_len, &bdt_list[0]);
/* now with some NPDU data */
for (i = 0; i < sizeof(npdu); i++) {
npdu[i] = i;
}
npdu_len = sizeof(npdu);
test_BVLC_Write_Broadcast_Distribution_Table_Message(
npdu, npdu_len, &bdt_list[0]);
}
static void test_BVLC_Read_Foreign_Device_Table_Ack_Message(
uint8_t *npdu,
uint16_t npdu_len,
BACNET_IP_FOREIGN_DEVICE_TABLE_ENTRY *fdt_list)
{
uint8_t pdu[480] = { 0 };
uint8_t message_type = 0;
uint16_t length = 0;
int len = 0, msg_len = 0, test_len = 0;
BACNET_IP_FOREIGN_DEVICE_TABLE_ENTRY *test_fdt_list = NULL;
uint16_t i = 0;
uint16_t count = 0;
count = bvlc_foreign_device_table_valid_count(fdt_list);
test_fdt_list = calloc(count, sizeof(BACNET_IP_FOREIGN_DEVICE_TABLE_ENTRY));
bvlc_foreign_device_table_link_array(test_fdt_list, count);
/* encode the message */
len = bvlc_encode_read_foreign_device_table_ack(pdu, sizeof(pdu), fdt_list);
msg_len = 4 + (count * BACNET_IP_FDT_ENTRY_SIZE);
zassert_equal(len, msg_len, NULL);
test_len = test_BVLC_Header(pdu, len, &message_type, &length);
zassert_equal(test_len, 4, NULL);
zassert_equal(message_type, BVLC_READ_FOREIGN_DEVICE_TABLE_ACK, NULL);
zassert_equal(length, msg_len, NULL);
test_len += bvlc_decode_read_foreign_device_table_ack(
&pdu[4], length - 4, test_fdt_list);
zassert_equal(msg_len, test_len, NULL);
for (i = 0; i < count; i++) {
test_BVLC_Foreign_Device_Table_Entry(
&fdt_list[i], &test_fdt_list[i]);
}
}
static void test_BVLC_Read_Foreign_Device_Table_Ack(void)
{
uint8_t npdu[480] = { 0 };
uint16_t npdu_len = 0;
uint16_t i = 0;
uint16_t count = 0;
uint16_t test_count = 0;
uint16_t test_port_start = 0xBAC1;
bool status = false;
BACNET_IP_FOREIGN_DEVICE_TABLE_ENTRY fdt_list[5] = { 0 };
BACNET_IP_ADDRESS dest_address = { 0 };
status = bvlc_address_from_ascii(&dest_address, "192.168.0.1");
zassert_true(status, NULL);
/* configure a FDT entry */
count = sizeof(fdt_list) / sizeof(fdt_list[0]);
bvlc_foreign_device_table_link_array(fdt_list, count);
for (i = 0; i < count; i++) {
dest_address.port = test_port_start + i;
status = bvlc_foreign_device_table_entry_add(
&fdt_list[0], &dest_address, 12345);
zassert_true(status, NULL);
/* add again should only update TTL */
status = bvlc_foreign_device_table_entry_add(
&fdt_list[0], &dest_address, 12345);
zassert_true(status, NULL);
}
test_count = bvlc_foreign_device_table_count(fdt_list);
zassert_equal(test_count, count, NULL);
if (test_count != count) {
printf("size=%u count=%u\n", count, test_count);
}
test_count = bvlc_foreign_device_table_valid_count(fdt_list);
zassert_equal(test_count, count, NULL);
test_BVLC_Read_Foreign_Device_Table_Ack_Message(
npdu, npdu_len, fdt_list);
/* now with some NPDU data */
for (i = 0; i < sizeof(npdu); i++) {
npdu[i] = i;
}
npdu_len = sizeof(npdu);
test_BVLC_Read_Foreign_Device_Table_Ack_Message(
npdu, npdu_len, fdt_list);
/* cleanup */
for (i = 0; i < count; i++) {
dest_address.port = test_port_start + i;
status =
bvlc_foreign_device_table_entry_delete(&fdt_list[0], &dest_address);
zassert_true(status, NULL);
}
test_count = bvlc_foreign_device_table_valid_count(fdt_list);
zassert_equal(test_count, 0, NULL);
}
static void test_BVLC_Address_Copy(void)
{
unsigned int i = 0;
BACNET_IP_ADDRESS src = { 0 };
BACNET_IP_ADDRESS dst = { 0 };
bool status = false;
/* test with zeros */
status = bvlc_address_copy(&dst, &src);
zassert_true(status, NULL);
status = bvlc_address_different(&dst, &src);
zassert_false(status, NULL);
/* test with valid values */
for (i = 0; i < sizeof(src.address); i++) {
src.address[i] = 1 + i;
}
src.port = 47808;
status = bvlc_address_copy(&dst, &src);
zassert_true(status, NULL);
status = bvlc_address_different(&dst, &src);
zassert_false(status, NULL);
/* test for different port */
dst.port = 47809;
status = bvlc_address_different(&dst, &src);
zassert_true(status, NULL);
/* test for different address */
dst.port = src.port;
for (i = 0; i < sizeof(src.address); i++) {
dst.address[i] = 0;
status = bvlc_address_different(&dst, &src);
zassert_true(status, NULL);
dst.address[i] = 1 + i;
}
}
static void test_BVLC_Address_Get_Set(void)
{
uint16_t i = 0;
BACNET_ADDRESS bsrc = { 0 };
BACNET_IP_ADDRESS src = { 0 };
BACNET_IP_ADDRESS dst = { 0 };
BACNET_IP_BROADCAST_DISTRIBUTION_MASK mask = { 0 };
BACNET_IP_BROADCAST_DISTRIBUTION_MASK test_mask = { 0 };
const uint32_t broadcast_mask = 0x12345678;
uint32_t test_broadcast_mask = 0;
uint8_t octet0 = 192;
uint8_t octet1 = 168;
uint8_t octet2 = 1;
uint8_t octet3 = 255;
uint8_t test_octet0 = 0;
uint8_t test_octet1 = 0;
uint8_t test_octet2 = 0;
uint8_t test_octet3 = 0;
const uint16_t dnet = 12345;
uint16_t snet = 0;
bool status = false;
for (i = 0; i < 255; i++) {
octet0 = i;
octet1 = i;
octet2 = i;
octet3 = i;
status = bvlc_address_set(&src, octet0, octet1, octet2, octet3);
zassert_true(status, NULL);
status = bvlc_address_get(
&src, &test_octet0, &test_octet1, &test_octet2, &test_octet3);
zassert_true(status, NULL);
zassert_equal(octet0, test_octet0, NULL);
zassert_equal(octet1, test_octet1, NULL);
zassert_equal(octet2, test_octet2, NULL);
zassert_equal(octet3, test_octet3, NULL);
}
/* test the ASCII hex to address */
/* test invalid */
status = bvlc_address_from_ascii(&src, "256");
zassert_false(status, NULL);
status = bvlc_address_from_ascii(&src, "192.168.0.1");
zassert_true(status, NULL);
status = bvlc_address_set(&dst, 192, 168, 0, 1);
zassert_true(status, NULL);
status = bvlc_address_different(&dst, &src);
zassert_false(status, NULL);
/* test zero compression */
status = bvlc_address_from_ascii(&src, "127...");
zassert_true(status, NULL);
status = bvlc_address_set(&dst, 127, 0, 0, 0);
zassert_true(status, NULL);
status = bvlc_address_different(&dst, &src);
if (status) {
status = bvlc_address_get(
&src, &test_octet0, &test_octet1, &test_octet2, &test_octet3);
printf("src:%u.%u.%u.%u\n", (unsigned)test_octet0,
(unsigned)test_octet1, (unsigned)test_octet2,
(unsigned)test_octet3);
status = bvlc_address_get(
&dst, &test_octet0, &test_octet1, &test_octet2, &test_octet3);
printf("dst:%u.%u.%u.%u\n", (unsigned)test_octet0,
(unsigned)test_octet1, (unsigned)test_octet2,
(unsigned)test_octet3);
}
zassert_false(status, NULL);
/* BACnet to IPv4 address conversions */
status = bvlc_address_port_from_ascii(&src, "192.168.0.1", "0xBAC0");
zassert_true(status, NULL);
status = bvlc_ip_address_to_bacnet_local(&bsrc, &src);
zassert_true(status, NULL);
status = bvlc_ip_address_from_bacnet_local(&dst, &bsrc);
zassert_true(status, NULL);
status = bvlc_address_different(&dst, &src);
zassert_false(status, NULL);
status = bvlc_ip_address_to_bacnet_remote(&bsrc, dnet, &src);
zassert_true(status, NULL);
status = bvlc_ip_address_from_bacnet_remote(&dst, &snet, &bsrc);
zassert_true(status, NULL);
zassert_equal(snet, dnet, NULL);
status = bvlc_ip_address_from_bacnet_remote(&dst, NULL, &bsrc);
zassert_true(status, NULL);
/* Broadcast Distribution Mask conversions */
status = bvlc_broadcast_distribution_mask_from_host(&mask, broadcast_mask);
zassert_true(status, NULL);
status =
bvlc_broadcast_distribution_mask_to_host(&test_broadcast_mask, &mask);
zassert_true(status, NULL);
zassert_equal(test_broadcast_mask, broadcast_mask, NULL);
octet0 = 0x12;
octet1 = 0x34;
octet2 = 0x56;
octet3 = 0x78;
bvlc_broadcast_distribution_mask_set(
&test_mask, octet0, octet1, octet2, octet3);
status = bvlc_broadcast_distribution_mask_different(&mask, &test_mask);
zassert_false(status, NULL);
bvlc_broadcast_distribution_mask_get(
&test_mask, &test_octet0, &test_octet1, &test_octet2, &test_octet3);
zassert_equal(octet0, test_octet0, NULL);
zassert_equal(octet1, test_octet1, NULL);
zassert_equal(octet2, test_octet2, NULL);
zassert_equal(octet3, test_octet3, NULL);
}
static void test_BVLC_BBMD_Address(void)
{
uint8_t apdu[480] = { 0 };
int apdu_len = 0;
int test_apdu_len = 0;
BACNET_IP_ADDRESS bbmd_address;
BACNET_IP_ADDRESS test_bbmd_address;
BACNET_ERROR_CODE error_code = ERROR_CODE_SUCCESS;
bool status = false;
status = bvlc_address_port_from_ascii(
&bbmd_address, "192.168.0.255", "0xBAC0");
zassert_true(status, NULL);
apdu_len = bvlc_foreign_device_bbmd_host_address_encode(apdu, sizeof(apdu),
&bbmd_address);
zassert_not_equal(apdu_len, 0, NULL);
test_apdu_len = bvlc_foreign_device_bbmd_host_address_decode(apdu,
apdu_len, &error_code, &test_bbmd_address);
if (test_apdu_len < 0) {
printf("BVLC: error-code=%s\n", bactext_error_code_name(error_code));
}
zassert_not_equal(test_apdu_len, 0, NULL);
zassert_not_equal(test_apdu_len, BACNET_STATUS_ERROR, NULL);
zassert_not_equal(test_apdu_len, BACNET_STATUS_ABORT, NULL);
zassert_not_equal(test_apdu_len, BACNET_STATUS_REJECT, NULL);
status = bvlc_address_different(&bbmd_address, &test_bbmd_address);
zassert_false(status, NULL);
}
/**
* @}
*/
void test_main(void)
{
ztest_test_suite(bvlc_tests,
ztest_unit_test(test_BVLC_Result),
ztest_unit_test(test_BVLC_Write_Broadcast_Distribution_Table),
ztest_unit_test(test_BVLC_Read_Broadcast_Distribution_Table_Message),
ztest_unit_test(test_BVLC_Forwarded_NPDU),
ztest_unit_test(test_BVLC_Register_Foreign_Device),
ztest_unit_test(test_BVLC_Read_Foreign_Device_Table_Ack),
ztest_unit_test(test_BVLC_Delete_Foreign_Device),
ztest_unit_test(test_BVLC_Distribute_Broadcast_To_Network),
ztest_unit_test(test_BVLC_Broadcast_Distribution_Table_Encode),
ztest_unit_test(test_BVLC_Original_Unicast_NPDU),
ztest_unit_test(test_BVLC_Original_Broadcast_NPDU),
ztest_unit_test(test_BVLC_Secure_BVLL),
ztest_unit_test(test_BVLC_Address_Copy),
ztest_unit_test(test_BVLC_Address_Get_Set),
ztest_unit_test(test_BVLC_BBMD_Address)
);
ztest_run_test_suite(bvlc_tests);
}
Reference in New Issue View Git Blame Copy Permalink