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

Oscbc 15 testing datalink by mock

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);
+}