diff --git a/src/bacnet/datalink/datalink.c b/src/bacnet/datalink/datalink.c index d581fa2f..42fd7638 100644 --- a/src/bacnet/datalink/datalink.c +++ b/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 +#include /* for strcasecmp() */ static enum { DATALINK_NONE = 0, diff --git a/test/bacnet/datalink/mock/CMakeLists.txt b/test/bacnet/datalink/mock/CMakeLists.txt new file mode 100644 index 00000000..800d8025 --- /dev/null +++ b/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 + ) diff --git a/test/bacnet/datalink/mock/src/arcnet-mock.c b/test/bacnet/datalink/mock/src/arcnet-mock.c new file mode 100644 index 00000000..2ac79295 --- /dev/null +++ b/test/bacnet/datalink/mock/src/arcnet-mock.c @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2020 Legrand North America, LLC. + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#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)); +} diff --git a/test/bacnet/datalink/mock/src/bip-mock.c b/test/bacnet/datalink/mock/src/bip-mock.c new file mode 100644 index 00000000..8b012459 --- /dev/null +++ b/test/bacnet/datalink/mock/src/bip-mock.c @@ -0,0 +1,135 @@ +/* + * Copyright (c) 2020 Legrand North America, LLC. + * + * SPDX-License-Identifier: MIT + */ + +#include +#include /* for standard integer types uint8_t etc. */ +#include /* for the standard bool type. */ +#include +#include +#include +#include +#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(); +} diff --git a/test/bacnet/datalink/mock/src/bip6-mock.c b/test/bacnet/datalink/mock/src/bip6-mock.c new file mode 100644 index 00000000..de89cf66 --- /dev/null +++ b/test/bacnet/datalink/mock/src/bip6-mock.c @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2020 Legrand North America, LLC. + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#include /* for standard integer types uint8_t etc. */ +#include /* 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) +{ +} diff --git a/test/bacnet/datalink/mock/src/dlmstp-mock.c b/test/bacnet/datalink/mock/src/dlmstp-mock.c new file mode 100644 index 00000000..ed6a2bf0 --- /dev/null +++ b/test/bacnet/datalink/mock/src/dlmstp-mock.c @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2020 Legrand North America, LLC. + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#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); +} diff --git a/test/bacnet/datalink/mock/src/ethernet-mock.c b/test/bacnet/datalink/mock/src/ethernet-mock.c new file mode 100644 index 00000000..0cee69e0 --- /dev/null +++ b/test/bacnet/datalink/mock/src/ethernet-mock.c @@ -0,0 +1,71 @@ + /* + * Copyright (c) 2020 Legrand North America, LLC. + * + * SPDX-License-Identifier: MIT + */ + +#include +#include +#include +#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(); +} diff --git a/test/bacnet/datalink/mock/src/main.c b/test/bacnet/datalink/mock/src/main.c new file mode 100644 index 00000000..6f17c35d --- /dev/null +++ b/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 /* For calloc() */ +#include +#include +#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); +} diff --git a/zephyr/tests/bacnet/datalink/cobs/CMakeLists.txt b/zephyr/tests/bacnet/datalink/cobs/CMakeLists.txt new file mode 100644 index 00000000..0aa8bb6e --- /dev/null +++ b/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() diff --git a/zephyr/tests/bacnet/datalink/cobs/prj.conf b/zephyr/tests/bacnet/datalink/cobs/prj.conf new file mode 100644 index 00000000..65f15a6f --- /dev/null +++ b/zephyr/tests/bacnet/datalink/cobs/prj.conf @@ -0,0 +1,3 @@ +CONFIG_ZTEST=y +CONFIG_BACNETSTACK=y +CONFIG_BACDL_MSTP=y diff --git a/zephyr/tests/bacnet/datalink/cobs/testcase.yaml b/zephyr/tests/bacnet/datalink/cobs/testcase.yaml new file mode 100644 index 00000000..4c03613b --- /dev/null +++ b/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 diff --git a/zephyr/tests/bacnet/datalink/mock/CMakeLists.txt b/zephyr/tests/bacnet/datalink/mock/CMakeLists.txt new file mode 100644 index 00000000..430f0abb --- /dev/null +++ b/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() diff --git a/zephyr/tests/bacnet/datalink/mock/prj.conf b/zephyr/tests/bacnet/datalink/mock/prj.conf new file mode 100644 index 00000000..f1fba55c --- /dev/null +++ b/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 diff --git a/zephyr/tests/bacnet/datalink/mock/testcase.yaml b/zephyr/tests/bacnet/datalink/mock/testcase.yaml new file mode 100644 index 00000000..8206825b --- /dev/null +++ b/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