Merge pull request #253 from Michail-Antropov/OSCBC-15-testing-datalink-by-mock

Oscbc 15 testing datalink by mock

src/bacnet/datalink/datalink.c

@@ -44,7 +44,7 @@
 #include "bacnet/basic/bbmd6/h_bbmd6.h"
 #include "bacnet/datalink/arcnet.h"
 #include "bacnet/datalink/dlmstp.h"
-#include <string.h>
+#include <strings.h>                /* for strcasecmp() */
 
 static enum {
     DATALINK_NONE = 0,

test/bacnet/datalink/mock/CMakeLists.txt

@@ -0,0 +1,50 @@
+# SPDX-License-Identifier: MIT
+
+cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
+
+get_filename_component(basename ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+project(test_${basename}
+	VERSION 1.0.0
+	LANGUAGES C)
+
+
+string(REGEX REPLACE
+    "/test/bacnet/[a-zA-Z_/-]*$"
+    "/src"
+    SRC_DIR
+    ${CMAKE_CURRENT_SOURCE_DIR})
+string(REGEX REPLACE
+    "/test/bacnet/[a-zA-Z_/-]*$"
+    "/test"
+    TST_DIR
+    ${CMAKE_CURRENT_SOURCE_DIR})
+set(ZTST_DIR "${TST_DIR}/ztest/src")
+
+add_compile_definitions(
+	BIG_ENDIAN=0
+	CONFIG_ZTEST=1
+	BACDL_ALL=1
+	)
+
+include_directories(
+	${SRC_DIR}
+	${TST_DIR}/ztest/include
+	)
+
+file(GLOB SRC_TEST ./src/*.c)
+
+add_executable(${PROJECT_NAME}
+	# File(s) under test
+	${SRC_DIR}/bacnet/datalink/datalink.c
+	# Support files and stubs (pathname alphabetical)
+	${SRC_DIR}/bacnet/bacdcode.c
+	${SRC_DIR}/bacnet/bacint.c
+	${SRC_DIR}/bacnet/bacreal.c
+	${SRC_DIR}/bacnet/bacstr.c
+	${SRC_DIR}/bacnet/basic/sys/bigend.c
+	${SRC_DIR}/bacnet/basic/sys/days.c
+	# Test and test library files
+	${SRC_TEST}
+	${ZTST_DIR}/ztest_mock.c
+	${ZTST_DIR}/ztest.c
+	)

test/bacnet/datalink/mock/src/arcnet-mock.c

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Legrand North America, LLC.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <ztest.h>
+#include <stdint.h>
+#include "bacnet/datalink/arcnet.h"
+
+bool arcnet_valid(void)
+{
+    return ztest_get_return_value();
+}
+
+void arcnet_cleanup(void)
+{
+}
+
+bool arcnet_init(char *interface_name)
+{
+    ztest_check_expected_value(interface_name);
+    return ztest_get_return_value();
+}
+
+int arcnet_send_pdu(BACNET_ADDRESS *dest, BACNET_NPDU_DATA *npdu_data,
+                    uint8_t *pdu, unsigned pdu_len)
+{
+    ztest_check_expected_value(dest);
+    ztest_check_expected_value(npdu_data);
+    ztest_check_expected_data(pdu, pdu_len);
+    return ztest_get_return_value();
+}
+
+uint16_t arcnet_receive(BACNET_ADDRESS *src, uint8_t *pdu, uint16_t max_pdu,
+                        unsigned timeout)
+{
+    ztest_check_expected_value(src);
+    ztest_check_expected_value(timeout);
+    ztest_copy_return_data(pdu, max_pdu);
+    return ztest_get_return_value();
+}
+
+void arcnet_get_my_address(BACNET_ADDRESS *my_address)
+{
+    ztest_copy_return_data(my_address, sizeof(BACNET_ADDRESS));
+}
+
+void arcnet_get_broadcast_address(BACNET_ADDRESS *dest)
+{
+    ztest_copy_return_data(dest, sizeof(BACNET_ADDRESS));
+}

test/bacnet/datalink/mock/src/bip-mock.c

@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2020 Legrand North America, LLC.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <ztest.h>
+#include <stdint.h> /* for standard integer types uint8_t etc. */
+#include <stdbool.h> /* for the standard bool type. */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "bacnet/datalink/bip.h"
+
+bool bip_init(char *ifname)
+{
+    ztest_check_expected_value(ifname);
+    return ztest_get_return_value();
+}
+
+void bip_set_interface(char *ifname)
+{
+    ztest_check_expected_value(ifname);
+}
+
+void bip_cleanup(void)
+{
+}
+
+bool bip_valid(void)
+{
+    return ztest_get_return_value();
+}
+
+bool bip_get_broadcast_addr(BACNET_IP_ADDRESS *addr)
+{
+    ztest_copy_return_data(addr, sizeof(BACNET_IP_ADDRESS));
+    return ztest_get_return_value();
+}
+
+void bip_get_my_address(BACNET_ADDRESS *my_address)
+{
+    ztest_copy_return_data(my_address, sizeof(BACNET_ADDRESS));
+}
+
+int bip_send_pdu(BACNET_ADDRESS *dest,
+    BACNET_NPDU_DATA *npdu_data,
+    uint8_t *pdu,
+    unsigned pdu_len)
+{
+    ztest_check_expected_value(dest);
+    ztest_check_expected_value(npdu_data);
+    ztest_check_expected_data(pdu, pdu_len);
+    return ztest_get_return_value();
+}
+
+int bip_send_mpdu(BACNET_IP_ADDRESS *dest, uint8_t *mtu, uint16_t mtu_len)
+{
+    ztest_check_expected_value(dest);
+    ztest_check_expected_data(mtu, mtu_len);
+    return ztest_get_return_value();
+}
+
+uint16_t bip_receive(BACNET_ADDRESS *src, uint8_t *pdu, uint16_t max_pdu,
+        unsigned timeout)
+{
+    ztest_check_expected_value(src);
+    ztest_check_expected_value(timeout);
+    ztest_copy_return_data(pdu, max_pdu);
+    return ztest_get_return_value();
+}
+
+void bip_set_port(uint16_t port)
+{
+    ztest_check_expected_value(port);
+}
+
+bool bip_port_changed(void)
+{
+    return ztest_get_return_value();
+}
+
+uint16_t bip_get_port(void)
+{
+    return ztest_get_return_value();
+}
+
+bool bip_set_addr(BACNET_IP_ADDRESS *addr)
+{
+    ztest_check_expected_data(addr, sizeof(BACNET_IP_ADDRESS));
+    return ztest_get_return_value();
+}
+
+bool bip_get_addr(BACNET_IP_ADDRESS *addr)
+{
+    ztest_copy_return_data(addr, sizeof(BACNET_IP_ADDRESS));
+    return ztest_get_return_value();
+}
+
+bool bip_get_addr_by_name(const char *host_name, BACNET_IP_ADDRESS *addr)
+{
+    ztest_check_expected_value(host_name);
+    ztest_check_expected_value(addr);
+    return ztest_get_return_value();
+}
+
+void bip_get_broadcast_address(BACNET_ADDRESS *dest)
+{
+    ztest_copy_return_data(dest, sizeof(BACNET_ADDRESS));
+}
+
+bool bip_set_broadcast_addr(BACNET_IP_ADDRESS *addr)
+{
+    return ztest_get_return_value();
+}
+
+bool bip_set_subnet_prefix(uint8_t prefix)
+{
+    return false;
+}
+
+uint8_t bip_get_subnet_prefix(void)
+{
+    return ztest_get_return_value();
+}
+
+void bip_debug_enable(void)
+{
+}
+
+int bip_get_socket(void)
+{
+    return ztest_get_return_value();
+}

test/bacnet/datalink/mock/src/bip6-mock.c

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2020 Legrand North America, LLC.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <ztest.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h> /* for standard integer types uint8_t etc. */
+#include <stdbool.h> /* for the standard bool type. */
+#include "bacnet/datalink/bip6.h"
+
+bool bip6_init(char *ifname)
+{
+    ztest_check_expected_value(ifname);
+    return ztest_get_return_value();
+}
+
+void bip6_cleanup(void)
+{
+}
+
+bool bip6_get_broadcast_addr(BACNET_IP6_ADDRESS *addr)
+{
+    ztest_copy_return_data(addr, sizeof(BACNET_IP6_ADDRESS));
+    return ztest_get_return_value();
+}
+
+void bip6_get_my_address(BACNET_ADDRESS *my_address)
+{
+    ztest_copy_return_data(my_address, sizeof(BACNET_ADDRESS));
+}
+
+int bip6_send_pdu(BACNET_ADDRESS *dest,
+    BACNET_NPDU_DATA *npdu_data,
+    uint8_t *pdu,
+    unsigned pdu_len)
+{
+    ztest_check_expected_value(dest);
+    ztest_check_expected_value(npdu_data);
+    ztest_check_expected_data(pdu, pdu_len);
+    return ztest_get_return_value();
+}
+
+uint16_t bip6_receive(
+    BACNET_ADDRESS *src, uint8_t *pdu, uint16_t max_pdu, unsigned timeout)
+{
+    ztest_check_expected_value(src);
+    ztest_check_expected_value(timeout);
+    ztest_copy_return_data(pdu, max_pdu);
+    return ztest_get_return_value();
+}
+
+void bip6_set_interface(char *ifname)
+{
+    ztest_check_expected_value(ifname);
+}
+
+bool bip6_address_match_self(BACNET_IP6_ADDRESS *addr)
+{
+    ztest_check_expected_value(addr);
+    return ztest_get_return_value();
+}
+
+bool bip6_set_addr(BACNET_IP6_ADDRESS *addr)
+{
+    ztest_check_expected_data(addr, sizeof(BACNET_IP6_ADDRESS));
+    return ztest_get_return_value();
+}
+
+bool bip6_get_addr(BACNET_IP6_ADDRESS *addr)
+{
+    ztest_copy_return_data(addr, sizeof(BACNET_IP6_ADDRESS));
+    return ztest_get_return_value();
+}
+
+void bip6_set_port(uint16_t port)
+{
+    ztest_check_expected_value(port);
+}
+
+uint16_t bip6_get_port(void)
+{
+    return ztest_get_return_value();
+}
+
+void bip6_get_broadcast_address(BACNET_ADDRESS *my_address)
+{
+    ztest_copy_return_data(my_address, sizeof(BACNET_ADDRESS));
+}
+
+bool bip6_set_broadcast_addr(BACNET_IP6_ADDRESS *addr)
+{
+    return ztest_get_return_value();
+}
+
+int bip6_send_mpdu(BACNET_IP6_ADDRESS *dest, uint8_t *mtu, uint16_t mtu_len)
+{
+    ztest_check_expected_value(dest);
+    ztest_check_expected_data(mtu, mtu_len);
+    return ztest_get_return_value();
+}
+
+bool bip6_send_pdu_queue_empty(void)
+{
+    return ztest_get_return_value();
+}
+
+void bip6_receive_callback(void)
+{
+}
+
+void bip6_debug_enable(void)
+{
+}

test/bacnet/datalink/mock/src/dlmstp-mock.c

@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2020 Legrand North America, LLC.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <ztest.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "bacnet/datalink/dlmstp.h"
+
+bool dlmstp_init(char *ifname)
+{
+    ztest_check_expected_value(ifname);
+    return ztest_get_return_value();
+}
+
+void dlmstp_reset(void)
+{    
+}
+
+void dlmstp_cleanup(void)
+{
+}
+
+int dlmstp_send_pdu(BACNET_ADDRESS *dest, BACNET_NPDU_DATA *npdu_data,
+                    uint8_t * pdu, unsigned pdu_len)
+{
+    ztest_check_expected_value(dest);
+    ztest_check_expected_value(npdu_data);
+    ztest_check_expected_data(pdu, pdu_len);
+    return ztest_get_return_value();
+}
+
+uint16_t dlmstp_receive(BACNET_ADDRESS *src, uint8_t *pdu, uint16_t max_pdu,
+                        unsigned timeout)
+{
+    ztest_check_expected_value(src);
+    ztest_check_expected_value(timeout);
+    ztest_copy_return_data(pdu, max_pdu);
+    return ztest_get_return_value();
+}
+
+void dlmstp_set_max_info_frames(uint8_t max_info_frames)
+{
+    ztest_check_expected_value(max_info_frames);
+}
+
+uint8_t dlmstp_max_info_frames(void)
+{
+    return ztest_get_return_value();
+}
+
+void dlmstp_set_max_master(uint8_t max_master)
+{
+    ztest_check_expected_value(max_master);
+}
+
+uint8_t dlmstp_max_master(void)
+{
+    return ztest_get_return_value();
+}
+
+void dlmstp_set_mac_address(uint8_t my_address)
+{
+    ztest_check_expected_value(my_address);
+}
+
+uint8_t dlmstp_mac_address(void)
+{
+    return ztest_get_return_value();
+}
+
+void dlmstp_get_my_address(BACNET_ADDRESS *my_address)
+{
+    ztest_copy_return_data(my_address, sizeof(BACNET_ADDRESS));
+}
+
+void dlmstp_get_broadcast_address(BACNET_ADDRESS *dest)
+{
+    ztest_copy_return_data(dest, sizeof(BACNET_ADDRESS));
+}
+
+void dlmstp_set_baud_rate(uint32_t baud)
+{
+    ztest_check_expected_value(baud);
+}
+
+uint32_t dlmstp_baud_rate(void)
+{
+    return ztest_get_return_value();
+}
+
+void dlmstp_fill_bacnet_address(BACNET_ADDRESS *src, uint8_t mstp_address)
+{
+    ztest_check_expected_value(src);
+    ztest_check_expected_value(mstp_address);
+}
+
+bool dlmstp_sole_master(void)
+{
+    return ztest_get_return_value();
+}
+
+bool dlmstp_send_pdu_queue_empty(void)
+{
+    return ztest_get_return_value();
+}
+
+bool dlmstp_send_pdu_queue_full(void)
+{
+    return ztest_get_return_value();
+}
+
+uint8_t dlmstp_max_info_frames_limit(void)
+{
+    return ztest_get_return_value();
+}
+
+uint8_t dlmstp_max_master_limit(void)
+{
+    return ztest_get_return_value();
+}
+
+void dlmstp_set_frame_rx_complete_callback(
+    dlmstp_hook_frame_rx_complete_cb cb_func)
+{
+    ztest_check_expected_value(cb_func);
+}
+
+void dlmstp_set_frame_rx_start_callback(
+        dlmstp_hook_frame_rx_start_cb cb_func)
+{
+    ztest_check_expected_value(cb_func);
+}
+
+void dlmstp_reset_statistics(void)
+{
+}
+
+void dlmstp_fill_statistics(struct dlmstp_statistics *statistics)
+{
+    ztest_check_expected_value(statistics);
+}

test/bacnet/datalink/mock/src/ethernet-mock.c

@@ -0,0 +1,71 @@
+ /*
+ * Copyright (c) 2020 Legrand North America, LLC.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <ztest.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "bacnet/datalink/ethernet.h"
+
+bool ethernet_valid(void)
+{
+    return ztest_get_return_value();
+}
+
+void ethernet_cleanup(void)
+{
+}
+
+bool ethernet_init(char *interface_name)
+{
+    ztest_check_expected_value(interface_name);
+    return ztest_get_return_value();
+}
+
+int ethernet_send_pdu(BACNET_ADDRESS *dest, BACNET_NPDU_DATA *npdu_data,
+                      uint8_t *pdu, unsigned pdu_len)
+{
+    ztest_check_expected_value(dest);
+    ztest_check_expected_value(npdu_data);
+    ztest_check_expected_data(pdu, pdu_len);
+    return ztest_get_return_value();
+}
+
+uint16_t ethernet_receive(BACNET_ADDRESS *src, uint8_t *pdu, uint16_t max_pdu,
+                         unsigned timeout)
+{
+    ztest_check_expected_value(src);
+    ztest_check_expected_value(timeout);
+    ztest_copy_return_data(pdu, max_pdu);
+    return ztest_get_return_value();
+}
+
+
+void ethernet_set_my_address(BACNET_ADDRESS *my_address)
+{
+    ztest_check_expected_data(my_address, sizeof(BACNET_ADDRESS));
+}
+
+void ethernet_get_my_address(BACNET_ADDRESS *my_address)
+{
+    ztest_copy_return_data(my_address, sizeof(BACNET_ADDRESS));
+}
+
+void ethernet_get_broadcast_address(BACNET_ADDRESS *dest)
+{
+    ztest_copy_return_data(dest, sizeof(BACNET_ADDRESS));
+}
+
+void ethernet_debug_address(const char *info, BACNET_ADDRESS *dest)
+{
+    ztest_check_expected_value(info);
+    ztest_check_expected_value(dest);
+}
+
+int ethernet_send(uint8_t *mtu, int mtu_len)
+{
+    ztest_check_expected_data(mtu, mtu_len);
+    return ztest_get_return_value();
+}

test/bacnet/datalink/mock/src/main.c

@@ -0,0 +1,441 @@
+/*
+ * Copyright (c) 2020 Legrand North America, LLC.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+/* @file
+ * @brief test BACnet datalink return codes
+ */
+
+#include <stdlib.h>  /* For calloc() */
+#include <ztest.h>
+#include <bacnet/datalink/datalink.h>
+#include "bacnet/apdu.h"
+
+void bvlc_maintenance_timer(uint16_t seconds)
+{
+    ztest_check_expected_value(seconds);
+}
+
+void bvlc6_maintenance_timer(uint16_t seconds)
+{
+    ztest_check_expected_value(seconds);
+}
+
+/**
+ * @addtogroup bacnet_tests
+ * @{
+ */
+
+/**
+ * @brief Test datalink
+ */
+
+static void test_datalink_arcnet(void)
+{
+    char *iface = "bla-bla-bla";
+    char *iface2 = "bla-bla-bla2";
+    uint8_t expected_data[] = { 0x5A, 0xA5, 0xDE, 0xAD };
+    uint8_t data[] = { 0xFF, 0xFF, 0xFF, 0xFF };
+    BACNET_ADDRESS addr = {
+        .mac_len = 6, 
+        .mac = { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE },
+        .net = 54,
+        .len = 7,
+        .adr = { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32 }
+    };
+    BACNET_ADDRESS addr2 = {0};
+    BACNET_NPDU_DATA npdu = {0};
+
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+    datalink_set("arcnet");
+
+    // init
+    ztest_expect_value(arcnet_init, interface_name, iface);
+    ztest_returns_value(arcnet_init, true);
+    zassert_equal(datalink_init(iface), true, NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    ztest_expect_value(arcnet_init, interface_name, iface2);
+    ztest_returns_value(arcnet_init, false);
+    zassert_equal(datalink_init(iface2), false, NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // send_pdu
+    ztest_expect_value(arcnet_send_pdu, dest, &addr);
+    ztest_expect_value(arcnet_send_pdu, npdu_data, &npdu);
+    ztest_expect_data(arcnet_send_pdu, pdu, expected_data);
+    ztest_returns_value(arcnet_send_pdu, 4);
+    zassert_equal(datalink_send_pdu(&addr, &npdu, expected_data,
+        sizeof(expected_data)), 4, NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // receive
+    ztest_expect_value(arcnet_receive, src, &addr);
+    ztest_expect_value(arcnet_receive, timeout, 10);
+    ztest_expect_data(arcnet_receive, pdu, expected_data);
+    ztest_returns_value(arcnet_receive, 4);
+    zassert_equal(datalink_receive(&addr, data, sizeof(data), 10), 4, NULL);
+    zassert_mem_equal(expected_data, data, sizeof(data), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    memset(expected_data, 0xff, sizeof(expected_data));
+    memset(data, 0x00, sizeof(data));
+    ztest_expect_value(arcnet_receive, src, &addr);
+    ztest_expect_value(arcnet_receive, timeout, 15);
+    ztest_expect_data(arcnet_receive, pdu, expected_data);
+    ztest_returns_value(arcnet_receive, 0);
+    zassert_equal(datalink_receive(&addr, data, sizeof(data), 15), 0, NULL);
+    zassert_mem_equal(expected_data, data, sizeof(data), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // get_broadcast_address
+    ztest_expect_value(arcnet_get_broadcast_address, dest, &addr);
+    datalink_get_broadcast_address(&addr2);
+    zassert_mem_equal(&addr, &addr2, sizeof(addr), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // get_my_address
+    ztest_expect_value(arcnet_get_my_address, my_address, &addr);
+    datalink_get_my_address(&addr2);
+    zassert_mem_equal(&addr, &addr2, sizeof(addr), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // set_interface - do nothing
+    datalink_set_interface(iface);
+
+    // maintenance_timer - do nothing for arcnet
+    datalink_maintenance_timer(42);
+}
+
+static void test_datalink_bip(void)
+{
+    char *iface = "bla-bla-bla";
+    char *iface2 = "bla-bla-bla2";
+    uint8_t expected_data[] = { 0x5A, 0xA5, 0xDE, 0xAD };
+    uint8_t data[] = { 0xFF, 0xFF, 0xFF, 0xFF };
+    BACNET_ADDRESS addr = {
+        .mac_len = 6, 
+        .mac = { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE },
+        .net = 54,
+        .len = 7,
+        .adr = { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32 }
+    };
+    BACNET_ADDRESS addr2 = {0};
+    BACNET_NPDU_DATA npdu = {0};
+
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+    datalink_set("bip");
+
+    // init
+    ztest_expect_value(bip_init, ifname, iface);
+    ztest_returns_value(bip_init, true);
+    zassert_equal(datalink_init(iface), true, NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    ztest_expect_value(bip_init, ifname, iface2);
+    ztest_returns_value(bip_init, false);
+    zassert_equal(datalink_init(iface2), false, NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // send_pdu
+    ztest_expect_value(bip_send_pdu, dest, &addr);
+    ztest_expect_value(bip_send_pdu, npdu_data, &npdu);
+    ztest_expect_data(bip_send_pdu, pdu, expected_data);
+    ztest_returns_value(bip_send_pdu, 4);
+    zassert_equal(datalink_send_pdu(&addr, &npdu, expected_data,
+        sizeof(expected_data)), 4, NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // receive
+    ztest_expect_value(bip_receive, src, &addr);
+    ztest_expect_value(bip_receive, timeout, 10);
+    ztest_expect_data(bip_receive, pdu, expected_data);
+    ztest_returns_value(bip_receive, 4);
+    zassert_equal(datalink_receive(&addr, data, sizeof(data), 10), 4, NULL);
+    zassert_mem_equal(expected_data, data, sizeof(data), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    memset(expected_data, 0xff, sizeof(expected_data));
+    memset(data, 0x00, sizeof(data));
+    ztest_expect_value(bip_receive, src, &addr);
+    ztest_expect_value(bip_receive, timeout, 15);
+    ztest_expect_data(bip_receive, pdu, expected_data);
+    ztest_returns_value(bip_receive, 0);
+    zassert_equal(datalink_receive(&addr, data, sizeof(data), 15), 0, NULL);
+    zassert_mem_equal(expected_data, data, sizeof(data), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // get_broadcast_address
+    ztest_expect_value(bip_get_broadcast_address, dest, &addr);
+    datalink_get_broadcast_address(&addr2);
+    zassert_mem_equal(&addr, &addr2, sizeof(addr), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // get_my_address
+    ztest_expect_value(bip_get_my_address, my_address, &addr);
+    datalink_get_my_address(&addr2);
+    zassert_mem_equal(&addr, &addr2, sizeof(addr), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // set_interface - do nothing
+    datalink_set_interface(iface);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // maintenance_timer
+    ztest_expect_value(bvlc_maintenance_timer, seconds, 42);
+    datalink_maintenance_timer(42);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+}
+
+static void test_datalink_bip6(void)
+{
+    char *iface = "bla-bla-bla";
+    char *iface2 = "bla-bla-bla2";
+    uint8_t expected_data[] = { 0x5A, 0xA5, 0xDE, 0xAD };
+    uint8_t data[] = { 0xFF, 0xFF, 0xFF, 0xFF };
+    BACNET_ADDRESS addr = {
+        .mac_len = 6, 
+        .mac = { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE },
+        .net = 54,
+        .len = 7,
+        .adr = { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32 }
+    };
+    BACNET_ADDRESS addr2 = {0};
+    BACNET_NPDU_DATA npdu = {0};
+
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+    datalink_set("bip6");
+
+    // init
+    ztest_expect_value(bip6_init, ifname, iface);
+    ztest_returns_value(bip6_init, true);
+    zassert_equal(datalink_init(iface), true, NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    ztest_expect_value(bip6_init, ifname, iface2);
+    ztest_returns_value(bip6_init, false);
+    zassert_equal(datalink_init(iface2), false, NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // send_pdu
+    ztest_expect_value(bip6_send_pdu, dest, &addr);
+    ztest_expect_value(bip6_send_pdu, npdu_data, &npdu);
+    ztest_expect_data(bip6_send_pdu, pdu, expected_data);
+    ztest_returns_value(bip6_send_pdu, 4);
+    zassert_equal(datalink_send_pdu(&addr, &npdu, expected_data,
+        sizeof(expected_data)), 4, NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // receive
+    ztest_expect_value(bip6_receive, src, &addr);
+    ztest_expect_value(bip6_receive, timeout, 10);
+    ztest_expect_data(bip6_receive, pdu, expected_data);
+    ztest_returns_value(bip6_receive, 4);
+    zassert_equal(datalink_receive(&addr, data, sizeof(data), 10), 4, NULL);
+    zassert_mem_equal(expected_data, data, sizeof(data), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    memset(expected_data, 0xff, sizeof(expected_data));
+    memset(data, 0x00, sizeof(data));
+    ztest_expect_value(bip6_receive, src, &addr);
+    ztest_expect_value(bip6_receive, timeout, 15);
+    ztest_expect_data(bip6_receive, pdu, expected_data);
+    ztest_returns_value(bip6_receive, 0);
+    zassert_equal(datalink_receive(&addr, data, sizeof(data), 15), 0, NULL);
+    zassert_mem_equal(expected_data, data, sizeof(data), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // get_broadcast_address
+    ztest_expect_value(bip6_get_broadcast_address, my_address, &addr);
+    datalink_get_broadcast_address(&addr2);
+    zassert_mem_equal(&addr, &addr2, sizeof(addr), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // get_my_address
+    ztest_expect_value(bip6_get_my_address, my_address, &addr);
+    datalink_get_my_address(&addr2);
+    zassert_mem_equal(&addr, &addr2, sizeof(addr), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // set_interface - do nothing
+    datalink_set_interface(iface);
+
+    // maintenance_timer
+    ztest_expect_value(bvlc6_maintenance_timer, seconds, 42);
+    datalink_maintenance_timer(42);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+}
+
+static void test_datalink_dlmstp(void)
+{
+    char *iface = "bla-bla-bla";
+    char *iface2 = "bla-bla-bla2";
+    uint8_t expected_data[] = { 0x5A, 0xA5, 0xDE, 0xAD };
+    uint8_t data[] = { 0xFF, 0xFF, 0xFF, 0xFF };
+    BACNET_ADDRESS addr = {
+        .mac_len = 6, 
+        .mac = { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE },
+        .net = 54,
+        .len = 7,
+        .adr = { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32 }
+    };
+    BACNET_ADDRESS addr2 = {0};
+    BACNET_NPDU_DATA npdu = {0};
+
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+    datalink_set("mstp");
+
+    // init
+    ztest_expect_value(dlmstp_init, ifname, iface);
+    ztest_returns_value(dlmstp_init, true);
+    zassert_equal(datalink_init(iface), true, NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    ztest_expect_value(dlmstp_init, ifname, iface2);
+    ztest_returns_value(dlmstp_init, false);
+    zassert_equal(datalink_init(iface2), false, NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // send_pdu
+    ztest_expect_value(dlmstp_send_pdu, dest, &addr);
+    ztest_expect_value(dlmstp_send_pdu, npdu_data, &npdu);
+    ztest_expect_data(dlmstp_send_pdu, pdu, expected_data);
+    ztest_returns_value(dlmstp_send_pdu, 4);
+    zassert_equal(datalink_send_pdu(&addr, &npdu, expected_data,
+        sizeof(expected_data)), 4, NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // receive
+    ztest_expect_value(dlmstp_receive, src, &addr);
+    ztest_expect_value(dlmstp_receive, timeout, 10);
+    ztest_expect_data(dlmstp_receive, pdu, expected_data);
+    ztest_returns_value(dlmstp_receive, 4);
+    zassert_equal(datalink_receive(&addr, data, sizeof(data), 10), 4, NULL);
+    zassert_mem_equal(expected_data, data, sizeof(data), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    memset(expected_data, 0xff, sizeof(expected_data));
+    memset(data, 0x00, sizeof(data));
+    ztest_expect_value(dlmstp_receive, src, &addr);
+    ztest_expect_value(dlmstp_receive, timeout, 15);
+    ztest_expect_data(dlmstp_receive, pdu, expected_data);
+    ztest_returns_value(dlmstp_receive, 0);
+    zassert_equal(datalink_receive(&addr, data, sizeof(data), 15), 0, NULL);
+    zassert_mem_equal(expected_data, data, sizeof(data), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // get_broadcast_address
+    ztest_expect_value(dlmstp_get_broadcast_address, dest, &addr);
+    datalink_get_broadcast_address(&addr2);
+    zassert_mem_equal(&addr, &addr2, sizeof(addr), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // get_my_address
+    ztest_expect_value(dlmstp_get_my_address, my_address, &addr);
+    datalink_get_my_address(&addr2);
+    zassert_mem_equal(&addr, &addr2, sizeof(addr), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // set_interface - do nothing
+    datalink_set_interface(iface);
+
+    // maintenance_timer - do nothing for dlmstp
+    datalink_maintenance_timer(42);
+}
+
+static void test_datalink_ethernet(void)
+{
+    char *iface = "bla-bla-bla";
+    char *iface2 = "bla-bla-bla2";
+    uint8_t expected_data[] = { 0x5A, 0xA5, 0xDE, 0xAD };
+    uint8_t data[] = { 0xFF, 0xFF, 0xFF, 0xFF };
+    BACNET_ADDRESS addr = {
+        .mac_len = 6, 
+        .mac = { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE },
+        .net = 54,
+        .len = 7,
+        .adr = { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32 }
+    };
+    BACNET_ADDRESS addr2 = {0};
+    BACNET_NPDU_DATA npdu = {0};
+
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+    datalink_set("ethernet");
+
+    // init
+    ztest_expect_value(ethernet_init, interface_name, iface);
+    ztest_returns_value(ethernet_init, true);
+    zassert_equal(datalink_init(iface), true, NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    ztest_expect_value(ethernet_init, interface_name, iface2);
+    ztest_returns_value(ethernet_init, false);
+    zassert_equal(datalink_init(iface2), false, NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // send_pdu
+    ztest_expect_value(ethernet_send_pdu, dest, &addr);
+    ztest_expect_value(ethernet_send_pdu, npdu_data, &npdu);
+    ztest_expect_data(ethernet_send_pdu, pdu, expected_data);
+    ztest_returns_value(ethernet_send_pdu, 4);
+    zassert_equal(datalink_send_pdu(&addr, &npdu, expected_data,
+        sizeof(expected_data)), 4, NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // receive
+    ztest_expect_value(ethernet_receive, src, &addr);
+    ztest_expect_value(ethernet_receive, timeout, 10);
+    ztest_expect_data(ethernet_receive, pdu, expected_data);
+    ztest_returns_value(ethernet_receive, 4);
+    zassert_equal(datalink_receive(&addr, data, sizeof(data), 10), 4, NULL);
+    zassert_mem_equal(expected_data, data, sizeof(data), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    memset(expected_data, 0xff, sizeof(expected_data));
+    memset(data, 0x00, sizeof(data));
+    ztest_expect_value(ethernet_receive, src, &addr);
+    ztest_expect_value(ethernet_receive, timeout, 15);
+    ztest_expect_data(ethernet_receive, pdu, expected_data);
+    ztest_returns_value(ethernet_receive, 0);
+    zassert_equal(datalink_receive(&addr, data, sizeof(data), 15), 0, NULL);
+    zassert_mem_equal(expected_data, data, sizeof(data), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // get_broadcast_address
+    ztest_expect_value(ethernet_get_broadcast_address, dest, &addr);
+    datalink_get_broadcast_address(&addr2);
+    zassert_mem_equal(&addr, &addr2, sizeof(addr), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // get_my_address
+    ztest_expect_value(ethernet_get_my_address, my_address, &addr);
+    datalink_get_my_address(&addr2);
+    zassert_mem_equal(&addr, &addr2, sizeof(addr), NULL);
+    zassert_equal(z_cleanup_mock(), 0, NULL);
+
+    // set_interface - do nothing
+    datalink_set_interface(iface);
+
+    // maintenance_timer - do nothing for ethernet
+    datalink_maintenance_timer(42);
+}
+
+
+/**
+ * @}
+ */
+
+void test_main(void)
+{
+    ztest_test_suite(datalink_tests,
+     ztest_unit_test(test_datalink_arcnet),
+     ztest_unit_test(test_datalink_bip),
+     ztest_unit_test(test_datalink_bip6),
+     ztest_unit_test(test_datalink_dlmstp),
+     ztest_unit_test(test_datalink_ethernet)
+     );
+
+    ztest_run_test_suite(datalink_tests);
+}

zephyr/tests/bacnet/datalink/cobs/CMakeLists.txt

@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: MIT
+
+cmake_minimum_required(VERSION 3.13.1)
+
+# Extract module path and names
+string(REGEX REPLACE
+  "/zephyr/tests/[a-zA-Z_/-]*$" ""
+  BACNET_BASE
+  ${CMAKE_CURRENT_SOURCE_DIR})
+string(REGEX REPLACE
+  "/zephyr/tests/" "/src/"
+  BACNET_SRC_PATH
+  ${CMAKE_CURRENT_SOURCE_DIR})
+string(REGEX REPLACE
+  "/zephyr/tests/" "/test/"
+  BACNET_TEST_PATH
+  ${CMAKE_CURRENT_SOURCE_DIR})
+get_filename_component(BACNET_NAME ${BACNET_BASE} NAME)
+
+add_definitions(-DMAX_APDU=1476)
+get_filename_component(BACNET_DATALINK_SRC ${BACNET_SRC_PATH} PATH)
+
+if(BOARD STREQUAL unit_testing)
+  file(RELATIVE_PATH BACNET_INCLUDE $ENV{ZEPHYR_BASE} ${BACNET_BASE}/src)
+  list(APPEND INCLUDE ${BACNET_INCLUDE})
+  list(APPEND SOURCES
+    ${BACNET_SRC_PATH}.c
+    ${BACNET_TEST_PATH}/src/main.c
+    ${BACNET_DATALINK_SRC}/cobs.c
+    )
+
+  add_definitions(-DBACDL_MSTP=1)
+
+  include($ENV{ZEPHYR_BASE}/subsys/testsuite/unittest.cmake)
+  project(${BACNET_NAME})
+else()
+  include($ENV{ZEPHYR_BASE}/cmake/app/boilerplate.cmake NO_POLICY_SCOPE)
+  project(${BACNET_NAME})
+
+  target_include_directories(app PRIVATE ${BACNET_BASE}/src)
+  target_sources(app PRIVATE
+    ${BACNET_TEST_PATH}/src/main.c
+    ${BACNET_DATALINK_SRC}/cobs.c
+    )
+endif()

zephyr/tests/bacnet/datalink/cobs/prj.conf

@@ -0,0 +1,3 @@
+CONFIG_ZTEST=y
+CONFIG_BACNETSTACK=y
+CONFIG_BACDL_MSTP=y

zephyr/tests/bacnet/datalink/cobs/testcase.yaml

@@ -0,0 +1,6 @@
+tests:
+  bacnet.datalink.cobs.unit:
+    tags: bacnet
+    type: unit
+  bacnet.datalink.cobs:
+    tags: bacnet

zephyr/tests/bacnet/datalink/mock/CMakeLists.txt

@@ -0,0 +1,54 @@
+# SPDX-License-Identifier: MIT
+
+cmake_minimum_required(VERSION 3.13.1)
+
+# Extract module path and names
+string(REGEX REPLACE
+  "/zephyr/tests/[a-zA-Z_/-]*$" ""
+  BACNET_BASE
+  ${CMAKE_CURRENT_SOURCE_DIR})
+string(REGEX REPLACE
+  "/zephyr/tests/" "/src/"
+  BACNET_SRC_PATH
+  ${CMAKE_CURRENT_SOURCE_DIR})
+string(REGEX REPLACE
+  "/zephyr/tests/" "/test/"
+  BACNET_TEST_PATH
+  ${CMAKE_CURRENT_SOURCE_DIR})
+get_filename_component(BACNET_NAME ${BACNET_BASE} NAME)
+
+# Update include path for this module
+list(APPEND BACNET_INCLUDE ${BACNET_BASE}/src)
+
+get_filename_component(BACNET_DATALINK_SRC ${BACNET_SRC_PATH} PATH)
+get_filename_component(BACNET_SRC ${BACNET_DATALINK_SRC} PATH)
+
+if(BOARD STREQUAL unit_testing)
+  file(RELATIVE_PATH BACNET_INCLUDE $ENV{ZEPHYR_BASE} ${BACNET_BASE}/src)
+  list(APPEND INCLUDE ${BACNET_INCLUDE})
+
+  file(GLOB SRC_TEST ${BACNET_TEST_PATH}/src/*.c)
+  list(APPEND SOURCES ${SRC_TEST} )
+
+  list(APPEND SOURCES
+    ${BACNET_DATALINK_SRC}/datalink.c
+    )
+
+  add_definitions(-DBACDL_ALL=1)
+
+  include($ENV{ZEPHYR_BASE}/subsys/testsuite/unittest.cmake)
+  project(${BACNET_NAME})
+else()
+  include($ENV{ZEPHYR_BASE}/cmake/app/boilerplate.cmake NO_POLICY_SCOPE)
+  project(${BACNET_NAME})
+
+  target_include_directories(app PRIVATE ${BACNET_INCLUDE})
+  file(GLOB SRC_TEST ${BACNET_TEST_PATH}/src/*.c)
+
+  add_definitions(-DBACDL_ALL=1 -DBACNET_ETHERNET_NO_REMAP_DEFINES=1)
+
+  target_sources(app PRIVATE
+    ${BACNET_DATALINK_SRC}/datalink.c
+    ${SRC_TEST}
+    )
+endif()

zephyr/tests/bacnet/datalink/mock/prj.conf

@@ -0,0 +1,27 @@
+CONFIG_ZTEST=y
+CONFIG_BACNETSTACK=y
+CONFIG_ZTEST_MOCKING=y
+
+# BIP Options
+CONFIG_BACDL_BIP=n
+#CONFIG_BACDL_BIP_PORT=47808
+#CONFIG_BACDL_BIP_ADDRESS_INDEX=0
+
+# pthreads
+#CONFIG_POSIX_API=y
+#CONFIG_PTHREAD_IPC=y
+#CONFIG_POSIX_MQUEUE=y
+
+# networking
+CONFIG_NETWORKING=y
+CONFIG_NET_IPV4=y
+CONFIG_NET_ARP=y
+CONFIG_NET_TCP=y
+CONFIG_NET_UDP=y
+CONFIG_NET_DHCPV4=y
+CONFIG_NET_L2_ETHERNET=n
+
+CONFIG_NET_MGMT=y
+CONFIG_NET_MGMT_EVENT=y
+
+CONFIG_LOG=y

zephyr/tests/bacnet/datalink/mock/testcase.yaml

@@ -0,0 +1,6 @@
+tests:
+  bacnet.datalink.mock.unit:
+    tags: bacnet
+    type: unit
+  bacnet.datalink.mock:
+    tags: bacnet