net: openthread: rpc: unit tests for ot_rpc_diag.c...

...and ot_rpc_netdata.c

1. Implement missing unit tests for OT API serialization
   implemented in ot_rpc_diag.c and ot_rpc_netdata.c
2. Fix discovered bugs.

Signed-off-by: Damian Krolik <[email protected]>

Author: Damian-Nordic

subsys/net/openthread/rpc/common/ot_rpc_types.h

@@ -17,7 +17,7 @@ enum ot_rpc_netif_address_offsets {
 	OT_RPC_NETIF_ADDRESS_VALID_OFFSET = 1,
 	OT_RPC_NETIF_ADDRESS_SCOPE_VALID_OFFSET = 2,
 	OT_RPC_NETIF_ADDRESS_SCOPE_OFFSET = 3,
-	OT_RPC_NETIF_ADDRESS_SCOPE_MASK = 7 << OT_RPC_NETIF_ADDRESS_SCOPE_OFFSET,
+	OT_RPC_NETIF_ADDRESS_SCOPE_MASK = 0xf << OT_RPC_NETIF_ADDRESS_SCOPE_OFFSET,
 	OT_RPC_NETIF_ADDRESS_RLOC_OFFSET = 7,
 	OT_RPC_NETIF_ADDRESS_MESH_LOCAL_OFFSET = 8,
 };

subsys/net/openthread/rpc/server/CMakeLists.txt

@@ -9,6 +9,7 @@ zephyr_library()
 zephyr_library_sources(
   ot_rpc_cli.c
   ot_rpc_coap.c
+  ot_rpc_diag.c
   ot_rpc_dataset.c
   ot_rpc_instance.c
   ot_rpc_ip6.c
@@ -19,7 +20,6 @@ zephyr_library_sources(
 )
 
 zephyr_library_sources_ifdef(CONFIG_NET_L2_OPENTHREAD
-  ot_rpc_diag.c
   ot_rpc_udp.c
 )
 

subsys/net/openthread/rpc/server/ot_rpc_diag.c

@@ -84,7 +84,7 @@ static bool serialize_mesh_local_prefix(zcbor_state_t *state, const otMeshLocalP
 	static void func_name(const struct nrf_rpc_group *group, struct nrf_rpc_cbor_ctx *ctx,     \
 			      void *handler_data)                                                  \
 	{                                                                                          \
-		size_t length = 1;                                                                \
+		size_t length;                                                                     \
 		const type *data;                                                                  \
 		struct nrf_rpc_cbor_ctx rsp_ctx;                                                   \
                                                                                                    \
@@ -94,7 +94,7 @@ static bool serialize_mesh_local_prefix(zcbor_state_t *state, const otMeshLocalP
 		data = func_to_call(ptr_call);                                                     \
 		openthread_api_mutex_unlock(openthread_get_default_context());                     \
                                                                                                    \
-		length += ret_size(data);                                                          \
+		length = 2 + ret_size(data);                                                       \
                                                                                                    \
 		NRF_RPC_CBOR_ALLOC(group, rsp_ctx, length);                                        \
 		serialize_bstr(rsp_ctx.zs, data);                                                  \

subsys/net/openthread/rpc/server/ot_rpc_ip6.c

@@ -40,7 +40,7 @@ static void ot_rpc_cmd_ip6_get_unicast_addrs(const struct nrf_rpc_group *group,
 			((uint16_t)addr->mValid << OT_RPC_NETIF_ADDRESS_VALID_OFFSET) |
 			((uint16_t)addr->mScopeOverrideValid
 			 << OT_RPC_NETIF_ADDRESS_SCOPE_VALID_OFFSET) |
-			((uint16_t)addr->mScopeOverride << OT_RPC_NETIF_ADDRESS_VALID_OFFSET) |
+			((uint16_t)addr->mScopeOverride << OT_RPC_NETIF_ADDRESS_SCOPE_OFFSET) |
 			((uint16_t)addr->mRloc << OT_RPC_NETIF_ADDRESS_RLOC_OFFSET) |
 			((uint16_t)addr->mMeshLocal << OT_RPC_NETIF_ADDRESS_MESH_LOCAL_OFFSET);
 

tests/mocks/nrf_rpc/mock_nrf_rpc_transport.c

@@ -31,7 +31,7 @@ typedef struct mock_nrf_rpc_tr_ctx {
 
 static void log_payload(const char *caption, const uint8_t *payload, size_t length)
 {
-	char payload_str[32];
+	char payload_str[128];
 
 	if (!bin2hex(payload, length, payload_str, sizeof(payload_str))) {
 		/*

tests/subsys/net/openthread/rpc/client/prj.conf

@@ -11,6 +11,7 @@ CONFIG_TEST_RANDOM_GENERATOR=y
 CONFIG_OPENTHREAD_RPC=y
 CONFIG_OPENTHREAD_RPC_CLIENT=y
 CONFIG_NETWORKING=y
+CONFIG_NRF_RPC_ZCBOR_BACKUPS=1
 CONFIG_NRF_RPC_CBKPROXY_OUT_SLOTS=0
 
 CONFIG_MOCK_NRF_RPC=y

tests/subsys/net/openthread/rpc/client/src/instance_suite.c

@@ -152,4 +152,18 @@ ZTEST(ot_rpc_instance, test_otInstanceErasePersistentInfo_error)
 	zassert_equal(error, OT_ERROR_INVALID_STATE);
 }
 
+/* Test serialization of otGetVersionString() */
+ZTEST(ot_rpc_instance, test_otGetVersionString)
+{
+	const char exp_version[] = {VERSION_STR, '\0'};
+	const char *version;
+
+	mock_nrf_rpc_tr_expect_add(RPC_CMD(OT_RPC_CMD_GET_VERSION_STRING),
+				   RPC_RSP(0x58, 64, VERSION_STR));
+	version = otGetVersionString();
+	mock_nrf_rpc_tr_expect_done();
+
+	zassert_str_equal(version, exp_version);
+}
+
 ZTEST_SUITE(ot_rpc_instance, NULL, NULL, tc_setup, NULL, NULL);

tests/subsys/net/openthread/rpc/client/src/ip6_suite.c

@@ -6,6 +6,7 @@
 
 #include <mock_nrf_rpc_transport.h>
 #include <ot_rpc_ids.h>
+#include <ot_rpc_types.h>
 #include <test_rpc_env.h>
 
 #include <zephyr/ztest.h>
@@ -132,4 +133,77 @@ ZTEST(ot_rpc_ip6, test_otIp6UnsubscribeMulticastAddress_failed)
 	zassert_equal(error, OT_ERROR_FAILED);
 }
 
+/* Test serialization of otIp6GetUnicastAddresses() */
+ZTEST(ot_rpc_ip6, test_otIp6GetUnicastAddresses)
+{
+	const otIp6Address exp_addr1 = {.mFields.m8 = {ADDR_1}};
+	const otIp6Address exp_addr2 = {.mFields.m8 = {ADDR_2}};
+	const uint16_t exp_flags1 = BIT(OT_RPC_NETIF_ADDRESS_PREFERRED_OFFSET) |
+				    BIT(OT_RPC_NETIF_ADDRESS_VALID_OFFSET) |
+				    BIT(OT_RPC_NETIF_ADDRESS_RLOC_OFFSET) |
+				    BIT(OT_RPC_NETIF_ADDRESS_MESH_LOCAL_OFFSET);
+	const uint16_t exp_flags2 = BIT(OT_RPC_NETIF_ADDRESS_SCOPE_VALID_OFFSET) |
+				    (ADDR_SCOPE << OT_RPC_NETIF_ADDRESS_SCOPE_OFFSET);
+
+	const otNetifAddress *addr;
+
+	mock_nrf_rpc_tr_expect_add(RPC_CMD(OT_RPC_CMD_IP6_GET_UNICAST_ADDRESSES),
+				   RPC_RSP(0x9f, 0x50, ADDR_1, CBOR_UINT8(ADDR_PREFIX_LENGTH),
+					   OT_ADDRESS_ORIGIN_MANUAL, CBOR_UINT16(exp_flags1), 0xff,
+					   0x9f, 0x50, ADDR_2, CBOR_UINT8(ADDR_PREFIX_LENGTH),
+					   OT_ADDRESS_ORIGIN_DHCPV6, CBOR_UINT16(exp_flags2),
+					   0xff));
+	addr = otIp6GetUnicastAddresses(NULL);
+	mock_nrf_rpc_tr_expect_done();
+
+	zassert_not_null(addr);
+	zassert_mem_equal(&addr->mAddress, &exp_addr1, OT_IP6_ADDRESS_SIZE);
+	zassert_equal(addr->mPrefixLength, ADDR_PREFIX_LENGTH);
+	zassert_equal(addr->mAddressOrigin, OT_ADDRESS_ORIGIN_MANUAL);
+	zassert_true(addr->mPreferred);
+	zassert_true(addr->mValid);
+	zassert_false(addr->mScopeOverrideValid);
+	zassert_true(addr->mRloc);
+	zassert_true(addr->mMeshLocal);
+	addr = addr->mNext;
+
+	zassert_not_null(addr);
+	zassert_mem_equal(&addr->mAddress, &exp_addr2, OT_IP6_ADDRESS_SIZE);
+	zassert_equal(addr->mPrefixLength, ADDR_PREFIX_LENGTH);
+	zassert_equal(addr->mAddressOrigin, OT_ADDRESS_ORIGIN_DHCPV6);
+	zassert_false(addr->mPreferred);
+	zassert_false(addr->mValid);
+	zassert_true(addr->mScopeOverrideValid);
+	zassert_equal(addr->mScopeOverride, ADDR_SCOPE);
+	zassert_false(addr->mRloc);
+	zassert_false(addr->mMeshLocal);
+	addr = addr->mNext;
+
+	zassert_is_null(addr);
+}
+
+/* Test serialization of otIp6GetMulticastAddresses() */
+ZTEST(ot_rpc_ip6, test_otIp6GetMulticastAddresses)
+{
+	const otIp6Address exp_addr1 = {.mFields.m8 = {MADDR_FF02_1}};
+	const otIp6Address exp_addr2 = {.mFields.m8 = {MADDR_FF02_2}};
+
+	const otNetifMulticastAddress *maddr;
+
+	mock_nrf_rpc_tr_expect_add(RPC_CMD(OT_RPC_CMD_IP6_GET_MULTICAST_ADDRESSES),
+				   RPC_RSP(0x50, MADDR_FF02_1, 0x50, MADDR_FF02_2));
+	maddr = otIp6GetMulticastAddresses(NULL);
+	mock_nrf_rpc_tr_expect_done();
+
+	zassert_not_null(maddr);
+	zassert_mem_equal(&maddr->mAddress, &exp_addr1, OT_IP6_ADDRESS_SIZE);
+	maddr = maddr->mNext;
+
+	zassert_not_null(maddr);
+	zassert_mem_equal(&maddr->mAddress, &exp_addr2, OT_IP6_ADDRESS_SIZE);
+	maddr = maddr->mNext;
+
+	zassert_is_null(maddr);
+}
+
 ZTEST_SUITE(ot_rpc_ip6, NULL, NULL, tc_setup, NULL, NULL);

tests/subsys/net/openthread/rpc/client/src/link_suite.c

@@ -116,4 +116,44 @@ ZTEST(ot_rpc_link, test_otLinkGetFactoryAssignedIeeeEui64)
 	zassert_mem_equal(expected_ext_addr.m8, ext_addr.m8, OT_EXT_ADDRESS_SIZE);
 }
 
+/* Test serialization of otLinkGetChannel() */
+ZTEST(ot_rpc_link, test_otLinkGetChannel)
+{
+	uint8_t channel;
+
+	mock_nrf_rpc_tr_expect_add(RPC_CMD(OT_RPC_CMD_LINK_GET_CHANNEL),
+				   RPC_RSP(CBOR_UINT8(UINT8_MAX)));
+	channel = otLinkGetChannel(NULL);
+	mock_nrf_rpc_tr_expect_done();
+
+	zassert_equal(channel, UINT8_MAX);
+}
+
+/* Test serialization of otLinkGetExtendedAddress() */
+ZTEST(ot_rpc_link, test_otLinkGetExtendedAddress)
+{
+	const otExtAddress exp_extaddr = {{INT_SEQUENCE(OT_EXT_ADDRESS_SIZE)}};
+	const otExtAddress *extaddr;
+
+	mock_nrf_rpc_tr_expect_add(RPC_CMD(OT_RPC_CMD_LINK_GET_EXTENDED_ADDRESS),
+				   RPC_RSP(EXT_ADDR));
+	extaddr = otLinkGetExtendedAddress(NULL);
+	mock_nrf_rpc_tr_expect_done();
+
+	zassert_mem_equal(extaddr, &exp_extaddr, OT_EXT_ADDRESS_SIZE);
+}
+
+/* Test serialization of otLinkGetPanId() */
+ZTEST(ot_rpc_link, test_otLinkGetPanId)
+{
+	otPanId panid;
+
+	mock_nrf_rpc_tr_expect_add(RPC_CMD(OT_RPC_CMD_LINK_GET_PAN_ID),
+				   RPC_RSP(CBOR_UINT16(UINT16_MAX)));
+	panid = otLinkGetPanId(NULL);
+	mock_nrf_rpc_tr_expect_done();
+
+	zassert_equal(panid, UINT16_MAX);
+}
+
 ZTEST_SUITE(ot_rpc_link, NULL, NULL, tc_setup, NULL, NULL);

tests/subsys/net/openthread/rpc/client/src/netdata_suite.c

@@ -123,4 +123,30 @@ ZTEST(ot_rpc_netdata, test_otNetDataGetNextOnMeshPrefix)
 	zassert_true(br.mDp);
 }
 
+/* Test serialization of otNetDataGetStableVersion() */
+ZTEST(ot_rpc_netdata, test_otNetDataGetStableVersion)
+{
+	uint8_t version;
+
+	mock_nrf_rpc_tr_expect_add(RPC_CMD(OT_RPC_CMD_NET_DATA_GET_STABLE_VERSION),
+				   RPC_RSP(CBOR_UINT8(UINT8_MAX)));
+	version = otNetDataGetStableVersion(NULL);
+	mock_nrf_rpc_tr_expect_done();
+
+	zassert_equal(version, UINT8_MAX);
+}
+
+/* Test serialization of otNetDataGetVersion() */
+ZTEST(ot_rpc_netdata, test_otNetDataGetVersion)
+{
+	uint8_t version;
+
+	mock_nrf_rpc_tr_expect_add(RPC_CMD(OT_RPC_CMD_NET_DATA_GET_VERSION),
+				   RPC_RSP(CBOR_UINT8(UINT8_MAX)));
+	version = otNetDataGetVersion(NULL);
+	mock_nrf_rpc_tr_expect_done();
+
+	zassert_equal(version, UINT8_MAX);
+}
+
 ZTEST_SUITE(ot_rpc_netdata, NULL, NULL, tc_setup, NULL, NULL);