test: cmocka: Add module tests for fast_get() and fast_put()

And simple module tests for fast_get and fast_put() implemented in
src/lib/fast-get/fast-get.c.

Signed-off-by: Jyri Sarha <jyri.sarha@linux.intel.com>

Author: Jyri Sarha

test/cmocka/src/lib/CMakeLists.txt

@@ -2,3 +2,4 @@
 
 add_subdirectory(alloc)
 add_subdirectory(lib)
+add_subdirectory(fast-get)

test/cmocka/src/lib/fast-get/CMakeLists.txt

@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+cmocka_test(fast-get-tests
+	fast-get-tests.c
+	${PROJECT_SOURCE_DIR}/zephyr/lib/fast-get.c
+	${PROJECT_SOURCE_DIR}/src/lib/alloc.c
+	${PROJECT_SOURCE_DIR}/src/platform/library/lib/memory.c
+	${PROJECT_SOURCE_DIR}/src/spinlock.c
+)
+
+target_link_libraries(fast-get-tests PRIVATE "-Wl,--wrap=rzalloc,--wrap=rmalloc,--wrap=rfree")

test/cmocka/src/lib/fast-get/fast-get-tests.c

@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: BSD-3-Clause
+//
+// Copyright(c) 2024 Intel Corporation. All rights reserved.
+//
+// Author: Jyri Sarha <jyri.sarha@linux.intel.com>
+
+#include <sof/lib/fast-get.h>
+#include <rtos/sof.h>
+#include <rtos/alloc.h>
+#include <sof/lib/mm_heap.h>
+#include <sof/lib/memory.h>
+#include <sof/common.h>
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <setjmp.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <cmocka.h>
+#include <assert.h>
+
+static const int testdata[33][100] = {
+	{
+	1, 2, 3, 4, 5, 6, 7, 9, 0,
+	1, 2, 3, 4, 5, 6, 7, 9, 0,
+	1, 2, 3, 4, 5, 6, 7, 9, 0,
+	1, 2, 3, 4, 5, 6, 7, 9, 0,
+	1, 2, 3, 4, 5, 6, 7, 9, 0,
+	1, 2, 3, 4, 5, 6, 7, 9, 0,
+	1, 2, 3, 4, 5, 6, 7, 9, 0,
+	1, 2, 3, 4, 5, 6, 7, 9, 0,
+	1, 2, 3, 4, 5, 6, 7, 9, 0,
+	1, 2, 3, 4, 5, 6, 7, 9, 0,
+	},
+	{ 2 },
+	{ 3 },
+	{ 4 },
+	{ 5 },
+	{ 6 },
+	{ 7 },
+	{ 8 },
+	{ 9 },
+	{ 10 },
+	{ 11 },
+	{ 12 },
+	{ 13 },
+	{ 14 },
+	{ 15 },
+	{ 16 },
+	{ 17 },
+	{ 18 },
+	{ 19 },
+	{ 20 },
+	{ 21 },
+	{ 23 },
+	{ 24 },
+	{ 25 },
+	{ 26 },
+	{ 27 },
+	{ 28 },
+	{ 29 },
+	{ 30 },
+	{ 31 },
+	{ 32 },
+	{ 33 },
+};
+
+static void test_simple_fast_get_put(void **state)
+{
+	const void *ret;
+
+	(void)state; /* unused */
+
+	ret = fast_get(testdata[0], sizeof(testdata[0]));
+
+	assert(ret);
+	assert(!memcmp(ret, testdata[0], sizeof(testdata[0])));
+
+	fast_put(ret);
+}
+
+static void test_fast_get_size_missmatch_test(void **state)
+{
+	const void *ret[2];
+
+	(void)state; /* unused */
+
+	ret[0] = fast_get(testdata[0], sizeof(testdata[0]));
+
+	assert(ret[0]);
+	assert(!memcmp(ret[0], testdata[0], sizeof(testdata[0])));
+
+	ret[1] = fast_get(testdata[0], sizeof(testdata[0]) + 1);
+	assert(!ret[1]);
+
+	fast_put(ret);
+}
+
+static void test_over_32_fast_gets_and_puts(void **state)
+{
+	const void *copy[ARRAY_SIZE(testdata)];
+	int i;
+
+	(void)state; /* unused */
+
+	for (i = 0; i < ARRAY_SIZE(copy); i++)
+		copy[i] = fast_get(testdata[i], sizeof(testdata[0]));
+
+	for (i = 0; i < ARRAY_SIZE(copy); i++)
+		assert(!memcmp(copy[i], testdata[i], sizeof(testdata[0])));
+
+	for (i = 0; i < ARRAY_SIZE(copy); i++)
+		fast_put(copy[i]);
+}
+
+static void test_fast_get_refcounting(void **state)
+{
+	const void *copy[2][ARRAY_SIZE(testdata)];
+	int i;
+	(void)state; /* unused */
+
+	for (i = 0; i < ARRAY_SIZE(copy[0]); i++)
+		copy[0][i] = fast_get(testdata[i], sizeof(testdata[0]));
+
+	for (i = 0; i < ARRAY_SIZE(copy[0]); i++)
+		copy[1][i] = fast_get(testdata[i], sizeof(testdata[0]));
+
+	for (i = 0; i < ARRAY_SIZE(copy[0]); i++)
+		assert(copy[0][i] == copy[1][i]);
+
+	for (i = 0; i < ARRAY_SIZE(copy[0]); i++)
+		assert(!memcmp(copy[0][i], testdata[i], sizeof(testdata[0])));
+
+	for (i = 0; i < ARRAY_SIZE(copy[0]); i++)
+		fast_put(copy[0][i]);
+
+	for (i = 0; i < ARRAY_SIZE(copy[0]); i++)
+		assert(!memcmp(copy[1][i], testdata[i], sizeof(testdata[0])));
+
+	for (i = 0; i < ARRAY_SIZE(copy[0]); i++)
+		fast_put(copy[1][i]);
+}
+
+int main(void)
+{
+	const struct CMUnitTest tests[] = {
+		cmocka_unit_test(test_simple_fast_get_put),
+		cmocka_unit_test(test_fast_get_size_missmatch_test),
+		cmocka_unit_test(test_over_32_fast_gets_and_puts),
+		cmocka_unit_test(test_fast_get_refcounting),
+	};
+
+	cmocka_set_message_output(CM_OUTPUT_TAP);
+
+	return cmocka_run_group_tests(tests, NULL, NULL);
+}
+
+void *__wrap_rzalloc(enum mem_zone zone, uint32_t flags, uint32_t caps, size_t bytes);
+void *__wrap_rmalloc(enum mem_zone zone, uint32_t flags, uint32_t caps, size_t bytes);
+void __wrap_rfree(void *ptr);
+
+void *__wrap_rzalloc(enum mem_zone zone, uint32_t flags, uint32_t caps, size_t bytes)
+{
+	void *ret;
+	(void)zone;
+	(void)flags;
+	(void)caps;
+
+	ret = malloc(bytes);
+
+	assert(ret);
+
+	memset(ret, 0, bytes);
+
+	return ret;
+}
+
+void *__wrap_rmalloc(enum mem_zone zone, uint32_t flags, uint32_t caps, size_t bytes)
+{
+	void *ret;
+	(void)zone;
+	(void)flags;
+	(void)caps;
+
+	ret = malloc(bytes);
+
+	assert(ret);
+
+	return ret;
+}
+
+void __wrap_rfree(void *ptr)
+{
+	free(ptr);
+}