/* SPDX-License-Identifier: GPL-2.0-only */

/*
 * Include Unit Under Test source code directly instead of linking it.
 * This will allow access to internal structures and data without having
 * to extract them to another header file.
 */
#include "../lib/imd_cbmem.c"

#include <tests/test.h>
#include <stdlib.h>
#include <string.h>
#include <commonlib/bsd/helpers.h>
#include <imd.h>
#include <cbmem.h>
#include <imd_private.h>

#include <tests/lib/imd_cbmem_data.h>

#define CBMEM_ENTRY_ID 0xA001

static void reset_imd(void)
{
	imd.lg.limit = (uintptr_t)NULL;
	imd.lg.r = NULL;
	imd.sm.limit = (uintptr_t)NULL;
	imd.sm.r = NULL;

	cbmem_initialized = 0;
}

/* This implementation allows imd_cbmem module tests without linking lib/cbmem_common.c
   Function indicates to each hook if cbmem is being recovered or not. */
void cbmem_run_init_hooks(int is_recovery)
{
	function_called();
}

uintptr_t cbmem_top_chipset(void)
{
	return _cbmem_top_ptr;
}

static void *get_cbmem_ptr(void)
{
	void *cbmem_top_ptr = (void *)_cbmem_top_ptr;
	if (cbmem_top_ptr)
		return cbmem_top_ptr - CBMEM_SIZE;
	else
		return NULL;
}

static void clear_cbmem(void)
{
	void *ptr = get_cbmem_ptr();
	if (ptr)
		memset(ptr, 0, CBMEM_SIZE);
}

static void reset_and_clear_cbmem(void)
{
	reset_imd();
	clear_cbmem();
}

void prepare_simple_cbmem(void)
{
	reset_and_clear_cbmem();

	expect_function_call(cbmem_run_init_hooks);
	cbmem_initialize_empty();

	cbmem_entry_add(CBMEM_ENTRY_1_ID, CBMEM_ENTRY_1_SIZE);
	cbmem_entry_add(CBMEM_ENTRY_2_ID, CBMEM_ENTRY_2_SIZE);

	cbmem_entry_add(CBMEM_ENTRY_SM_1_ID, CBMEM_ENTRY_SM_1_SIZE);
	cbmem_entry_add(CBMEM_ENTRY_SM_2_ID, CBMEM_ENTRY_SM_2_SIZE);
}

static void test_cbmem_top(void **state)
{
	cbmem_top_init_once();

	if (ENV_ROMSTAGE)
		assert_ptr_equal(cbmem_top_chipset(), cbmem_top());

	if (ENV_POSTCAR || ENV_RAMSTAGE)
		assert_ptr_equal((void *)_cbmem_top_ptr, cbmem_top());
}

static void test_cbmem_initialize_empty(void **state)
{
	const struct cbmem_entry *found;

	/* Expect clean call without recovery */
	expect_function_call(cbmem_run_init_hooks);
	cbmem_initialize_empty();

	found = cbmem_entry_find(SMALL_REGION_ID);
	assert_non_null(found);
	/* Check that cbmem has only root, large and small entry. */
	assert_int_equal(2, ((struct imd_root *)imd.lg.r)->num_entries);
	assert_int_equal(1, ((struct imd_root *)imd.sm.r)->num_entries);
}

static void test_cbmem_initialize_empty_id_size(void **state)
{
	const struct cbmem_entry *entry1, *entry2;

	expect_function_call(cbmem_run_init_hooks);
	cbmem_initialize_empty_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);

	entry1 = cbmem_entry_find(SMALL_REGION_ID);
	entry2 = cbmem_entry_find(CBMEM_ENTRY_ID);

	assert_non_null(entry1);
	assert_non_null(entry2);
	assert_ptr_not_equal(entry1, entry2);
	/* Check that cbmem has root, large, small entries
	   and entry with id passed to init function. */
	assert_int_equal(3, ((struct imd_root *)imd.lg.r)->num_entries);
	assert_int_equal(1, ((struct imd_root *)imd.sm.r)->num_entries);
}

static void test_cbmem_initialize(void **state)
{
	int res;

	/* Expect call to fail as there is no previous cbmem to recover */
	res = cbmem_initialize();
	assert_int_equal(1, res);

	/* Create cbmem with few entries and check if initialization will recover */
	prepare_simple_cbmem();
	reset_imd();
	expect_function_call(cbmem_run_init_hooks);
	res = cbmem_initialize();
	assert_int_equal(0, res);
}

void test_cbmem_initialize_id_size_ramstage(void **state)
{
	int res;
	const struct cbmem_entry *entry1, *entry2;

	/* Expect call to fail as there is no previous cbmem to recover */
	res = cbmem_initialize_id_size(0, 0);
	assert_int_equal(1, res);

	reset_and_clear_cbmem();

	res = cbmem_initialize_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);
	assert_int_equal(1, res);

	/* Initialize empty cbmem with small region and check if next initialization
	   correctly recovers and creates its root entry with small region */
	expect_function_call(cbmem_run_init_hooks);
	cbmem_initialize_empty_id_size(0, 0);
	expect_function_call(cbmem_run_init_hooks);
	res = cbmem_initialize_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);
	assert_int_equal(0, res);

	entry1 = cbmem_entry_find(SMALL_REGION_ID);
	entry2 = cbmem_entry_find(CBMEM_ENTRY_ID);
	assert_non_null(entry1);
	assert_non_null(entry2);
	assert_ptr_not_equal(entry1, entry2);
	/* Check that cbmem has root, large, small entries and entry with id passed
	   to init function. */
	assert_int_equal(3, ((struct imd_root *)imd.lg.r)->num_entries);
	assert_int_equal(1, ((struct imd_root *)imd.sm.r)->num_entries);
}

void test_cbmem_initialize_id_size_romstage(void **state)
{
	int res;
	const struct cbmem_entry *entry1, *entry2;

	/* Expect call to fail as there is no previous cbmem to recover */
	res = cbmem_initialize_id_size(0, 0);
	assert_int_equal(1, res);

	/* Initialize empty cbmem with small region and check if next initialization
	   correctly recovers and creates its root entry with small region */
	expect_function_call(cbmem_run_init_hooks);
	cbmem_initialize_empty_id_size(0, 0);
	expect_function_call(cbmem_run_init_hooks);
	res = cbmem_initialize_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);
	assert_int_equal(0, res);

	entry1 = cbmem_entry_find(SMALL_REGION_ID);
	assert_non_null(entry1);

	/* Romstage locks imd cbmem initialization after recovery,
	   so entry with CBMEM_ENTRY_ID id is not present if it was not recovered. */
	entry2 = cbmem_entry_find(CBMEM_ENTRY_ID);
	assert_null(entry2);

	/* Initialize cbmem with few large and small entries */
	prepare_simple_cbmem();

	assert_non_null(cbmem_entry_find(CBMEM_ENTRY_1_ID));
	assert_non_null(cbmem_entry_find(CBMEM_ENTRY_2_ID));
	assert_non_null(cbmem_entry_find(CBMEM_ENTRY_SM_1_ID));
	assert_non_null(cbmem_entry_find(CBMEM_ENTRY_SM_2_ID));

	reset_imd();

	expect_function_call(cbmem_run_init_hooks);
	res = cbmem_initialize_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);
	assert_int_equal(0, res);

	/* Initialization function should be able to recover entries left in cbmem
	   while having imd structure clean */
	entry1 = cbmem_entry_find(SMALL_REGION_ID);
	assert_non_null(entry1);
	assert_non_null(cbmem_entry_find(CBMEM_ENTRY_1_ID));
	assert_non_null(cbmem_entry_find(CBMEM_ENTRY_2_ID));
	assert_non_null(cbmem_entry_find(CBMEM_ENTRY_SM_1_ID));
	assert_non_null(cbmem_entry_find(CBMEM_ENTRY_SM_2_ID));
}

static void test_cbmem_recovery(void **state)
{
	int is_wakeup = 1;

	/* Reset imd, initialize cbmem and add entries for recovery */
	prepare_simple_cbmem();
	expect_function_call(cbmem_run_init_hooks);
	assert_int_equal(0, cbmem_recovery(is_wakeup));

	/* Check that entries have been correctly recovered */
	assert_non_null(cbmem_entry_find(CBMEM_ENTRY_1_ID));
	assert_non_null(cbmem_entry_find(CBMEM_ENTRY_2_ID));
	assert_non_null(cbmem_entry_find(CBMEM_ENTRY_SM_1_ID));
	assert_non_null(cbmem_entry_find(CBMEM_ENTRY_SM_2_ID));

	is_wakeup = 0;
	expect_function_call(cbmem_run_init_hooks);
	assert_int_equal(0, cbmem_recovery(is_wakeup));

	/* Check that after recovery with is_wakeup equal to 0 the cbmem is empty
	   and in initial state. */
	assert_null(cbmem_entry_find(CBMEM_ENTRY_1_ID));
	assert_null(cbmem_entry_find(CBMEM_ENTRY_2_ID));
	assert_null(cbmem_entry_find(CBMEM_ENTRY_SM_1_ID));
	assert_null(cbmem_entry_find(CBMEM_ENTRY_SM_2_ID));
	/* Check that cbmem has root, large and small entry. */
	assert_int_equal(2, ((struct imd_root *)imd.lg.r)->num_entries);
	assert_int_equal(1, ((struct imd_root *)imd.sm.r)->num_entries);
}

static void test_cbmem_entry_add(void **state)
{
	/* IDs used for testing. Don't have to be sequential.
	   Must not be equal to SMALL_REGION_ID. */
	const int id1 = 0x10;
	const int id2 = 0x11;
	const int id3 = 0x12;
	const struct cbmem_entry *entry1, *entry2;
	const struct cbmem_entry *entry_ret2, *entry_ret3;

	/* cbmem_run_init_hooks() will be called by init functions
	   but this test does not aim to check it */
	ignore_function_calls(cbmem_run_init_hooks);

	cbmem_initialize_empty_id_size(id1, CBMEM_ROOT_SIZE);

	/* Expect NULL while looking for nonexistent entries */
	assert_null(cbmem_entry_find(id2));
	assert_null(cbmem_entry_find(id3));

	entry_ret2 = cbmem_entry_add(id2, CBMEM_ROOT_SIZE);
	/* Expect error when trying to add entry with zero size */
	assert_null(cbmem_entry_add(id3, 0));

	/* Check if entries have been added correctly and are not the same */
	entry1 = cbmem_entry_find(id1);
	entry2 = cbmem_entry_find(id2);
	assert_non_null(entry1);
	assert_non_null(entry2);
	assert_ptr_not_equal(entry1, entry2);
	assert_ptr_equal(entry_ret2, entry2);

	/* Add entry again and make sure that it has been
	   found instead of creating again. */
	entry_ret3 = cbmem_entry_add(id2, CBMEM_ROOT_SIZE / 2);
	assert_ptr_equal(entry_ret2, entry_ret3);
}

static void test_cbmem_add(void **state)
{
	const int id0 = 0x55;
	const int id1 = 0x66;
	const int id2 = 0x77;
	const int id3 = 0x88;
	const int entry1_size = 0x2000;
	const int entry2_size = 0x4d1;
	const int entry3_size = 0x30;
	void *entry1, *entry2, *entry3, *entry4;

	ignore_function_calls(cbmem_run_init_hooks);

	cbmem_initialize_empty_id_size(id1, entry1_size);
	entry2 = cbmem_add(id2, entry2_size);
	entry3 = cbmem_add(id3, entry3_size);
	entry1 = cbmem_find(id1);

	/* All pointers should be non-null and distinct. */
	assert_non_null(entry1);
	assert_non_null(entry2);
	assert_non_null(entry3);
	assert_ptr_not_equal(entry1, entry2);
	assert_ptr_not_equal(entry1, entry3);
	assert_ptr_not_equal(entry2, entry3);

	/* Adding the same ID should yield the same entry pointer. */
	entry4 = cbmem_add(id2, entry2_size);
	assert_ptr_equal(entry2, entry4);

	/* Expect error while trying to add range with zero size */
	assert_null(cbmem_add(id0, 0));
}

static void test_cbmem_entry_find(void **state)
{
	const int id1 = 0xA0;
	const int id2 = 0xDD;
	const int id3 = 0xBD;
	const size_t entry1_size = CBMEM_ROOT_SIZE;
	const size_t entry2_size = CBMEM_ROOT_SIZE / 2;
	const size_t entry3_size = 6321;
	const struct cbmem_entry *cbm_e1, *cbm_e2, *cbm_e3;
	const struct cbmem_entry *entry1, *entry2, *entry3;

	ignore_function_calls(cbmem_run_init_hooks);

	cbmem_initialize_empty();
	cbm_e1 = cbmem_entry_add(id1, entry1_size);
	cbm_e2 = cbmem_entry_add(id2, entry2_size);
	cbm_e3 = cbmem_entry_add(id3, entry3_size);

	/* Check pointers correctness and size for each entry */
	entry1 = cbmem_entry_find(id1);
	assert_ptr_equal(cbm_e1, entry1);
	assert_int_equal(0, (uintptr_t)cbmem_entry_start(cbm_e1) % CBMEM_SM_ALIGN);
	assert_int_equal(entry1_size, cbmem_entry_size(entry1));

	entry2 = cbmem_entry_find(id2);
	assert_ptr_equal(cbm_e2, entry2);
	assert_int_equal(0, (uintptr_t)cbmem_entry_start(cbm_e2) % CBMEM_SM_ALIGN);
	assert_int_equal(entry2_size, cbmem_entry_size(entry2));

	entry3 = cbmem_entry_find(id3);
	assert_ptr_equal(cbm_e3, entry3);
	assert_int_equal(0, (uintptr_t)cbmem_entry_start(cbm_e3) % CBMEM_SM_ALIGN);
	assert_int_equal(entry3_size, cbmem_entry_size(entry3));
}

static void test_cbmem_find(void **state)
{
	const int id1 = 0x30;
	const int id2 = 0x22;
	const int id3 = 0x101;
	void *cbm_e1, *cbm_e2, *entry1, *entry2;

	ignore_function_calls(cbmem_run_init_hooks);

	cbmem_initialize_empty();
	cbm_e1 = cbmem_add(id1, CBMEM_ROOT_SIZE);
	cbm_e2 = cbmem_add(id2, CBMEM_ROOT_SIZE);

	entry1 = cbmem_find(id1);
	assert_non_null(entry1);
	assert_ptr_equal(cbm_e1, entry1);

	entry2 = cbmem_find(id2);
	assert_non_null(entry2);
	assert_ptr_equal(cbm_e2, entry2);

	/* Expect error when looking for non-existent id */
	assert_null(cbmem_find(id3));
}

static void test_cbmem_entry_remove(void **state)
{
	const int id1 = 0x2D;
	const int id2 = 0x3D;
	const int id3 = 0x4D;
	const struct cbmem_entry *cbm_e1, *cbm_e2;

	ignore_function_calls(cbmem_run_init_hooks);

	cbmem_initialize_empty();
	cbm_e1 = cbmem_entry_add(id1, CBMEM_ROOT_SIZE);
	cbm_e2 = cbmem_entry_add(id2, CBMEM_ROOT_SIZE);

	/* Entries can be removed only in reverse order they have been added. */
	assert_int_equal(-1, cbmem_entry_remove(cbm_e1));
	assert_int_equal(0, cbmem_entry_remove(cbm_e2));
	assert_int_equal(0, cbmem_entry_remove(cbm_e1));

	/* Expect error when removing non-existent entry */
	assert_int_equal(-1, cbmem_entry_remove(cbmem_entry_find(id3)));
}

static void test_cbmem_entry_size(void **state)
{
	const int id1 = 0x4422;
	const int id2 = 0x2137;
	const int id3 = 0xb111;
	const size_t size1 = CBMEM_ROOT_SIZE * 4;
	const size_t size2 = 0x43;
	const size_t size3 = CBMEM_ROOT_SIZE * 8 + 7;

	ignore_function_calls(cbmem_run_init_hooks);

	cbmem_initialize_empty_id_size(id1, size1);
	assert_non_null(cbmem_entry_add(id2, size2));
	assert_non_null(cbmem_entry_add(id3, size3));

	/* Entry size needs not to be aligned.
	   It has to be the same as provided while adding it. */
	assert_int_equal(size1, cbmem_entry_size(cbmem_entry_find(id1)));
	assert_int_equal(size2, cbmem_entry_size(cbmem_entry_find(id2)));
	assert_int_equal(size3, cbmem_entry_size(cbmem_entry_find(id3)));
}

static void test_cbmem_entry_start(void **state)
{
	const int id1 = 0x62;
	const int id2 = 0x26;

	ignore_function_calls(cbmem_run_init_hooks);

	cbmem_initialize_empty_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);
	cbmem_entry_find(CBMEM_ENTRY_ID);
	cbmem_entry_add(id1, 0x40);
	cbmem_entry_add(id2, CBMEM_ROOT_SIZE * 2);

	/* Check if start address of found entry is the same
	   as the one returned by cbmem_find() function */
	assert_ptr_equal(cbmem_find(CBMEM_ENTRY_ID),
			 cbmem_entry_start(cbmem_entry_find(CBMEM_ENTRY_ID)));
	assert_ptr_equal(cbmem_find(id1), cbmem_entry_start(cbmem_entry_find(id1)));
	assert_ptr_equal(cbmem_find(id2), cbmem_entry_start(cbmem_entry_find(id2)));
}

/* Reimplementation for testing purposes */
void bootmem_add_range(uint64_t start, uint64_t size, const enum bootmem_type tag)
{
	check_expected(start);
	check_expected(size);
	check_expected(tag);
}

static void test_cbmem_add_bootmem(void **state)
{
	void *base_ptr = NULL;
	size_t size = 0;
	const int id1 = 0xCA;
	const int id2 = 0xEA;
	const int id3 = 0xDA;
	const size_t size1 = 1024;
	const size_t size2 = 128;
	const size_t size3 = 8192;

	ignore_function_calls(cbmem_run_init_hooks);

	cbmem_initialize_empty_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);
	cbmem_entry_add(id1, size1);
	cbmem_entry_add(id2, size2);
	cbmem_entry_add(id3, size3);

	cbmem_get_region(&base_ptr, &size);
	assert_int_equal(ALIGN_DOWN(_cbmem_top_ptr, LIMIT_ALIGN), base_ptr + size);

	expect_value(bootmem_add_range, start, base_ptr);
	expect_value(bootmem_add_range, size, size);
	expect_value(bootmem_add_range, tag, BM_MEM_TABLE);
	cbmem_add_bootmem();

	/* Check that adding bootmem does not change base or size of cbmem */
	cbmem_get_region(&base_ptr, &size);
	assert_int_equal(ALIGN_DOWN(_cbmem_top_ptr, LIMIT_ALIGN), base_ptr + size);
}

static void test_cbmem_get_region(void **state)
{
	int i;
	void *base_ptr = NULL;
	size_t size = 0;
	size_t size_counter = 0;
	const size_t entry_size = 0x2000;
	const size_t alloc_num = 32;
	const size_t small_entry_size = 64;
	const size_t small_alloc_num = 3;

	ignore_function_calls(cbmem_run_init_hooks);

	cbmem_initialize_empty_id_size(CBMEM_ENTRY_ID, CBMEM_ROOT_SIZE);

	/* Check size and base pointer for empty initialized cbmem */
	cbmem_get_region(&base_ptr, &size);
	assert_non_null(base_ptr);
	assert_int_not_equal(0, size);
	assert_int_equal(CBMEM_ROOT_SIZE + cbmem_overhead_size(), size);
	assert_int_equal(ALIGN_DOWN(_cbmem_top_ptr, LIMIT_ALIGN), base_ptr + size);

	/* Check for multiple big allocations */
	for (i = 1; i <= alloc_num; ++i) {
		const struct cbmem_entry *e = cbmem_entry_add(i, entry_size);
		assert_non_null(e);
		size_counter += cbmem_entry_size(e);

		/* Check if size is correct after each big allocation */
		cbmem_get_region(&base_ptr, &size);
		assert_int_equal(size_counter + cbmem_overhead_size() + CBMEM_ROOT_SIZE, size);
	}

	/* Check for few small allocations. */
	for (; i <= alloc_num + small_alloc_num; ++i) {
		const struct cbmem_entry *e = cbmem_entry_add(i, small_entry_size);
		assert_non_null(e);

		/* Check if size is correct after each small allocation. It should not change
		   as small entries have their region allocated and entry size is selected
		   to fit in it couple of times */
		cbmem_get_region(&base_ptr, &size);
		assert_int_equal(size_counter + cbmem_overhead_size() + CBMEM_ROOT_SIZE, size);
	}
}

static void test_general_data_structure(void **state)
{
	/* Initialize cbmem with few big and small entries, then check if binary data structure
	   is the same as stored in array containing hardcoded dumped cbmem */
	prepare_simple_cbmem();
	assert_memory_equal(get_cbmem_ptr(), test_cbmem_data, CBMEM_SIZE);
}

static int setup_teardown_test_imd_cbmem(void **state)
{
	reset_and_clear_cbmem();
	return 0;
}

static int setup_group_imd_cbmem(void **state)
{
	/* Allocate more data to have space for alignment */
	void *top_ptr = malloc(CBMEM_SIZE + DYN_CBMEM_ALIGN_SIZE);

	if (!top_ptr)
		return -1;

	*state = top_ptr;

	_cbmem_top_ptr = ALIGN_UP((uintptr_t)top_ptr + CBMEM_SIZE, DYN_CBMEM_ALIGN_SIZE);
	return 0;
}

static int teardown_group_imd_cbmem(void **state)
{
	reset_imd();
	free(*state);
	return 0;
}

int main(void)
{
	const struct CMUnitTest tests[] = {
		cmocka_unit_test_setup_teardown(test_cbmem_top,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
		cmocka_unit_test_setup_teardown(test_cbmem_initialize_empty,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
		cmocka_unit_test_setup_teardown(test_cbmem_initialize_empty_id_size,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
		cmocka_unit_test_setup_teardown(test_cbmem_initialize,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
#if ENV_ROMSTAGE_OR_BEFORE
		cmocka_unit_test_setup_teardown(test_cbmem_initialize_id_size_romstage,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
#else
		cmocka_unit_test_setup_teardown(test_cbmem_initialize_id_size_ramstage,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
#endif
		cmocka_unit_test_setup_teardown(test_cbmem_recovery,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
		cmocka_unit_test_setup_teardown(test_cbmem_entry_add,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
		cmocka_unit_test_setup_teardown(test_cbmem_add,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
		cmocka_unit_test_setup_teardown(test_cbmem_entry_find,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
		cmocka_unit_test_setup_teardown(test_cbmem_find,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
		cmocka_unit_test_setup_teardown(test_cbmem_entry_remove,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
		cmocka_unit_test_setup_teardown(test_cbmem_entry_size,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
		cmocka_unit_test_setup_teardown(test_cbmem_entry_start,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
		cmocka_unit_test_setup_teardown(test_cbmem_add_bootmem,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
		cmocka_unit_test_setup_teardown(test_cbmem_get_region,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
		cmocka_unit_test_setup_teardown(test_general_data_structure,
				setup_teardown_test_imd_cbmem,
				setup_teardown_test_imd_cbmem),
	};

	return cb_run_group_tests(tests, setup_group_imd_cbmem, teardown_group_imd_cbmem);
}