dali/bacnet_stack
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added BACnetRecipient and BACnetAddressBinding codecs for EPICS application (#1163)

Browse Source 
* Added BACnetRecipient and BACnetAddressBinding encoding, decoding, ASCII conversion, comparison, and copy functions.

*  Added library specific string manipulation utilities including strcmp, strncmp, stptok, and snprintf with offset functions.

* Added test/README about verification and validation testing.
This commit is contained in:
Steve Karg
2025-11-27 23:12:39 -06:00
committed by GitHub
parent 21626d1ac5
commit ca9836b099
28 changed files with 1875 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/bacnet/bacaddr/CMakeLists.txt
+3 -1
View File
@@ -37,9 +37,11 @@ add_executable(${PROJECT_NAME}
# Support files and stubs (pathname alphabetical)
${SRC_DIR}/bacnet/bacaction.c
${SRC_DIR}/bacnet/bacdcode.c
${SRC_DIR}/bacnet/bacint.c
${SRC_DIR}/bacnet/bacreal.c
${SRC_DIR}/bacnet/bacstr.c
${SRC_DIR}/bacnet/bacint.c
${SRC_DIR}/bacnet/bactext.c
${SRC_DIR}/bacnet/indtext.c
# Test and test library files
./src/main.c
${ZTST_DIR}/ztest_mock.c
test/bacnet/bacaddr/src/main.c
+211 -2
View File
@@ -31,6 +31,10 @@ static void test_BACNET_ADDRESS(void)
zassert_false(status, NULL);
status = bacnet_address_same(NULL, NULL);
zassert_false(status, NULL);
bacnet_address_copy(&dest, NULL);
bacnet_address_copy(&src, NULL);
status = bacnet_address_same(&dest, &src);
zassert_true(status, NULL);
/* happy day cases */
status = bacnet_address_same(&dest, &dest);
@@ -44,6 +48,42 @@ static void test_BACNET_ADDRESS(void)
zassert_true(status, NULL);
status = bacnet_address_same(&dest, &src);
zassert_true(status, NULL);
mac.len = 1;
mac.adr[0] = 3;
adr.len = 1;
adr.adr[0] = 4;
dnet = 1234;
status = bacnet_address_init(&src, &mac, dnet, &adr);
zassert_true(status, NULL);
bacnet_address_copy(&dest, &src);
zassert_true(status, NULL);
status = bacnet_address_net_same(&dest, &src);
zassert_true(status, NULL);
dnet = 0;
status = bacnet_address_init(&src, &mac, dnet, &adr);
zassert_true(status, NULL);
bacnet_address_copy(&dest, &src);
zassert_true(status, NULL);
status = bacnet_address_net_same(&dest, &src);
zassert_true(status, NULL);
/* net + adr */
dnet = 1;
status = bacnet_address_init(&src, NULL, dnet, &adr);
status = bacnet_address_net_same(&dest, &src);
zassert_false(status, NULL);
/* net=0, mac */
dnet = 1;
status = bacnet_address_init(&dest, NULL, dnet, &adr);
zassert_true(status, NULL);
dnet = 0;
status = bacnet_address_init(&src, &mac, dnet, NULL);
zassert_true(status, NULL);
status = bacnet_address_net_same(&dest, &src);
zassert_false(status, NULL);
status = bacnet_address_net_same(NULL, &src);
zassert_false(status, NULL);
status = bacnet_address_net_same(&dest, NULL);
zassert_false(status, NULL);
/* remote dnet is non-zero */
dnet = 1;
status = bacnet_address_init(&dest, &mac, dnet, &adr);
@@ -105,6 +145,11 @@ static void test_BACNET_ADDRESS(void)
zassert_true(status, NULL);
status = bacnet_address_same(&dest, &src);
zassert_true(status, NULL);
/* initialize using copy */
bacnet_address_copy(&dest, NULL);
zassert_equal(dest.mac_len, 0, NULL);
zassert_equal(dest.len, 0, NULL);
zassert_equal(dest.net, 0, NULL);
}
#if defined(CONFIG_ZTEST_NEW_API)
@@ -215,8 +260,36 @@ static void test_BACnetAddress_Codec(void)
zassert_equal(value.net, test_value.net, NULL);
zassert_equal(value.mac_len, test_value.mac_len, NULL);
zassert_equal(value.mac_len, 6, NULL);
/* test deprecated function */
test_len = decode_bacnet_address(apdu, &test_value);
zassert_equal(len, test_len, NULL);
zassert_equal(value.net, test_value.net, NULL);
zassert_equal(value.mac_len, test_value.mac_len, NULL);
zassert_equal(value.mac_len, 6, NULL);
/* negative tests - NULL value */
test_len = bacnet_address_decode(apdu, sizeof(apdu), NULL);
zassert_equal(len, test_len, NULL);
/* network address */
value.net = 1;
value.len = 3;
value.adr[0] = 1;
value.adr[1] = 2;
value.adr[2] = 3;
len = encode_bacnet_address(NULL, &value);
test_len = encode_bacnet_address(apdu, &value);
zassert_true(len > 0, NULL);
zassert_true(test_len > 0, NULL);
zassert_equal(len, test_len, "len=%d test_len=%d", len, test_len);
test_len = bacnet_address_decode(apdu, sizeof(apdu), &test_value);
zassert_equal(len, test_len, NULL);
zassert_equal(value.net, test_value.net, NULL);
zassert_equal(value.mac_len, test_value.mac_len, NULL);
zassert_equal(value.len, test_value.len, NULL);
zassert_equal(value.len, 3, NULL);
zassert_equal(value.adr[0], test_value.adr[0], NULL);
zassert_equal(value.adr[1], test_value.adr[1], NULL);
zassert_equal(value.adr[2], test_value.adr[2], NULL);
/* context tagged */
tag_number = 1;
len = encode_context_bacnet_address(NULL, tag_number, &value);
test_len = encode_context_bacnet_address(apdu, tag_number, &value);
@@ -229,6 +302,12 @@ static void test_BACnetAddress_Codec(void)
zassert_equal(value.net, test_value.net, NULL);
zassert_equal(value.mac_len, test_value.mac_len, NULL);
zassert_equal(value.mac_len, 6, NULL);
/* validate deprecated function */
test_len = decode_context_bacnet_address(apdu, tag_number, &test_value);
zassert_equal(len, test_len, NULL);
zassert_equal(value.net, test_value.net, NULL);
zassert_equal(value.mac_len, test_value.mac_len, NULL);
zassert_equal(value.mac_len, 6, NULL);
test_len = bacnet_address_context_decode(
apdu, sizeof(apdu), tag_number, &test_value);
/* negative tests - NULL value */
@@ -256,9 +335,18 @@ static void test_bacnet_vmac_entry_codec(void)
{
uint8_t apdu[MAX_APDU];
BACNET_VMAC_ENTRY value = { 0 }, test_value = { 0 };
BACNET_ADDRESS test_addr = { 0 };
int test_len = 0, apdu_len = 0, null_len = 0;
bool status = false;
unsigned i;
status = bacnet_vmac_address_set(NULL, 0);
zassert_false(status, NULL);
status = bacnet_vmac_address_set(&test_addr, 12345);
zassert_true(status, NULL);
zassert_equal(test_addr.mac_len, 3, NULL);
zassert_equal(test_addr.net, 0, NULL);
/* VMAC */
value.virtual_mac_address.adr[0] = 1;
value.virtual_mac_address.adr[1] = 2;
value.virtual_mac_address.adr[2] = 3;
@@ -268,6 +356,8 @@ static void test_bacnet_vmac_entry_codec(void)
value.native_mac_address[2] = 6;
value.native_mac_address[3] = 7;
value.native_mac_address_len = 4;
null_len = bacnet_vmac_entry_encode(NULL, sizeof(apdu), NULL);
zassert_equal(null_len, 0, NULL);
null_len = bacnet_vmac_entry_encode(NULL, sizeof(apdu), &value);
apdu_len = bacnet_vmac_entry_encode(apdu, sizeof(apdu), &value);
zassert_true(apdu_len > 0, NULL);
@@ -302,6 +392,124 @@ static void test_bacnet_vmac_entry_codec(void)
}
}
#if defined(CONFIG_ZTEST_NEW_API)
ZTEST(bacnet_address_tests, test_bacnet_address_ascii)
#else
static void test_bacnet_address_ascii(void)
#endif
{
char ascii_mac_net_adr[80] = "{ff:00:ff:01:ff:02,1,7f}";
char ascii_mac_net[80] = "{192.168.1.1:47808,0}";
BACNET_ADDRESS value = { 0 };
bool status;
status = bacnet_address_from_ascii(NULL, NULL);
zassert_false(status, NULL);
status = bacnet_address_from_ascii(&value, NULL);
zassert_false(status, NULL);
status = bacnet_address_from_ascii(NULL, ascii_mac_net_adr);
zassert_false(status, NULL);
status = bacnet_address_from_ascii(&value, ascii_mac_net_adr);
zassert_true(status, NULL);
zassert_equal(value.mac_len, 6, NULL);
zassert_equal(value.mac[0], 0xff, NULL);
zassert_equal(value.mac[1], 0x00, NULL);
zassert_equal(value.mac[2], 0xff, NULL);
zassert_equal(value.mac[3], 0x01, NULL);
zassert_equal(value.mac[4], 0xff, NULL);
zassert_equal(value.mac[5], 0x02, NULL);
zassert_equal(value.net, 1, NULL);
zassert_equal(value.len, 1, NULL);
zassert_equal(value.adr[0], 0x7f, NULL);
status = bacnet_address_from_ascii(&value, ascii_mac_net);
zassert_true(status, NULL);
zassert_equal(value.mac_len, 6, NULL);
zassert_equal(value.mac[0], 192, NULL);
zassert_equal(value.mac[1], 168, NULL);
zassert_equal(value.mac[2], 1, NULL);
zassert_equal(value.mac[3], 1, NULL);
zassert_equal(value.net, 0, NULL);
zassert_equal(value.len, 0, NULL);
}
#if defined(CONFIG_ZTEST_NEW_API)
ZTEST(bacnet_address_tests, test_BACNET_ADDRESS_BINDING)
#else
static void test_BACNET_ADDRESS_BINDING(void)
#endif
{
uint8_t apdu[MAX_APDU] = { 0 };
BACNET_ADDRESS addr = {
.mac_len = 1, .mac[0] = 0x01, .net = 0, .adr[0] = 0, .len = 0
};
BACNET_ADDRESS_BINDING binding = { 0 }, test_binding = { 0 };
bool status = false;
int len, test_len, apdu_len, null_len;
char str[80] = "";
null_len = bacnet_address_binding_type_encode(NULL, NULL);
zassert_equal(null_len, 0, NULL);
status = bacnet_address_binding_init(&binding, 12345, &addr);
len = bacnet_address_binding_type_encode(NULL, &binding);
null_len = bacnet_address_binding_type_encode(NULL, &binding);
zassert_not_equal(null_len, 0, NULL);
apdu_len = bacnet_address_binding_type_encode(apdu, &binding);
zassert_not_equal(null_len, 0, NULL);
zassert_equal(null_len, apdu_len, NULL);
test_len = bacnet_address_binding_decode(apdu, apdu_len, &test_binding);
zassert_equal(apdu_len, test_len, NULL);
status = bacnet_address_same(
&binding.device_address, &test_binding.device_address);
zassert_true(status, NULL);
status = bacnet_address_binding_same(&binding, &test_binding);
zassert_true(status, NULL);
null_len = bacnet_address_binding_encode(NULL, 0, &binding);
zassert_equal(null_len, 0, NULL);
null_len = bacnet_address_binding_encode(NULL, 0, NULL);
zassert_equal(null_len, 0, NULL);
null_len = bacnet_address_binding_encode(NULL, sizeof(apdu), &binding);
zassert_not_equal(null_len, 0, NULL);
apdu_len = bacnet_address_binding_encode(apdu, sizeof(apdu), &binding);
zassert_equal(null_len, apdu_len, NULL);
/* shrink the apdu size for decoding test */
while (apdu_len) {
apdu_len--;
test_len = bacnet_address_binding_decode(apdu, apdu_len, &test_binding);
zassert_equal(test_len, BACNET_STATUS_ERROR, NULL);
}
/* negative tests - NULL value */
apdu_len = bacnet_address_binding_encode(apdu, sizeof(apdu), &binding);
zassert_equal(null_len, apdu_len, NULL);
test_len = bacnet_address_binding_decode(apdu, sizeof(apdu), NULL);
zassert_equal(apdu_len, test_len, NULL);
test_len = bacnet_address_binding_decode(NULL, 0, NULL);
zassert_equal(test_len, BACNET_STATUS_ERROR, NULL);
status = bacnet_address_binding_copy(&test_binding, &binding);
zassert_true(status, NULL);
status = bacnet_address_binding_same(&test_binding, &binding);
zassert_true(status, NULL);
/* ASCII */
len = bacnet_address_binding_to_ascii(&binding, str, sizeof(str));
zassert_true(len > 0, NULL);
status = bacnet_address_binding_from_ascii(&test_binding, str);
zassert_true(status, NULL);
status = bacnet_address_binding_same(&test_binding, &binding);
zassert_true(status, NULL);
/* negative tests - NULL value */
status = bacnet_address_binding_same(NULL, &binding);
zassert_false(status, NULL);
status = bacnet_address_binding_same(&test_binding, NULL);
zassert_false(status, NULL);
status = bacnet_address_binding_copy(NULL, &binding);
zassert_false(status, NULL);
status = bacnet_address_binding_copy(&test_binding, NULL);
zassert_false(status, NULL);
status = bacnet_address_binding_init(NULL, 0, &addr);
zassert_false(status, NULL);
len = bacnet_address_binding_to_ascii(NULL, str, sizeof(str));
zassert_equal(len, 0, NULL);
}
/**
* @}
*/
@@ -314,8 +522,9 @@ void test_main(void)
bacnet_address_tests, ztest_unit_test(test_BACNET_ADDRESS),
ztest_unit_test(test_BACNET_MAC_ADDRESS),
ztest_unit_test(test_BACnetAddress_Codec),
ztest_unit_test(test_bacnet_vmac_entry_codec));
ztest_unit_test(test_bacnet_vmac_entry_codec),
ztest_unit_test(test_bacnet_address_ascii),
ztest_unit_test(test_BACNET_ADDRESS_BINDING));
ztest_run_test_suite(bacnet_address_tests);
}
#endif
test/bacnet/bacapp/src/main.c
+11 -7
View File
@@ -1334,7 +1334,8 @@ void test_bacapp_snprintf(
/* normal case */
len = bacapp_snprintf_value(str, str_len + 1, &object_value);
zassert_mem_equal(
str, expected, str_len, "str='%s' expected='%s'", str, expected);
str, expected, str_len, "%s: str='%s' expected='%s'",
bactext_application_tag_name(tag_number), str, expected);
zassert_equal(len, str_len, NULL);
/* test when buffer is too small the behavior matches snprintf(). */
test_len = len;
@@ -1380,14 +1381,17 @@ static void test_bacapp_sprintf_epics(void)
BACNET_APPLICATION_TAG_DOUBLE, "-3.14159", "-3.141590");
test_bacapp_snprintf(
BACNET_APPLICATION_TAG_OCTET_STRING, "1234567890ABCDEF",
"1234567890ABCDEF");
"X'1234567890ABCDEF'");
test_bacapp_snprintf(
BACNET_APPLICATION_TAG_OCTET_STRING, "12-34-56-78-90-AB-CD-EF",
"1234567890ABCDEF");
BACNET_APPLICATION_TAG_OCTET_STRING, "X'1234567890ABCDEF'",
"X'1234567890ABCDEF'");
test_bacapp_snprintf(
BACNET_APPLICATION_TAG_OCTET_STRING, "12 34 56 78 90 AB CD EF",
"1234567890ABCDEF");
test_bacapp_snprintf(BACNET_APPLICATION_TAG_OCTET_STRING, "", "");
BACNET_APPLICATION_TAG_OCTET_STRING, "X'12-34-56-78-90-AB-CD-EF'",
"X'1234567890ABCDEF'");
test_bacapp_snprintf(
BACNET_APPLICATION_TAG_OCTET_STRING, "X'12 34 56 78 90 AB CD EF'",
"X'1234567890ABCDEF'");
test_bacapp_snprintf(BACNET_APPLICATION_TAG_OCTET_STRING, "", "X''");
test_bacapp_snprintf(
BACNET_APPLICATION_TAG_CHARACTER_STRING, "Karg!", "\"Karg!\"");
test_bacapp_snprintf(BACNET_APPLICATION_TAG_CHARACTER_STRING, "", "\"\"");
test/bacnet/bacdest/src/main.c
+117 -46
View File
@@ -11,6 +11,7 @@
#include <stdlib.h>
#include <string.h>
#include <zephyr/ztest.h>
#include <bacnet/bacaddr.h>
#include <bacnet/bacdest.h>
/**
@@ -21,49 +22,6 @@
/**
* @brief Test
*/
static void
testBACnetRecipientData(BACNET_RECIPIENT *data1, BACNET_RECIPIENT *data2)
{
unsigned i = 0;
if (data1 && data2) {
zassert_equal(data1->tag, data2->tag, NULL);
if (data1->tag == BACNET_RECIPIENT_TAG_DEVICE) {
zassert_equal(
data1->type.device.type, data2->type.device.type, NULL);
zassert_equal(
data1->type.device.instance, data2->type.device.instance, NULL);
} else if (data1->tag == BACNET_RECIPIENT_TAG_ADDRESS) {
zassert_equal(
data1->type.address.net, data2->type.address.net, NULL);
if (data1->type.address.net == BACNET_BROADCAST_NETWORK) {
zassert_equal(
data1->type.address.mac_len, data2->type.address.mac_len,
NULL);
} else if (data1->type.address.net) {
zassert_equal(
data1->type.address.len, data2->type.address.len, NULL);
for (i = 0; i < data1->type.address.len; i++) {
zassert_equal(
data1->type.address.adr[i], data2->type.address.adr[i],
NULL);
}
} else {
zassert_equal(
data1->type.address.mac_len, data2->type.address.mac_len,
NULL);
for (i = 0; i < data1->type.address.mac_len; i++) {
zassert_equal(
data1->type.address.mac[i], data2->type.address.mac[i],
NULL);
}
}
} else {
zassert_true(data1->tag < BACNET_RECIPIENT_TAG_MAX, NULL);
}
}
}
#if defined(CONFIG_ZTEST_NEW_API)
ZTEST(bacnet_destination_tests, testBACnetDestination)
#else
@@ -73,6 +31,7 @@ static void testBACnetDestination(void)
uint8_t apdu[MAX_APDU] = { 0 };
BACNET_DESTINATION destination = { 0 }, test_destination = { 0 };
int apdu_len = 0, null_len = 0, test_len = 0;
bool status = false;
destination.Recipient.tag = BACNET_RECIPIENT_TAG_DEVICE;
destination.Recipient.type.device.type = OBJECT_DEVICE;
@@ -82,8 +41,8 @@ static void testBACnetDestination(void)
zassert_equal(apdu_len, null_len, NULL);
test_len = bacnet_destination_decode(apdu, apdu_len, &test_destination);
zassert_equal(apdu_len, test_len, NULL);
testBACnetRecipientData(
&destination.Recipient, &test_destination.Recipient);
status = bacnet_destination_same(&destination, &test_destination);
zassert_true(status, NULL);
destination.Recipient.tag = BACNET_RECIPIENT_TAG_ADDRESS;
destination.Recipient.type.address.net = 1234;
@@ -99,6 +58,8 @@ static void testBACnetDestination(void)
zassert_equal(apdu_len, null_len, NULL);
test_len = bacnet_destination_decode(apdu, apdu_len, &test_destination);
zassert_equal(test_len, apdu_len, NULL);
status = bacnet_destination_same(&destination, &test_destination);
zassert_true(status, NULL);
null_len = bacnet_destination_encode(NULL, &destination);
apdu_len = bacnet_destination_encode(apdu, &destination);
@@ -107,12 +68,27 @@ static void testBACnetDestination(void)
zassert_equal(test_len, apdu_len, NULL);
test_len = bacnet_destination_decode(apdu, apdu_len, NULL);
zassert_equal(test_len, apdu_len, NULL);
status = bacnet_destination_same(&destination, &test_destination);
zassert_true(status, NULL);
bacnet_destination_copy(&test_destination, &destination);
status = bacnet_destination_same(&destination, &test_destination);
zassert_true(status, NULL);
/* decoding, some negative tests */
test_len = bacnet_destination_decode(NULL, apdu_len, &test_destination);
zassert_equal(test_len, BACNET_STATUS_REJECT, NULL);
test_len = bacnet_destination_decode(apdu, 0, &test_destination);
zassert_equal(test_len, BACNET_STATUS_REJECT, NULL);
/* context */
null_len = bacnet_destination_context_encode(NULL, 4, &destination);
apdu_len = bacnet_destination_context_encode(apdu, 4, &destination);
zassert_equal(apdu_len, null_len, NULL);
test_len =
bacnet_destination_context_decode(apdu, apdu_len, 4, &test_destination);
zassert_equal(apdu_len, test_len, NULL);
/* defaults */
status = bacnet_destination_default(&destination);
zassert_false(status, NULL);
}
/**
* @}
@@ -163,6 +139,99 @@ static void test_BACnetDestination_ASCII(void)
}
}
#if defined(CONFIG_ZTEST_NEW_API)
ZTEST(bacnet_destination_tests, testBACnetRecipient)
#else
static void testBACnetRecipient(void)
#endif
{
uint8_t apdu[MAX_APDU] = { 0 };
BACNET_RECIPIENT value = { 0 }, test_value = { 0 };
BACNET_MAC_ADDRESS mac = { .len = 1, .adr[0] = 0x01 };
BACNET_MAC_ADDRESS adr = { .len = 1, .adr[0] = 0x02 };
uint16_t snet = 1234;
BACNET_ADDRESS address = { 0 };
int apdu_len = 0, null_len = 0, test_len = 0;
uint8_t tag_number = 4;
bool status = false;
/* device */
bacnet_recipient_device_set(&value, OBJECT_DEVICE, 123);
status = bacnet_recipient_device_valid(&value);
zassert_true(status, NULL);
bacnet_recipient_copy(&test_value, &value);
status = bacnet_recipient_same(&value, &test_value);
zassert_true(status, NULL);
null_len = bacnet_recipient_encode(NULL, &value);
apdu_len = bacnet_recipient_encode(apdu, &value);
zassert_equal(apdu_len, null_len, NULL);
test_len = bacnet_recipient_decode(apdu, apdu_len, &test_value);
zassert_equal(apdu_len, test_len, NULL);
status = bacnet_recipient_same(&value, &test_value);
zassert_true(status, NULL);
/* address */
status = bacnet_address_init(&address, &mac, snet, &adr);
zassert_true(status, NULL);
bacnet_recipient_address_set(&value, &address);
bacnet_recipient_copy(&test_value, &value);
status = bacnet_recipient_same(&value, &test_value);
zassert_true(status, NULL);
null_len = bacnet_recipient_encode(NULL, &value);
apdu_len = bacnet_recipient_encode(apdu, &value);
zassert_equal(apdu_len, null_len, NULL);
test_len = bacnet_recipient_decode(apdu, apdu_len, &test_value);
zassert_equal(apdu_len, test_len, NULL);
status = bacnet_recipient_same(&value, &test_value);
zassert_true(status, NULL);
/* context */
null_len = bacnet_recipient_context_encode(NULL, tag_number, &value);
apdu_len = bacnet_recipient_context_encode(apdu, tag_number, &value);
zassert_equal(apdu_len, null_len, NULL);
test_len = bacnet_recipient_context_decode(
apdu, apdu_len, tag_number, &test_value);
zassert_equal(apdu_len, test_len, NULL);
status = bacnet_recipient_same(&value, &test_value);
zassert_true(status, NULL);
bacnet_recipient_device_wildcard_set(&value);
status = bacnet_recipient_device_wildcard(&value);
zassert_true(status, NULL);
}
#if defined(CONFIG_ZTEST_NEW_API)
ZTEST(bacnet_destination_tests, test_BACnetRecipient_ASCII)
#else
static void test_BACnetRecipient_ASCII(void)
#endif
{
bool status = false;
BACNET_RECIPIENT value = { 0 }, test_value = { 0 };
BACNET_ADDRESS address = { 0 };
BACNET_MAC_ADDRESS mac = { .len = 1, .adr[0] = 0x01 };
BACNET_MAC_ADDRESS adr = { .len = 1, .adr[0] = 0x02 };
uint16_t snet = 1234;
int len = 0;
char ascii[80] = "";
bacnet_recipient_device_set(&value, OBJECT_DEVICE, 4194303);
len = bacnet_recipient_to_ascii(&value, ascii, sizeof(ascii));
zassert_true(len > 0, NULL);
status = bacnet_recipient_from_ascii(&test_value, ascii);
zassert_true(status, "ascii=%s", ascii);
status = bacnet_recipient_same(&value, &test_value);
zassert_true(status, NULL);
status = bacnet_address_init(&address, &mac, snet, &adr);
zassert_true(status, NULL);
bacnet_recipient_address_set(&value, &address);
len = bacnet_recipient_to_ascii(&value, ascii, sizeof(ascii));
zassert_true(len > 0, NULL);
status = bacnet_recipient_from_ascii(&test_value, ascii);
zassert_true(status, "ascii=%s", ascii);
status = bacnet_recipient_same(&value, &test_value);
zassert_true(status, NULL);
}
#if defined(CONFIG_ZTEST_NEW_API)
ZTEST_SUITE(bacnet_destination_tests, NULL, NULL, NULL, NULL, NULL);
#else
@@ -170,7 +239,9 @@ void test_main(void)
{
ztest_test_suite(
bacnet_destination_tests, ztest_unit_test(testBACnetDestination),
ztest_unit_test(test_BACnetDestination_ASCII));
ztest_unit_test(test_BACnetDestination_ASCII),
ztest_unit_test(testBACnetRecipient),
ztest_unit_test(test_BACnetRecipient_ASCII));
ztest_run_test_suite(bacnet_destination_tests);
}
test/bacnet/bacstr/src/main.c
+367 -7
View File
@@ -5,9 +5,24 @@
* @date 2004
* @copyright SPDX-License-Identifier: MIT
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <zephyr/ztest.h>
#include <bacnet/bacstr.h>
/**
* @brief compare two double precision floating points to 3 decimal places
* @param x1 - first comparison value
* @param x2 - second comparison value
* @return true if the value is the same to 3 decimal points
*/
static bool is_float_equal(double x1, double x2)
{
return fabs(x1 - x2) < 0.001;
}
/**
* @addtogroup bacnet_tests
* @{
@@ -120,6 +135,8 @@ static void testCharacterString(void)
{
BACNET_CHARACTER_STRING bacnet_string = { 0 }, bacnet_string2 = { 0 };
const char *value = "Joshua,Mary,Anna,Christopher";
const char *utf8_value = "Joshua😍Mary😍Anna😍Christopher";
const char *result = NULL;
char test_value[MAX_APDU] = "Patricia";
char test_append_value[MAX_APDU] = " and the Kids";
char test_append_string[MAX_APDU] = "";
@@ -129,12 +146,19 @@ static void testCharacterString(void)
size_t test_length = 0;
size_t i = 0;
/* verify initialization */
/* verify UTF8 initialization */
status = characterstring_init(&bacnet_string, CHARACTER_UTF8, NULL, 0);
zassert_true(status, NULL);
zassert_equal(characterstring_length(&bacnet_string), 0, NULL);
zassert_equal(
characterstring_encoding(&bacnet_string), CHARACTER_UTF8, NULL);
/* verify ANSI initialization */
status = characterstring_init(&bacnet_string, CHARACTER_ANSI_X34, NULL, 0);
zassert_true(status, NULL);
zassert_equal(characterstring_length(&bacnet_string), 0, NULL);
zassert_equal(
characterstring_encoding(&bacnet_string), CHARACTER_ANSI_X34, NULL);
/* empty string is the same as NULL */
status = characterstring_same(&bacnet_string, NULL);
zassert_true(status, NULL);
@@ -156,11 +180,11 @@ static void testCharacterString(void)
status = characterstring_init(
&bacnet_string, CHARACTER_ANSI_X34, &test_value[0], test_length);
zassert_true(status, NULL);
value = characterstring_value(&bacnet_string);
result = characterstring_value(&bacnet_string);
length = characterstring_length(&bacnet_string);
zassert_equal(length, test_length, NULL);
for (i = 0; i < test_length; i++) {
zassert_equal(value[i], test_value[i], NULL);
zassert_equal(result[i], test_value[i], NULL);
}
test_length = characterstring_copy_value(
test_string, sizeof(test_string), &bacnet_string);
@@ -174,10 +198,10 @@ static void testCharacterString(void)
test_length = strlen(test_append_string);
zassert_true(status, NULL);
length = characterstring_length(&bacnet_string);
value = characterstring_value(&bacnet_string);
result = characterstring_value(&bacnet_string);
zassert_equal(length, test_length, NULL);
for (i = 0; i < test_length; i++) {
zassert_equal(value[i], test_append_string[i], NULL);
zassert_equal(result[i], test_append_string[i], NULL);
}
/* init from valid ASCII string */
status = characterstring_init_ansi(&bacnet_string, value);
@@ -223,6 +247,22 @@ static void testCharacterString(void)
status = characterstring_ansi_copy(
test_append_string, sizeof(test_append_string), &bacnet_string);
zassert_equal(strncmp(value, test_append_string, strlen(value)), 0, NULL);
/* UTF-8 specific */
status = characterstring_init_ansi(&bacnet_string, value);
zassert_true(status, NULL);
length = characterstring_length(&bacnet_string);
status = characterstring_init_ansi(&bacnet_string, utf8_value);
zassert_true(status, NULL);
zassert_equal(
characterstring_encoding(&bacnet_string), CHARACTER_UTF8, NULL);
status = characterstring_valid(&bacnet_string);
zassert_true(status, NULL);
test_length = characterstring_utf8_length(&bacnet_string);
zassert_equal(
length, test_length, "value=\"%s\" length=%d, test_length=%d", value,
length, test_length);
status = characterstring_printable(&bacnet_string);
zassert_false(status, NULL);
}
/**
@@ -394,6 +434,17 @@ static void test_bacnet_stricmp(void)
zassert_not_equal(rv, 0, NULL);
rv = bacnet_stricmp(test_name_a, NULL);
zassert_not_equal(rv, 0, NULL);
/* case sensitive */
rv = bacnet_strcmp(name_a, name_a);
zassert_equal(rv, 0, NULL);
rv = bacnet_strcmp(name_a, test_name_a);
zassert_not_equal(rv, 0, NULL);
rv = bacnet_strcmp(test_name_a, test_name_b);
zassert_not_equal(rv, 0, NULL);
rv = bacnet_strcmp(NULL, test_name_b);
zassert_not_equal(rv, 0, NULL);
rv = bacnet_strcmp(test_name_a, NULL);
zassert_not_equal(rv, 0, NULL);
}
/**
@@ -409,6 +460,18 @@ static void test_bacnet_strnicmp(void)
const char *name_a = "Patricia", *test_name_a = "patricia";
const char *name_b = "CamelCase", *test_name_b = "CAMELCASE";
/* case sensitive */
rv = bacnet_strncmp(name_a, name_a, strlen(name_a));
zassert_equal(rv, 0, NULL);
rv = bacnet_strncmp(name_a, test_name_a, strlen(name_a));
zassert_not_equal(rv, 0, NULL);
rv = bacnet_strncmp(test_name_a, test_name_b, strlen(test_name_a));
zassert_not_equal(rv, 0, NULL);
rv = bacnet_strncmp(NULL, test_name_b, strlen(test_name_b));
zassert_not_equal(rv, 0, NULL);
rv = bacnet_strncmp(test_name_a, NULL, strlen(test_name_a));
zassert_not_equal(rv, 0, NULL);
/* case insensitive */
rv = bacnet_strnicmp(name_a, test_name_a, strlen(name_a));
zassert_equal(rv, 0, NULL);
rv = bacnet_strnicmp(name_b, test_name_b, strlen(name_b));
@@ -451,6 +514,299 @@ static void test_bacnet_strnlen(void)
test_len = bacnet_strnlen(test_name, 512);
zassert_equal(len, test_len, "len=%u test_len=%d", len, test_len);
}
/**
* @brief Test encode/decode API for bacnet_strto. functions
*/
#if defined(CONFIG_ZTEST_NEW_API)
ZTEST(bacstr_tests, test_bacnet_strto)
#else
static void test_bacnet_strto(void)
#endif
{
bool status;
const char *empty_string = "";
const char *extra_text_string = "123yyx";
const char *test_unsigned_long_string = "1234567890";
unsigned long unsigned_long_value, test_unsigned_long_value = 1234567890;
const char *test_long_string = "-1234567890";
long long_value, test_long_value = -1234567890;
const char *test_float_positive_string = "1.23";
float float_value, test_float_value = 1.23f;
double double_value, test_double_value = 1.23;
long double long_double_value, test_long_double_value = 1.23L;
const char *test_float_negative_string = "-1.23";
float float_negative_value, test_float_negative_value = -1.23f;
double double_negative_value, test_double_negative_value = -1.23;
long double long_double_negative_value,
test_long_double_negative_value = -1.23L;
char buffer[80] = "", *ascii_result = NULL;
/* unsigned long */
status = bacnet_strtoul(test_unsigned_long_string, &unsigned_long_value);
zassert_true(status, NULL);
zassert_equal(unsigned_long_value, test_unsigned_long_value, NULL);
status = bacnet_strtoul(empty_string, &unsigned_long_value);
zassert_false(status, NULL);
status = bacnet_strtoul(extra_text_string, &unsigned_long_value);
zassert_false(status, NULL);
ascii_result = bacnet_ultoa(unsigned_long_value, buffer, sizeof(buffer));
zassert_equal(bacnet_strcmp(buffer, test_unsigned_long_string), 0, NULL);
zassert_equal(ascii_result, buffer, NULL);
ascii_result = bacnet_utoa(unsigned_long_value, buffer, sizeof(buffer));
zassert_equal(bacnet_strcmp(buffer, test_unsigned_long_string), 0, NULL);
zassert_equal(ascii_result, buffer, NULL);
/* long */
status = bacnet_strtol(test_long_string, &long_value);
zassert_true(status, NULL);
zassert_equal(long_value, test_long_value, NULL);
status = bacnet_strtol(empty_string, &long_value);
zassert_false(status, NULL);
status = bacnet_strtol(extra_text_string, &long_value);
zassert_false(status, NULL);
ascii_result = bacnet_ltoa(long_value, buffer, sizeof(buffer));
zassert_equal(bacnet_strcmp(buffer, test_long_string), 0, NULL);
zassert_equal(ascii_result, buffer, NULL);
ascii_result = bacnet_itoa(long_value, buffer, sizeof(buffer));
zassert_equal(bacnet_strcmp(buffer, test_long_string), 0, NULL);
zassert_equal(ascii_result, buffer, NULL);
/* single precision */
status = bacnet_strtof(test_float_positive_string, &float_value);
zassert_true(status, NULL);
zassert_true(is_float_equal(float_value, test_float_value), NULL);
status = bacnet_strtof(test_float_negative_string, &float_negative_value);
zassert_true(status, NULL);
zassert_true(
is_float_equal(float_negative_value, test_float_negative_value), NULL);
status = bacnet_strtof(empty_string, &float_value);
zassert_false(status, NULL);
status = bacnet_strtof(extra_text_string, &float_value);
zassert_false(status, NULL);
/* double precision */
status = bacnet_strtod(test_float_positive_string, &double_value);
zassert_true(status, NULL);
zassert_true(is_float_equal(double_value, test_double_value), NULL);
status = bacnet_strtod(test_float_negative_string, &double_negative_value);
zassert_true(status, NULL);
zassert_true(
is_float_equal(double_negative_value, test_double_negative_value),
NULL);
status = bacnet_strtod(empty_string, &double_value);
zassert_false(status, NULL);
status = bacnet_strtod(extra_text_string, &double_value);
zassert_false(status, NULL);
ascii_result =
bacnet_dtoa(double_negative_value, buffer, sizeof(buffer), 2);
zassert_equal(bacnet_strcmp(buffer, test_float_negative_string), 0, NULL);
zassert_equal(ascii_result, buffer, NULL);
/* long double precision */
status = bacnet_strtold(test_float_positive_string, &long_double_value);
zassert_true(status, NULL);
zassert_true(
is_float_equal(long_double_value, test_long_double_value), NULL);
status =
bacnet_strtold(test_float_negative_string, &long_double_negative_value);
zassert_true(status, NULL);
zassert_true(
is_float_equal(
long_double_negative_value, test_long_double_negative_value),
NULL);
status = bacnet_strtold(empty_string, &long_double_value);
zassert_false(status, NULL);
status = bacnet_strtold(extra_text_string, &long_double_value);
zassert_false(status, NULL);
}
/**
* @brief Test encode/decode API for bacnet_string_to_x functions
*/
#if defined(CONFIG_ZTEST_NEW_API)
ZTEST(bacstr_tests, test_bacnet_string_to_x)
#else
static void test_bacnet_string_to_x(void)
#endif
{
bool status;
const char *empty_string = "";
const char *extra_text_string = "123yyx";
const char *test_uint8_t_string = "123";
const char *test_uint16_t_string = "12345";
const char *test_uint32_t_string = "1234567890";
const char *test_int32_t_string = "-1234567890";
const char *test_true_string = "true";
const char *test_false_string = "false";
const char *test_active_string = "active";
const char *test_inactive_string = "inactive";
const char *test_true_numeric_string = "1";
const char *test_false_numeric_string = "0";
const char *test_unsigned_string = "1234567890";
const char *test_ascii_string = "abcdefghijklmnopqrstuvwxyz";
uint8_t uint8_t_value, test_uint8_t_value = 123;
uint16_t uint16_t_value, test_uint16_t_value = 12345;
uint32_t uint32_t_value, test_uint32_t_value = 1234567890;
int32_t int32_t_value, test_int32_t_value = -1234567890;
BACNET_UNSIGNED_INTEGER bacnet_unsigned_integer,
test_bacnet_unsigned_integer = 1234567890;
bool bool_value, test_true_value = true, test_false_value = false;
char ascii_string[80] = "", *ascii_string_result = NULL;
/* uint8_t */
status = bacnet_string_to_uint8(test_uint8_t_string, &uint8_t_value);
zassert_true(status, NULL);
zassert_equal(uint8_t_value, test_uint8_t_value, NULL);
status = bacnet_string_to_uint8(empty_string, &uint8_t_value);
zassert_false(status, NULL);
status = bacnet_string_to_uint8(extra_text_string, &uint8_t_value);
zassert_false(status, NULL);
/* uint16_t */
status = bacnet_string_to_uint16(test_uint16_t_string, &uint16_t_value);
zassert_true(status, NULL);
zassert_equal(uint16_t_value, test_uint16_t_value, NULL);
status = bacnet_string_to_uint16(empty_string, &uint16_t_value);
zassert_false(status, NULL);
status = bacnet_string_to_uint16(extra_text_string, &uint16_t_value);
zassert_false(status, NULL);
/* uint32_t */
status = bacnet_string_to_uint32(test_uint32_t_string, &uint32_t_value);
zassert_true(status, NULL);
zassert_equal(uint32_t_value, test_uint32_t_value, NULL);
status = bacnet_string_to_uint32(empty_string, &uint32_t_value);
zassert_false(status, NULL);
status = bacnet_string_to_uint32(extra_text_string, &uint32_t_value);
zassert_false(status, NULL);
/* int32_t */
status = bacnet_string_to_int32(test_int32_t_string, &int32_t_value);
zassert_true(status, NULL);
zassert_equal(int32_t_value, test_int32_t_value, NULL);
status = bacnet_string_to_int32(empty_string, &int32_t_value);
zassert_false(status, NULL);
/* bool */
status = bacnet_string_to_bool(test_true_string, &bool_value);
zassert_true(status, NULL);
zassert_equal(bool_value, test_true_value, NULL);
status = bacnet_string_to_bool(test_false_string, &bool_value);
zassert_true(status, NULL);
zassert_equal(bool_value, test_false_value, NULL);
status = bacnet_string_to_bool(empty_string, &bool_value);
zassert_false(status, NULL);
status = bacnet_string_to_bool(extra_text_string, &bool_value);
zassert_false(status, NULL);
/* active/inactive */
status = bacnet_string_to_bool(test_active_string, &bool_value);
zassert_true(status, NULL);
zassert_equal(bool_value, test_true_value, NULL);
status = bacnet_string_to_bool(test_inactive_string, &bool_value);
zassert_true(status, NULL);
zassert_equal(bool_value, test_false_value, NULL);
status = bacnet_string_to_bool(empty_string, &bool_value);
zassert_false(status, NULL);
/* 0/1 */
status = bacnet_string_to_bool(test_true_numeric_string, &bool_value);
zassert_true(status, NULL);
zassert_equal(bool_value, test_true_value, NULL);
status = bacnet_string_to_bool(test_false_numeric_string, &bool_value);
zassert_true(status, NULL);
zassert_equal(bool_value, test_false_value, NULL);
/* bacnet_unsigned_integer */
status = bacnet_string_to_unsigned(
test_unsigned_string, &bacnet_unsigned_integer);
zassert_true(status, NULL);
zassert_equal(bacnet_unsigned_integer, test_bacnet_unsigned_integer, NULL);
status = bacnet_string_to_unsigned(empty_string, &bacnet_unsigned_integer);
zassert_false(status, NULL);
status =
bacnet_string_to_unsigned(extra_text_string, &bacnet_unsigned_integer);
zassert_false(status, NULL);
/* ascii string */
ascii_string_result = bacnet_snprintf_to_ascii(
ascii_string, sizeof(ascii_string), "%s", test_ascii_string);
zassert_equal(
bacnet_strcmp(ascii_string_result, test_ascii_string), 0, NULL);
}
/**
* @brief Test encode/decode API for bacnet trim functions
*/
#if defined(CONFIG_ZTEST_NEW_API)
ZTEST(bacstr_tests, test_bacnet_string_trim)
#else
static void test_bacnet_string_trim(void)
#endif
{
char trim_left[80] = " abcdefg", *trim_left_result = NULL;
char trim_right[80] = "abcdefg ", *trim_right_result = NULL;
char trim_both[80] = " abcdefg ", *trim_both_result = NULL;
char *trim_test_value = "abcdefg";
char *empty_string = "";
trim_left_result = bacnet_ltrim(trim_left, " ");
trim_right_result = bacnet_rtrim(trim_right, " ");
trim_both_result = bacnet_trim(trim_both, " ");
zassert_equal(bacnet_strcmp(trim_left_result, trim_test_value), 0, NULL);
zassert_equal(bacnet_strcmp(trim_right_result, trim_test_value), 0, NULL);
zassert_equal(bacnet_strcmp(trim_both_result, trim_test_value), 0, NULL);
trim_left_result = bacnet_ltrim(empty_string, " ");
trim_right_result = bacnet_rtrim(empty_string, " ");
trim_both_result = bacnet_trim(empty_string, " ");
zassert_equal(bacnet_strcmp(trim_left_result, empty_string), 0, NULL);
zassert_equal(bacnet_strcmp(trim_right_result, empty_string), 0, NULL);
zassert_equal(bacnet_strcmp(trim_both_result, empty_string), 0, NULL);
}
/**
* @brief Test bacnet_stptok string tokenizer
*/
#if defined(CONFIG_ZTEST_NEW_API)
ZTEST(bacstr_tests, test_bacnet_stptok)
#else
static void test_bacnet_stptok(void)
#endif
{
char *pCmd = "I Love You\r\n";
char token[80] = "";
pCmd = bacnet_stptok(pCmd, token, sizeof(token), " \r\n");
zassert_true(bacnet_strcmp(token, "I") == 0, NULL);
zassert_true(bacnet_strcmp(pCmd, "Love You\r\n") == 0, NULL);
pCmd = bacnet_stptok(pCmd, token, sizeof(token), " \r\n");
zassert_true(bacnet_strcmp(token, "Love") == 0, NULL);
zassert_true(bacnet_strcmp(pCmd, "You\r\n") == 0, NULL);
pCmd = bacnet_stptok(pCmd, token, sizeof(token), " \r\n");
zassert_true(bacnet_strcmp(token, "You") == 0, NULL);
zassert_true(pCmd == NULL, NULL);
}
/**
* @brief Test encode/decode API for bacnet snprintf and shift functions
*/
#if defined(CONFIG_ZTEST_NEW_API)
ZTEST(bacstr_tests, test_bacnet_snprintf)
#else
static void test_bacnet_snprintf(void)
#endif
{
int buf_len = 0, str_len;
int i;
char str[30] = "";
str_len = sizeof(str);
for (i = 0; i < 5; i++) {
/* appending formatted strings */
buf_len = bacnet_snprintf(str, str_len, buf_len, "{");
buf_len =
bacnet_snprintf(str, str_len, buf_len, "REALLY BIG STRING BASS");
buf_len = bacnet_snprintf(str, str_len, buf_len, "}");
}
zassert_equal(buf_len, str_len, "buf_len=%d str_len=%d", buf_len, str_len);
zassert_equal(
str[buf_len - 1], 0, "str[%d]=%c", buf_len - 1, str[buf_len - 1]);
}
/**
* @}
*/
@@ -465,8 +821,12 @@ void test_main(void)
ztest_unit_test(testCharacterString), ztest_unit_test(testOctetString),
ztest_unit_test(test_bacnet_stricmp),
ztest_unit_test(test_bacnet_strnicmp),
ztest_unit_test(test_bacnet_strnlen));
ztest_unit_test(test_bacnet_strnlen),
ztest_unit_test(test_bacnet_strto),
ztest_unit_test(test_bacnet_string_to_x),
ztest_unit_test(test_bacnet_string_trim),
ztest_unit_test(test_bacnet_stptok),
ztest_unit_test(test_bacnet_snprintf));
ztest_run_test_suite(bacstr_tests);
}
#endif
test/bacnet/basic/bbmd/CMakeLists.txt
+3 -1
View File
@@ -34,10 +34,12 @@ add_executable(${PROJECT_NAME}
${SRC_DIR}/bacnet/bacaddr.c
${SRC_DIR}/bacnet/bacdcode.c
${SRC_DIR}/bacnet/bacint.c
${SRC_DIR}/bacnet/bacstr.c
${SRC_DIR}/bacnet/bacreal.c
${SRC_DIR}/bacnet/bacstr.c
${SRC_DIR}/bacnet/bactext.c
${SRC_DIR}/bacnet/hostnport.c
${SRC_DIR}/bacnet/iam.c
${SRC_DIR}/bacnet/indtext.c
${SRC_DIR}/bacnet/npdu.c
${SRC_DIR}/bacnet/basic/sys/bigend.c
${SRC_DIR}/bacnet/basic/sys/debug.c
test/bacnet/basic/bbmd6/CMakeLists.txt
+3 -1
View File
@@ -35,9 +35,11 @@ add_executable(${PROJECT_NAME}
${SRC_DIR}/bacnet/bacaddr.c
${SRC_DIR}/bacnet/bacdcode.c
${SRC_DIR}/bacnet/bacint.c
${SRC_DIR}/bacnet/bacstr.c
${SRC_DIR}/bacnet/bacreal.c
${SRC_DIR}/bacnet/bacstr.c
${SRC_DIR}/bacnet/bactext.c
${SRC_DIR}/bacnet/iam.c
${SRC_DIR}/bacnet/indtext.c
${SRC_DIR}/bacnet/npdu.c
${SRC_DIR}/bacnet/basic/sys/bigend.c
${SRC_DIR}/bacnet/basic/sys/debug.c
test/bacnet/basic/bzll/CMakeLists.txt
+3 -1
View File
@@ -33,9 +33,11 @@ add_executable(${PROJECT_NAME}
${SRC_DIR}/bacnet/bacaddr.c
${SRC_DIR}/bacnet/bacdcode.c
${SRC_DIR}/bacnet/bacint.c
${SRC_DIR}/bacnet/bacstr.c
${SRC_DIR}/bacnet/bacreal.c
${SRC_DIR}/bacnet/bacstr.c
${SRC_DIR}/bacnet/bactext.c
${SRC_DIR}/bacnet/iam.c
${SRC_DIR}/bacnet/indtext.c
${SRC_DIR}/bacnet/npdu.c
${SRC_DIR}/bacnet/basic/sys/bigend.c
${SRC_DIR}/bacnet/basic/sys/debug.c
test/bacnet/datalink/dlmstp/CMakeLists.txt
+2
View File
@@ -40,8 +40,10 @@ add_executable(${PROJECT_NAME}
${SRC_DIR}/bacnet/bacint.c
${SRC_DIR}/bacnet/bacreal.c
${SRC_DIR}/bacnet/bacstr.c
${SRC_DIR}/bacnet/bactext.c
${SRC_DIR}/bacnet/basic/sys/ringbuf.c
${SRC_DIR}/bacnet/basic/sys/days.c
${SRC_DIR}/bacnet/indtext.c
${SRC_DIR}/bacnet/npdu.c
# Test and test library files
./src/main.c
test/bacnet/datalink/mstp/CMakeLists.txt
+3 -1
View File
@@ -45,8 +45,10 @@ add_executable(${PROJECT_NAME}
${SRC_DIR}/bacnet/bacaddr.c
${SRC_DIR}/bacnet/bacdcode.c
${SRC_DIR}/bacnet/bacint.c
${SRC_DIR}/bacnet/bacstr.c
${SRC_DIR}/bacnet/bacreal.c
${SRC_DIR}/bacnet/bacstr.c
${SRC_DIR}/bacnet/bactext.c
${SRC_DIR}/bacnet/indtext.c
${SRC_DIR}/bacnet/npdu.c
${SRC_DIR}/bacnet/basic/sys/bigend.c
# Support files and stubs (pathname alphabetical)
test/bacnet/npdu/CMakeLists.txt
+2
View File
@@ -42,11 +42,13 @@ add_executable(${PROJECT_NAME}
${SRC_DIR}/bacnet/bacint.c
${SRC_DIR}/bacnet/bacreal.c
${SRC_DIR}/bacnet/bacstr.c
${SRC_DIR}/bacnet/bactext.c
${SRC_DIR}/bacnet/basic/service/h_apdu.c
${SRC_DIR}/bacnet/basic/sys/bigend.c
${SRC_DIR}/bacnet/basic/sys/debug.c
${SRC_DIR}/bacnet/basic/tsm/tsm.c
${SRC_DIR}/bacnet/dcc.c
${SRC_DIR}/bacnet/indtext.c
${SRC_DIR}/bacnet/proplist.c
${SRC_DIR}/bacnet/reject.c
${SRC_DIR}/bacnet/rp.c