From b592a22dbce521522931f8e3d79d6e16f2d334fa Mon Sep 17 00:00:00 2001
From: Imre Kis <imre.kis@arm.com>
Date: Fri, 17 Jun 2022 14:42:04 +0200
Subject: [PATCH 19/24] Add mock for libsp/sp_memory_management

Add mock_sp_memory_management for mocking sp_memory_management part of
libsp.

Signed-off-by: Imre Kis <imre.kis@arm.com>
Change-Id: I9f74142bc3568dfc59f820ec2c2af81deba0d0da

Upstream-Status: Pending [In review]
Signed-off-by: Anton Antonov <Anton.Antonov@arm.com>

---
 .../ffa/libsp/include/sp_memory_management.h  |   2 +-
 .../messaging/ffa/libsp/mock/component.cmake  |   1 +
 .../libsp/mock/mock_sp_memory_management.cpp  | 523 ++++++++++++++++++
 .../libsp/mock/mock_sp_memory_management.h    |  98 ++++
 .../test/test_mock_sp_memory_management.cpp   | 260 +++++++++
 components/messaging/ffa/libsp/tests.cmake    |  13 +
 6 files changed, 896 insertions(+), 1 deletion(-)
 create mode 100644 components/messaging/ffa/libsp/mock/mock_sp_memory_management.cpp
 create mode 100644 components/messaging/ffa/libsp/mock/mock_sp_memory_management.h
 create mode 100644 components/messaging/ffa/libsp/test/test_mock_sp_memory_management.cpp

diff --git a/components/messaging/ffa/libsp/include/sp_memory_management.h b/components/messaging/ffa/libsp/include/sp_memory_management.h
index 58a6cc1..ec76a3d 100644
--- a/components/messaging/ffa/libsp/include/sp_memory_management.h
+++ b/components/messaging/ffa/libsp/include/sp_memory_management.h
@@ -381,7 +381,7 @@ sp_result sp_memory_share_dynamic_is_supported(bool *supported);
  *
  * @param[in]      descriptor        The memory descriptor
  * @param[in,out]  acc_desc          Access descriptor
- * @param[in,out   regions           Memory region array
+ * @param[in,out]  regions           Memory region array
  * @param[in]      in_region_count   Count of the specified regions, can be 0
  * @param[in,out]  out_region_count  Count of the reserved space of in the
  *                                   regions buffer for retrieved regions. After
diff --git a/components/messaging/ffa/libsp/mock/component.cmake b/components/messaging/ffa/libsp/mock/component.cmake
index 15db85a..eb0d28c 100644
--- a/components/messaging/ffa/libsp/mock/component.cmake
+++ b/components/messaging/ffa/libsp/mock/component.cmake
@@ -13,6 +13,7 @@ target_sources(${TGT} PRIVATE
 	"${CMAKE_CURRENT_LIST_DIR}/mock_ffa_api.cpp"
 	"${CMAKE_CURRENT_LIST_DIR}/mock_ffa_internal_api.cpp"
 	"${CMAKE_CURRENT_LIST_DIR}/mock_sp_discovery.cpp"
+	"${CMAKE_CURRENT_LIST_DIR}/mock_sp_memory_management.cpp"
 	"${CMAKE_CURRENT_LIST_DIR}/mock_sp_rxtx.cpp"
 	)
 
diff --git a/components/messaging/ffa/libsp/mock/mock_sp_memory_management.cpp b/components/messaging/ffa/libsp/mock/mock_sp_memory_management.cpp
new file mode 100644
index 0000000..9eb0aaa
--- /dev/null
+++ b/components/messaging/ffa/libsp/mock/mock_sp_memory_management.cpp
@@ -0,0 +1,523 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/*
+ * Copyright (c) 2022, Arm Limited. All rights reserved.
+ */
+
+#include <CppUTestExt/MockSupport.h>
+#include "mock_sp_memory_management.h"
+
+void expect_sp_memory_donate(const struct sp_memory_descriptor *descriptor,
+			     const struct sp_memory_access_descriptor *acc_desc,
+			     const struct sp_memory_region regions[],
+			     uint32_t region_count, const uint64_t *handle,
+			     sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_donate")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(*descriptor))
+		.withMemoryBufferParameter("acc_desc", (const unsigned char *)acc_desc,
+					   sizeof(*acc_desc))
+		.withMemoryBufferParameter("regions", (const unsigned char *)regions,
+					   sizeof(*regions) * region_count)
+		.withUnsignedIntParameter("region_count", region_count)
+		.withOutputParameterReturning("handle", handle, sizeof(*handle))
+		.andReturnValue(result);
+}
+
+sp_result sp_memory_donate(struct sp_memory_descriptor *descriptor,
+			   struct sp_memory_access_descriptor *acc_desc,
+			   struct sp_memory_region regions[],
+			   uint32_t region_count, uint64_t *handle)
+{
+	return mock()
+		.actualCall("sp_memory_donate")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(*descriptor))
+		.withMemoryBufferParameter("acc_desc", (const unsigned char *)acc_desc,
+					   sizeof(*acc_desc))
+		.withMemoryBufferParameter("regions", (const unsigned char *)regions,
+					   sizeof(*regions) * region_count)
+		.withUnsignedIntParameter("region_count", region_count)
+		.withOutputParameter("handle", handle)
+		.returnIntValue();
+}
+
+void expect_sp_memory_donate_dynamic(const struct sp_memory_descriptor *descriptor,
+				     const struct sp_memory_access_descriptor *acc_desc,
+				     const struct sp_memory_region regions[],
+				     uint32_t region_count, const uint64_t *handle,
+				     sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_donate_dynamic")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(*descriptor))
+		.withMemoryBufferParameter("acc_desc", (const unsigned char *)acc_desc,
+					   sizeof(*acc_desc))
+		.withMemoryBufferParameter("regions", (const unsigned char *)regions,
+					   sizeof(*regions) * region_count)
+		.withUnsignedIntParameter("region_count", region_count)
+		.withOutputParameterReturning("handle", handle, sizeof(*handle))
+		.andReturnValue(result);
+}
+
+sp_result sp_memory_donate_dynamic(struct sp_memory_descriptor *descriptor,
+				   struct sp_memory_access_descriptor *acc_desc,
+				   struct sp_memory_region regions[],
+				   uint32_t region_count, uint64_t *handle,
+				   struct ffa_mem_transaction_buffer *buffer)
+{
+	if (buffer == NULL) { // LCOV_EXCL_BR_LINE
+		FAIL("ffa_mem_transaction_buffer is NULL"); // LCOV_EXCL_LINE
+	}
+
+	return mock()
+		.actualCall("sp_memory_donate_dynamic")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(*descriptor))
+		.withMemoryBufferParameter("acc_desc", (const unsigned char *)acc_desc,
+					   sizeof(*acc_desc))
+		.withMemoryBufferParameter("regions", (const unsigned char *)regions,
+					   sizeof(*regions) * region_count)
+		.withUnsignedIntParameter("region_count", region_count)
+		.withOutputParameter("handle", handle)
+		.returnIntValue();
+}
+
+void expect_sp_memory_donate_dynamic_is_supported(const bool *supported, sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_lend_dynamic_is_supported")
+		.withOutputParameterReturning("supported", supported, sizeof(*supported))
+		.andReturnValue(result);
+}
+
+sp_result sp_memory_donate_dynamic_is_supported(bool *supported)
+{
+	return mock()
+		.actualCall("sp_memory_lend_dynamic_is_supported")
+		.withOutputParameter("supported", supported)
+		.returnIntValue();
+}
+
+void expect_sp_memory_lend(const struct sp_memory_descriptor *descriptor,
+			   const struct sp_memory_access_descriptor acc_desc[],
+			   uint32_t acc_desc_count,
+			   const struct sp_memory_region regions[],
+			   uint32_t region_count, const uint64_t *handle,
+			   sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_lend")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(*descriptor))
+		.withMemoryBufferParameter("acc_desc", (const unsigned char *)acc_desc,
+					   sizeof(*acc_desc) * acc_desc_count)
+		.withUnsignedIntParameter("acc_desc_count", acc_desc_count)
+		.withMemoryBufferParameter("regions", (const unsigned char *)regions,
+					   sizeof(*regions) * region_count)
+		.withUnsignedIntParameter("region_count", region_count)
+		.withOutputParameterReturning("handle", handle, sizeof(*handle))
+		.andReturnValue(result);
+}
+
+sp_result sp_memory_lend(struct sp_memory_descriptor *descriptor,
+			 struct sp_memory_access_descriptor acc_desc[],
+			 uint32_t acc_desc_count,
+			 struct sp_memory_region regions[],
+			 uint32_t region_count, uint64_t *handle)
+{
+	return mock()
+		.actualCall("sp_memory_lend")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(*descriptor))
+		.withMemoryBufferParameter("acc_desc", (const unsigned char *)acc_desc,
+					   sizeof(*acc_desc) * acc_desc_count)
+		.withUnsignedIntParameter("acc_desc_count", acc_desc_count)
+		.withMemoryBufferParameter("regions", (const unsigned char *)regions,
+					   sizeof(*regions) * region_count)
+		.withUnsignedIntParameter("region_count", region_count)
+		.withOutputParameter("handle", handle)
+		.returnIntValue();
+}
+
+void expect_sp_memory_lend_dynamic(const struct sp_memory_descriptor *descriptor,
+				   const struct sp_memory_access_descriptor acc_desc[],
+				   uint32_t acc_desc_count,
+				   const struct sp_memory_region regions[],
+				   const uint32_t region_count, const uint64_t *handle,
+				   sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_lend")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(*descriptor))
+		.withMemoryBufferParameter("acc_desc", (const unsigned char *)acc_desc,
+					   sizeof(*acc_desc) * acc_desc_count)
+		.withUnsignedIntParameter("acc_desc_count", acc_desc_count)
+		.withMemoryBufferParameter("regions", (const unsigned char *)regions,
+					   sizeof(*regions) * region_count)
+		.withUnsignedIntParameter("region_count", region_count)
+		.withOutputParameterReturning("handle", handle, sizeof(*handle))
+		.andReturnValue(result);
+}
+
+sp_result sp_memory_lend_dynamic(struct sp_memory_descriptor *descriptor,
+				 struct sp_memory_access_descriptor acc_desc[],
+				 uint32_t acc_desc_count,
+				 struct sp_memory_region regions[],
+				 uint32_t region_count, uint64_t *handle,
+				 struct ffa_mem_transaction_buffer *buffer)
+{
+	if (buffer == NULL) { // LCOV_EXCL_BR_LINE
+		FAIL("ffa_mem_transaction_buffer is NULL"); // LCOV_EXCL_LINE
+	}
+
+	return mock()
+		.actualCall("sp_memory_lend")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(*descriptor))
+		.withMemoryBufferParameter("acc_desc", (const unsigned char *)acc_desc,
+					   sizeof(*acc_desc) * acc_desc_count)
+		.withUnsignedIntParameter("acc_desc_count", acc_desc_count)
+		.withMemoryBufferParameter("regions", (const unsigned char *)regions,
+					   sizeof(*regions) * region_count)
+		.withUnsignedIntParameter("region_count", region_count)
+		.withOutputParameter("handle", handle)
+		.returnIntValue();
+}
+
+void expect_sp_memory_lend_dynamic_is_supported(const bool *supported, sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_lend_dynamic_is_supported")
+		.withOutputParameterReturning("supported", supported, sizeof(*supported))
+		.andReturnValue(result);
+}
+
+sp_result sp_memory_lend_dynamic_is_supported(bool *supported)
+{
+	return mock()
+		.actualCall("sp_memory_lend_dynamic_is_supported")
+		.withOutputParameter("supported", supported)
+		.returnIntValue();
+}
+
+void expect_sp_memory_share(const struct sp_memory_descriptor *descriptor,
+			    const struct sp_memory_access_descriptor acc_desc[],
+			    uint32_t acc_desc_count,
+			    const struct sp_memory_region regions[],
+			    uint32_t region_count, const uint64_t *handle,
+			    sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_share")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(*descriptor))
+		.withMemoryBufferParameter("acc_desc", (const unsigned char *)acc_desc,
+					   sizeof(*acc_desc) * acc_desc_count)
+		.withUnsignedIntParameter("acc_desc_count", acc_desc_count)
+		.withMemoryBufferParameter("regions", (const unsigned char *)regions,
+					   sizeof(*regions) * region_count)
+		.withUnsignedIntParameter("region_count", region_count)
+		.withOutputParameterReturning("handle", handle, sizeof(*handle))
+		.andReturnValue(result);
+}
+
+sp_result sp_memory_share(struct sp_memory_descriptor *descriptor,
+			  struct sp_memory_access_descriptor acc_desc[],
+			  uint32_t acc_desc_count,
+			  struct sp_memory_region regions[],
+			  uint32_t region_count, uint64_t *handle)
+{
+	return mock()
+		.actualCall("sp_memory_share")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(*descriptor))
+		.withMemoryBufferParameter("acc_desc", (const unsigned char *)acc_desc,
+					   sizeof(*acc_desc) * acc_desc_count)
+		.withUnsignedIntParameter("acc_desc_count", acc_desc_count)
+		.withMemoryBufferParameter("regions", (const unsigned char *)regions,
+					   sizeof(*regions) * region_count)
+		.withUnsignedIntParameter("region_count", region_count)
+		.withOutputParameter("handle", handle)
+		.returnIntValue();
+}
+
+void expect_sp_memory_share_dynamic(const struct sp_memory_descriptor *descriptor,
+				    const struct sp_memory_access_descriptor acc_desc[],
+				    uint32_t acc_desc_count,
+				    const struct sp_memory_region regions[],
+				    uint32_t region_count, const uint64_t *handle,
+				    sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_share_dynamic")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(*descriptor))
+		.withMemoryBufferParameter("acc_desc", (const unsigned char *)acc_desc,
+					   sizeof(*acc_desc) * acc_desc_count)
+		.withUnsignedIntParameter("acc_desc_count", acc_desc_count)
+		.withMemoryBufferParameter("regions", (const unsigned char *)regions,
+					   sizeof(*regions) * region_count)
+		.withUnsignedIntParameter("region_count", region_count)
+		.withOutputParameterReturning("handle", handle, sizeof(*handle))
+		.andReturnValue(result);
+}
+
+sp_result sp_memory_share_dynamic(struct sp_memory_descriptor *descriptor,
+				  struct sp_memory_access_descriptor acc_desc[],
+				  uint32_t acc_desc_count,
+				  struct sp_memory_region regions[],
+				  uint32_t region_count, uint64_t *handle,
+				  struct ffa_mem_transaction_buffer *buffer)
+{
+	if (buffer == NULL) { // LCOV_EXCL_BR_LINE
+		FAIL("ffa_mem_transaction_buffer is NULL"); // LCOV_EXCL_LINE
+	}
+
+	return mock()
+		.actualCall("sp_memory_share_dynamic")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(*descriptor))
+		.withMemoryBufferParameter("acc_desc", (const unsigned char *)acc_desc,
+					   sizeof(*acc_desc) * acc_desc_count)
+		.withUnsignedIntParameter("acc_desc_count", acc_desc_count)
+		.withMemoryBufferParameter("regions", (const unsigned char *)regions,
+					   sizeof(*regions) * region_count)
+		.withUnsignedIntParameter("region_count", region_count)
+		.withOutputParameter("handle", handle)
+		.returnIntValue();
+}
+
+void expect_sp_memory_share_dynamic_is_supported(const bool *supported, sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_share_dynamic_is_supported")
+		.withOutputParameterReturning("supported", supported, sizeof(*supported))
+		.andReturnValue(result);
+}
+
+sp_result sp_memory_share_dynamic_is_supported(bool *supported)
+{
+	return mock()
+		.actualCall("sp_memory_share_dynamic_is_supported")
+		.withOutputParameter("supported", supported)
+		.returnIntValue();
+}
+
+void expect_sp_memory_retrieve(const struct sp_memory_descriptor *descriptor,
+			       const struct sp_memory_access_descriptor *req_acc_desc,
+			       const struct sp_memory_access_descriptor *resp_acc_desc,
+			       const struct sp_memory_region in_regions[],
+			       const struct sp_memory_region out_regions[],
+			       uint32_t in_region_count,
+			       const uint32_t *out_region_count, uint64_t handle,
+			       sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_retrieve")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(descriptor))
+		.withMemoryBufferParameter("req_acc_desc", (const unsigned char *)req_acc_desc,
+					   sizeof(*req_acc_desc))
+		.withOutputParameterReturning("resp_acc_desc",
+					      (const unsigned char *)resp_acc_desc,
+					      sizeof(*resp_acc_desc))
+		.withMemoryBufferParameter("in_regions", (const unsigned char *)in_regions,
+					   sizeof(*in_regions) * in_region_count)
+		.withOutputParameterReturning("out_regions", out_regions,
+					      sizeof(*out_regions) * *out_region_count)
+		.withUnsignedIntParameter("in_region_count", in_region_count)
+		.withOutputParameterReturning("out_region_count", out_region_count,
+					      sizeof(*out_region_count))
+		.withUnsignedLongIntParameter("handle", handle)
+		.andReturnValue(result);
+
+}
+
+sp_result sp_memory_retrieve(struct sp_memory_descriptor *descriptor,
+			     struct sp_memory_access_descriptor *acc_desc,
+			     struct sp_memory_region regions[],
+			     uint32_t in_region_count,
+			     uint32_t *out_region_count, uint64_t handle)
+{
+	return mock()
+		.actualCall("sp_memory_retrieve")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(descriptor))
+		.withMemoryBufferParameter("req_acc_desc", (const unsigned char *)acc_desc,
+					   sizeof(*acc_desc))
+		.withOutputParameter("resp_acc_desc", acc_desc)
+		.withMemoryBufferParameter("in_regions", (const unsigned char *)regions,
+					   sizeof(*regions) * in_region_count)
+		.withOutputParameter("out_regions", regions)
+		.withUnsignedIntParameter("in_region_count", in_region_count)
+		.withOutputParameter("out_region_count", out_region_count)
+		.withUnsignedLongIntParameter("handle", handle)
+		.returnIntValue();
+}
+
+void expect_sp_memory_retrieve_dynamic(const struct sp_memory_descriptor *descriptor,
+				       const struct sp_memory_access_descriptor *req_acc_desc,
+				       const struct sp_memory_access_descriptor *resp_acc_desc,
+				       const struct sp_memory_region in_regions[],
+				       const struct sp_memory_region out_regions[],
+				       uint32_t in_region_count,
+				       const uint32_t *out_region_count, uint64_t handle,
+				       sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_retrieve")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(descriptor))
+		.withMemoryBufferParameter("req_acc_desc", (const unsigned char *)req_acc_desc,
+					   sizeof(*req_acc_desc))
+		.withOutputParameterReturning("resp_acc_desc",
+					      (const unsigned char *)resp_acc_desc,
+					      sizeof(*resp_acc_desc))
+		.withMemoryBufferParameter("in_regions", (const unsigned char *)in_regions,
+					   sizeof(*in_regions) * in_region_count)
+		.withOutputParameterReturning("out_regions", out_regions,
+					      sizeof(*out_regions) * *out_region_count)
+		.withUnsignedIntParameter("in_region_count", in_region_count)
+		.withOutputParameterReturning("out_region_count", out_region_count,
+					      sizeof(*out_region_count))
+		.withUnsignedLongIntParameter("handle", handle)
+		.andReturnValue(result);
+}
+
+sp_result
+sp_memory_retrieve_dynamic(struct sp_memory_descriptor *descriptor,
+			   struct sp_memory_access_descriptor *acc_desc,
+			   struct sp_memory_region regions[],
+			   uint32_t in_region_count, uint32_t *out_region_count,
+			   uint64_t handle,
+			   struct ffa_mem_transaction_buffer *buffer)
+{
+	if (buffer == NULL) { // LCOV_EXCL_BR_LINE
+		FAIL("ffa_mem_transaction_buffer is NULL"); // LCOV_EXCL_LINE
+	}
+
+	return mock()
+		.actualCall("sp_memory_retrieve")
+		.withMemoryBufferParameter("descriptor", (const unsigned char *)descriptor,
+					   sizeof(descriptor))
+		.withMemoryBufferParameter("req_acc_desc", (const unsigned char *)acc_desc,
+					   sizeof(*acc_desc))
+		.withOutputParameter("resp_acc_desc", acc_desc)
+		.withMemoryBufferParameter("in_regions", (const unsigned char *)regions,
+					   sizeof(*regions) * in_region_count)
+		.withOutputParameter("out_regions", regions)
+		.withUnsignedIntParameter("in_region_count", in_region_count)
+		.withOutputParameter("out_region_count", out_region_count)
+		.withUnsignedLongIntParameter("handle", handle)
+		.returnIntValue();
+}
+
+void expect_sp_memory_retrieve_dynamic_is_supported(const bool *supported, sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_retrieve_dynamic_is_supported")
+		.withOutputParameterReturning("supported", supported, sizeof(*supported))
+		.andReturnValue(result);
+}
+
+sp_result sp_memory_retrieve_dynamic_is_supported(bool *supported)
+{
+	return mock()
+		.actualCall("sp_memory_retrieve_dynamic_is_supported")
+		.withOutputParameter("supported", supported)
+		.returnIntValue();
+}
+
+void expect_sp_memory_relinquish(uint64_t handle, const uint16_t endpoints[],
+			         uint32_t endpoint_count,
+			         const struct sp_memory_transaction_flags *flags,
+				 sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_relinquish")
+		.withUnsignedLongIntParameter("handle", handle)
+		.withMemoryBufferParameter("endpoints", (const unsigned char *)endpoints,
+					   sizeof(*endpoints) * endpoint_count)
+		.withMemoryBufferParameter("flags", (const unsigned char *)flags, sizeof(*flags))
+		.andReturnValue(result);
+}
+
+sp_result sp_memory_relinquish(uint64_t handle, const uint16_t endpoints[],
+			       uint32_t endpoint_count,
+			       struct sp_memory_transaction_flags *flags)
+{
+	return mock()
+		.actualCall("sp_memory_relinquish")
+		.withUnsignedLongIntParameter("handle", handle)
+		.withMemoryBufferParameter("endpoints", (const unsigned char *)endpoints,
+					   sizeof(*endpoints) * endpoint_count)
+		.withMemoryBufferParameter("flags", (const unsigned char *)flags, sizeof(*flags))
+		.returnIntValue();
+}
+
+void expect_sp_memory_reclaim(uint64_t handle, uint32_t flags, sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_reclaim")
+		.withUnsignedLongIntParameter("handle", handle)
+		.withUnsignedIntParameter("flags", flags)
+		.andReturnValue(result);
+}
+
+sp_result sp_memory_reclaim(uint64_t handle, uint32_t flags)
+{
+	return mock()
+		.actualCall("sp_memory_reclaim")
+		.withUnsignedLongIntParameter("handle", handle)
+		.withUnsignedIntParameter("flags", flags)
+		.returnIntValue();
+}
+
+void expect_sp_memory_permission_get(const void *base_address, const struct sp_mem_perm *mem_perm,
+				     sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_permission_set")
+		.withConstPointerParameter("base_address", base_address)
+		.withOutputParameterReturning("mem_perm", mem_perm,
+					      sizeof(*mem_perm))
+		.andReturnValue(result);
+}
+
+sp_result sp_memory_permission_get(const void *base_address,
+				   struct sp_mem_perm *mem_perm)
+{
+	return mock()
+		.actualCall("sp_memory_permission_set")
+		.withConstPointerParameter("base_address", base_address)
+		.withOutputParameter("mem_perm", mem_perm)
+		.returnIntValue();
+}
+
+void expect_sp_memory_permission_set(const void *base_address, size_t region_size,
+				     const struct sp_mem_perm *mem_perm, sp_result result)
+{
+	mock()
+		.expectOneCall("sp_memory_permission_set")
+		.withConstPointerParameter("base_address", base_address)
+		.withUnsignedLongIntParameter("region_size", region_size)
+		.withMemoryBufferParameter("mem_perm", (const unsigned char *)mem_perm,
+					   sizeof(*mem_perm))
+		.andReturnValue(result);
+}
+
+sp_result sp_memory_permission_set(const void *base_address, size_t region_size,
+				   const struct sp_mem_perm *mem_perm)
+{
+	return mock()
+		.actualCall("sp_memory_permission_set")
+		.withConstPointerParameter("base_address", base_address)
+		.withUnsignedLongIntParameter("region_size", region_size)
+		.withMemoryBufferParameter("mem_perm", (const unsigned char *)mem_perm,
+					   sizeof(*mem_perm))
+		.returnIntValue();
+}
diff --git a/components/messaging/ffa/libsp/mock/mock_sp_memory_management.h b/components/messaging/ffa/libsp/mock/mock_sp_memory_management.h
new file mode 100644
index 0000000..458d2af
--- /dev/null
+++ b/components/messaging/ffa/libsp/mock/mock_sp_memory_management.h
@@ -0,0 +1,98 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+/*
+ * Copyright (c) 2022, Arm Limited and Contributors. All rights reserved.
+ */
+
+#ifndef LIBSP_MOCK_MOCK_SP_MEMORY_MANAGEMENT_H_
+#define LIBSP_MOCK_MOCK_SP_MEMORY_MANAGEMENT_H_
+
+#include "../include/sp_memory_management.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void expect_sp_memory_donate(const struct sp_memory_descriptor *descriptor,
+			     const struct sp_memory_access_descriptor *acc_desc,
+			     const struct sp_memory_region regions[],
+			     uint32_t region_count, const uint64_t *handle,
+			     sp_result result);
+
+void expect_sp_memory_donate_dynamic(const struct sp_memory_descriptor *descriptor,
+				     const struct sp_memory_access_descriptor *acc_desc,
+				     const struct sp_memory_region regions[],
+				     uint32_t region_count, const uint64_t *handle,
+				     sp_result result);
+
+void expect_sp_memory_donate_dynamic_is_supported(const bool *supported, sp_result result);
+
+void expect_sp_memory_lend(const struct sp_memory_descriptor *descriptor,
+			   const struct sp_memory_access_descriptor acc_desc[],
+			   uint32_t acc_desc_count,
+			   const struct sp_memory_region regions[],
+			   uint32_t region_count, const uint64_t *handle,
+			   sp_result result);
+
+void expect_sp_memory_lend_dynamic(const struct sp_memory_descriptor *descriptor,
+				   const struct sp_memory_access_descriptor acc_desc[],
+				   uint32_t acc_desc_count,
+				   const struct sp_memory_region regions[],
+				   const uint32_t region_count, const uint64_t *handle,
+				   sp_result result);
+
+void expect_sp_memory_lend_dynamic_is_supported(const bool *supported, sp_result result);
+
+void expect_sp_memory_share(const struct sp_memory_descriptor *descriptor,
+			    const struct sp_memory_access_descriptor acc_desc[],
+			    uint32_t acc_desc_count,
+			    const struct sp_memory_region regions[],
+			    uint32_t region_count, const uint64_t *handle,
+			    sp_result result);
+
+void expect_sp_memory_share_dynamic(const struct sp_memory_descriptor *descriptor,
+				    const struct sp_memory_access_descriptor acc_desc[],
+				    uint32_t acc_desc_count,
+				    const struct sp_memory_region regions[],
+				    uint32_t region_count, const uint64_t *handle,
+				    sp_result result);
+
+void expect_sp_memory_share_dynamic_is_supported(const bool *supported, sp_result result);
+
+void expect_sp_memory_retrieve(const struct sp_memory_descriptor *descriptor,
+			       const struct sp_memory_access_descriptor *req_acc_desc,
+			       const struct sp_memory_access_descriptor *resp_acc_desc,
+			       const struct sp_memory_region in_regions[],
+			       const struct sp_memory_region out_regions[],
+			       uint32_t in_region_count,
+			       const uint32_t *out_region_count, uint64_t handle,
+			       sp_result result);
+
+void expect_sp_memory_retrieve_dynamic(const struct sp_memory_descriptor *descriptor,
+				       const struct sp_memory_access_descriptor *req_acc_desc,
+				       const struct sp_memory_access_descriptor *resp_acc_desc,
+				       const struct sp_memory_region in_regions[],
+				       const struct sp_memory_region out_regions[],
+				       uint32_t in_region_count,
+				       const uint32_t *out_region_count, uint64_t handle,
+				       sp_result result);
+
+void expect_sp_memory_retrieve_dynamic_is_supported(const bool *supported, sp_result result);
+
+void expect_sp_memory_relinquish(uint64_t handle, const uint16_t endpoints[],
+				 uint32_t endpoint_count,
+				 const struct sp_memory_transaction_flags *flags,
+				 sp_result result);
+
+void expect_sp_memory_reclaim(uint64_t handle, uint32_t flags, sp_result result);
+
+void expect_sp_memory_permission_get(const void *base_address, const struct sp_mem_perm *mem_perm,
+				     sp_result result);
+
+void expect_sp_memory_permission_set(const void *base_address, size_t region_size,
+				     const struct sp_mem_perm *mem_perm, sp_result result);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBSP_MOCK_MOCK_SP_MEMORY_MANAGEMENT_H_ */
diff --git a/components/messaging/ffa/libsp/test/test_mock_sp_memory_management.cpp b/components/messaging/ffa/libsp/test/test_mock_sp_memory_management.cpp
new file mode 100644
index 0000000..387b50f
--- /dev/null
+++ b/components/messaging/ffa/libsp/test/test_mock_sp_memory_management.cpp
@@ -0,0 +1,260 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/*
+ * Copyright (c) 2022, Arm Limited. All rights reserved.
+ */
+
+#include <CppUTestExt/MockSupport.h>
+#include <CppUTest/TestHarness.h>
+#include "mock_sp_memory_management.h"
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+static const struct sp_memory_descriptor expected_descriptor = {
+	.sender_id = 0xfedc,
+	.memory_type = sp_memory_type_normal_memory,
+	.mem_region_attr = {.normal_memory = {
+		.cacheability = sp_cacheability_write_back,
+		.shareability = sp_shareability_inner_shareable
+	}},
+	.flags = {
+		.zero_memory = true,
+		.operation_time_slicing = true,
+		.zero_memory_after_relinquish = true,
+		.transaction_type = sp_memory_transaction_type_relayer_specified,
+		.alignment_hint = 0x2000
+	},
+	.tag = 0x0123456789abcdefULL
+};
+static const struct sp_memory_access_descriptor expected_acc_desc[] = {
+	{
+		.receiver_id = 0xfafa,
+		.instruction_access = sp_instruction_access_executable,
+		.data_access = sp_data_access_read_only
+	}, {
+		.receiver_id = 0xc1ca,
+		.instruction_access = sp_instruction_access_not_executable,
+		.data_access = sp_data_access_read_write
+	}
+};
+static const struct sp_memory_region expected_regions[2] = {
+	{.address = (void *)0x01234567, .page_count = 0x89abcdef},
+	{.address = (void *)0x12345670, .page_count = 0x9abcdef8},
+};
+static const uint64_t expected_handle = 0xabcdef0123456789ULL;
+static const void *expected_address = (const void *)0x234567879;
+static const struct sp_mem_perm expected_mem_perm = {
+	.data_access = sp_mem_perm_data_perm_read_write,
+	.instruction_access = sp_mem_perm_instruction_perm_non_executable,
+};
+
+TEST_GROUP(mock_sp_memory_management)
+{
+	TEST_SETUP()
+	{
+		memset(&descriptor, 0x00, sizeof(descriptor));
+		memset(&acc_desc, 0x00, sizeof(acc_desc));
+		memset(&regions, 0x00, sizeof(regions));
+		handle = 0;
+		supported = false;
+	}
+
+	TEST_TEARDOWN()
+	{
+		mock().checkExpectations();
+		mock().clear();
+	}
+
+	struct sp_memory_descriptor descriptor;
+	struct sp_memory_access_descriptor acc_desc[2];
+	struct sp_memory_region regions[2];
+	uint64_t handle;
+	bool supported;
+	struct ffa_mem_transaction_buffer tr_buffer;
+
+	static const sp_result result = -1;
+};
+
+TEST(mock_sp_memory_management, sp_memory_donate)
+{
+	descriptor = expected_descriptor;
+	acc_desc[0] = expected_acc_desc[0];
+	memcpy(regions, expected_regions, sizeof(regions));
+
+	expect_sp_memory_donate(&expected_descriptor, expected_acc_desc, expected_regions, 2,
+				&expected_handle, result);
+	LONGS_EQUAL(result, sp_memory_donate(&descriptor, acc_desc, regions, 2, &handle));
+
+	UNSIGNED_LONGLONGS_EQUAL(expected_handle, handle);
+}
+
+TEST(mock_sp_memory_management, sp_memory_donate_dynamic)
+{
+	descriptor = expected_descriptor;
+	acc_desc[0] = expected_acc_desc[0];
+	memcpy(regions, expected_regions, sizeof(regions));
+
+	expect_sp_memory_donate_dynamic(&expected_descriptor, expected_acc_desc, expected_regions,
+					2, &expected_handle, result);
+	LONGS_EQUAL(result, sp_memory_donate_dynamic(&descriptor, acc_desc, regions, 2, &handle,
+						     &tr_buffer));
+
+	UNSIGNED_LONGLONGS_EQUAL(expected_handle, handle);
+}
+
+TEST(mock_sp_memory_management, sp_memory_donate_dynamic_is_supported)
+{
+	const bool expected_supported = true;
+	expect_sp_memory_donate_dynamic_is_supported(&expected_supported, result);
+	LONGS_EQUAL(result, sp_memory_donate_dynamic_is_supported(&supported));
+	CHECK_TRUE(supported);
+}
+
+TEST(mock_sp_memory_management, sp_memory_lend)
+{
+	descriptor = expected_descriptor;
+	memcpy(acc_desc, expected_acc_desc, sizeof(acc_desc));
+	memcpy(regions, expected_regions, sizeof(regions));
+
+	expect_sp_memory_lend(&descriptor, acc_desc, 2, regions, 2, &expected_handle, result);
+	LONGS_EQUAL(result, sp_memory_lend(&descriptor, acc_desc, 2, regions, 2, &handle));
+	UNSIGNED_LONGLONGS_EQUAL(expected_handle, handle);
+}
+
+TEST(mock_sp_memory_management, sp_memory_lend_dynamic)
+{
+	descriptor = expected_descriptor;
+	memcpy(acc_desc, expected_acc_desc, sizeof(acc_desc));
+	memcpy(regions, expected_regions, sizeof(regions));
+
+	expect_sp_memory_lend_dynamic(&descriptor, acc_desc, 2, regions, 2, &expected_handle,
+				      result);
+	LONGS_EQUAL(result, sp_memory_lend_dynamic(&descriptor, acc_desc, 2, regions, 2, &handle,
+						   &tr_buffer));
+	UNSIGNED_LONGLONGS_EQUAL(expected_handle, handle);
+}
+
+TEST(mock_sp_memory_management, sp_memory_lend_dynamic_is_supported)
+{
+	const bool expected_supported = true;
+	expect_sp_memory_lend_dynamic_is_supported(&expected_supported, result);
+	LONGS_EQUAL(result, sp_memory_lend_dynamic_is_supported(&supported));
+	CHECK_TRUE(supported);
+}
+
+TEST(mock_sp_memory_management, sp_memory_share)
+{
+	descriptor = expected_descriptor;
+	memcpy(acc_desc, expected_acc_desc, sizeof(acc_desc));
+	memcpy(regions, expected_regions, sizeof(regions));
+
+	expect_sp_memory_share(&descriptor, acc_desc, 2, regions, 2, &expected_handle, result);
+	LONGS_EQUAL(result, sp_memory_share(&descriptor, acc_desc, 2, regions, 2, &handle));
+	UNSIGNED_LONGLONGS_EQUAL(expected_handle, handle);
+}
+
+TEST(mock_sp_memory_management, sp_memory_share_dynamic)
+{
+	descriptor = expected_descriptor;
+	memcpy(acc_desc, expected_acc_desc, sizeof(acc_desc));
+	memcpy(regions, expected_regions, sizeof(regions));
+
+	expect_sp_memory_share_dynamic(&descriptor, acc_desc, 2, regions, 2, &expected_handle,
+				      result);
+	LONGS_EQUAL(result, sp_memory_share_dynamic(&descriptor, acc_desc, 2, regions, 2, &handle,
+						   &tr_buffer));
+	UNSIGNED_LONGLONGS_EQUAL(expected_handle, handle);
+}
+
+TEST(mock_sp_memory_management, sp_memory_share_dynamic_is_supported)
+{
+	const bool expected_supported = true;
+	expect_sp_memory_share_dynamic_is_supported(&expected_supported, result);
+	LONGS_EQUAL(result, sp_memory_share_dynamic_is_supported(&supported));
+	CHECK_TRUE(supported);
+}
+
+TEST(mock_sp_memory_management, sp_memory_retrieve)
+{
+	const uint32_t expected_region_count = 1;
+	struct sp_memory_access_descriptor acc_desc = expected_acc_desc[0];
+	struct sp_memory_region region = expected_regions[0];
+	uint32_t out_region_count = 0;
+
+	descriptor = expected_descriptor;
+
+	expect_sp_memory_retrieve(&expected_descriptor, &expected_acc_desc[0],
+				  &expected_acc_desc[1], &expected_regions[0],
+				  &expected_regions[1], 1, &expected_region_count, expected_handle,
+				  result);
+	LONGS_EQUAL(result, sp_memory_retrieve(&descriptor, &acc_desc, &region, 1,
+					       &out_region_count, expected_handle));
+	MEMCMP_EQUAL(&acc_desc, &expected_acc_desc[1], sizeof(acc_desc));
+	MEMCMP_EQUAL(&region, &expected_regions[1], sizeof(region));
+	UNSIGNED_LONGS_EQUAL(expected_region_count, out_region_count);
+}
+
+TEST(mock_sp_memory_management, sp_memory_retrieve_dynamic)
+{
+	const uint32_t expected_region_count = 1;
+	struct sp_memory_access_descriptor acc_desc = expected_acc_desc[0];
+	struct sp_memory_region region = expected_regions[0];
+	uint32_t out_region_count = 0;
+
+	descriptor = expected_descriptor;
+
+	expect_sp_memory_retrieve_dynamic(&expected_descriptor, &expected_acc_desc[0],
+					  &expected_acc_desc[1], &expected_regions[0],
+					  &expected_regions[1], 1, &expected_region_count,
+					  expected_handle, result);
+	LONGS_EQUAL(result, sp_memory_retrieve_dynamic(&descriptor, &acc_desc, &region, 1,
+						       &out_region_count, expected_handle,
+						       &tr_buffer));
+	MEMCMP_EQUAL(&acc_desc, &expected_acc_desc[1], sizeof(acc_desc));
+	MEMCMP_EQUAL(&region, &expected_regions[1], sizeof(region));
+	UNSIGNED_LONGS_EQUAL(expected_region_count, out_region_count);
+}
+
+TEST(mock_sp_memory_management, sp_memory_retrieve_dynamic_is_supported)
+{
+	const bool expected_supported = true;
+	expect_sp_memory_retrieve_dynamic_is_supported(&expected_supported, result);
+	LONGS_EQUAL(result, sp_memory_retrieve_dynamic_is_supported(&supported));
+	CHECK_TRUE(supported);
+}
+
+TEST(mock_sp_memory_management, sp_memory_relinquish)
+{
+	uint16_t endpoints[3] = {1, 2, 3};
+	struct sp_memory_transaction_flags flags = {0}; // TODO: flags
+
+	expect_sp_memory_relinquish(expected_handle, endpoints, 3, &flags, result);
+	LONGS_EQUAL(result, sp_memory_relinquish(expected_handle, endpoints, 3, &flags));
+}
+
+TEST(mock_sp_memory_management, sp_memory_reclaim)
+{
+	uint32_t flags = 0xffffffff;
+
+	expect_sp_memory_reclaim(expected_handle, flags, result);
+	LONGS_EQUAL(result, sp_memory_reclaim(expected_handle, flags));
+}
+
+TEST(mock_sp_memory_management, sp_memory_permission_get)
+{
+	struct sp_mem_perm mem_perm;
+
+	memset(&mem_perm, 0x00, sizeof(mem_perm));
+
+	expect_sp_memory_permission_get(expected_address, &expected_mem_perm, result);
+	LONGS_EQUAL(result, sp_memory_permission_get(expected_address, &mem_perm));
+	MEMCMP_EQUAL(&expected_mem_perm, &mem_perm, sizeof(expected_mem_perm));
+}
+
+TEST(mock_sp_memory_management, sp_memory_permission_set)
+{
+	size_t size = 0x7654;
+
+	expect_sp_memory_permission_set(expected_address, size, &expected_mem_perm, result);
+	LONGS_EQUAL(result, sp_memory_permission_set(expected_address, size, &expected_mem_perm));
+}
diff --git a/components/messaging/ffa/libsp/tests.cmake b/components/messaging/ffa/libsp/tests.cmake
index 7b52248..63abb57 100644
--- a/components/messaging/ffa/libsp/tests.cmake
+++ b/components/messaging/ffa/libsp/tests.cmake
@@ -134,6 +134,19 @@ unit_test_add_suite(
 		-DARM64
 )
 
+unit_test_add_suite(
+	NAME libsp_mock_sp_memory_management
+	SOURCES
+		${CMAKE_CURRENT_LIST_DIR}/test/test_mock_sp_memory_management.cpp
+		${CMAKE_CURRENT_LIST_DIR}/mock/mock_sp_memory_management.cpp
+	INCLUDE_DIRECTORIES
+		${CMAKE_CURRENT_LIST_DIR}/include/
+		${CMAKE_CURRENT_LIST_DIR}/mock
+		${UNIT_TEST_PROJECT_PATH}/components/common/utils/include
+	COMPILE_DEFINITIONS
+		-DARM64
+)
+
 unit_test_add_suite(
 	NAME libsp_sp_memory_management_internals
 	SOURCES
-- 
2.17.1