Skip to content

Commit 3ff3b61

Browse files
mrajwatlauda
mrajwa
authored and
tlauda
committed
CMOCKA: removed old memory allocation in testcases of KPB
The KPB component has changed its buffering algorithm therefore its test cases needs to be changed accordingly. Signed-off-by: Marcin Rajwa <marcin.rajwa@linux.intel.com>
1 parent a98e3f8 commit 3ff3b61

2 files changed

Lines changed: 60 additions & 214 deletions

File tree

‎test/cmocka/src/audio/kpb/CMakeLists.txt‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
cmocka_test(kpb
2+
${PROJECT_SOURCE_DIR}/src/audio/kpb.c
23
kpb_buffer.c
34
kpb_mock.c
4-
${PROJECT_SOURCE_DIR}/src/audio/kpb.c
55
${PROJECT_SOURCE_DIR}/src/audio/buffer.c
66
#${PROJECT_SOURCE_DIR}/src/audio/component.c
77
)

‎test/cmocka/src/audio/kpb/kpb_buffer.c‎

Lines changed: 59 additions & 213 deletions
Original file line numberDiff line numberDiff line change
@@ -45,184 +45,94 @@
4545
#include "kpb_mock.h"
4646
#include <sof/list.h>
4747

48-
/* local data types */
49-
enum kpb_test_type {
50-
KPB_TEST_COPY_TWO_BUFFERS = 0,
51-
KPB_TEST_COPY_ONE_BUFFER,
52-
};
53-
48+
/*! Local data types */
5449
enum kpb_test_buff_type {
5550
KPB_SOURCE_BUFFER = 0,
5651
KPB_SINK_BUFFER,
5752
};
5853

54+
/*! Parameters for test case */
5955
struct test_case {
60-
enum kpb_test_type type;
6156
int no_buffers;
6257
int lp_buff_size;
6358
int hp_buff_size;
6459
int source_period_bytes;
6560
int sink_period_bytes;
6661
};
6762

68-
/* dummy component driver & device */
63+
/* Dummy IPC structure, used to create KPB component */
64+
struct sof_ipc_comp_kpb_mock {
65+
struct sof_ipc_comp comp;
66+
struct sof_ipc_comp_config config;
67+
uint32_t size; /**< size of bespoke data section in bytes */
68+
uint32_t type; /**< sof_ipc_effect_type */
69+
70+
/* reserved for future use */
71+
uint32_t reserved[7];
72+
/* sof_kpb_config */
73+
uint32_t not_used; /**< kpb size in bytes */
74+
uint32_t caps; /**< SOF_MEM_CAPS_ */
75+
uint32_t no_channels; /**< no of channels */
76+
uint32_t history_depth; /**< time of buffering in milliseconds */
77+
uint32_t sampling_freq; /**< frequency in hertz */
78+
uint32_t sampling_width; /**< number of bits */
79+
};
80+
81+
/* Dummy component driver & device */
6982
struct comp_driver kpb_drv_mock;
7083
struct comp_dev *kpb_dev_mock;
7184
struct comp_buffer *source;
7285
struct comp_buffer *sink;
7386

74-
/* dummy memory buffers and data pointers */
87+
/* Dummy memory buffers and data pointers */
7588
void *source_data;
7689
void *sink_data;
7790
void *his_buf_lp;
7891
void *his_buf_hp;
7992

80-
/* local function declarations */
81-
static struct comp_buffer *mock_comp_buffer(void **state,
82-
enum kpb_test_buff_type buff_type);
83-
static struct kpb_comp_data *mock_comp_kpb(void **state, void *hp_buf,
84-
void *lp_buf);
85-
static struct comp_dev *mock_comp_dev(void);
86-
93+
/* Initialize KPB for test */
8794
static int buffering_test_setup(void **state)
8895
{
89-
struct test_case *test_case_data = (struct test_case *)*state;
90-
int lp_buff_size = test_case_data->lp_buff_size;
91-
int hp_buff_size = test_case_data->hp_buff_size;
92-
int entire_buff_size = hp_buff_size + lp_buff_size;
93-
/* allocate memory for components */
94-
if (test_case_data->no_buffers == 2) {
95-
his_buf_lp = test_malloc(lp_buff_size);
96-
his_buf_hp = test_malloc(hp_buff_size);
97-
} else if (test_case_data->type == KPB_TEST_COPY_ONE_BUFFER) {
98-
his_buf_hp = test_malloc(hp_buff_size);
99-
} else {
100-
return -1;
101-
}
96+
(void)state;
97+
98+
/* Dummy IPC structue to create new KPB component */
99+
struct sof_ipc_comp_kpb_mock kpb = {
100+
.comp = {
101+
.type = SOF_COMP_KPB,
102+
},
103+
.config = {
104+
.hdr = {
105+
.size = sizeof(struct sof_ipc_comp_config),
106+
},
107+
},
108+
.size = sizeof(struct sof_kpb_config),
109+
.no_channels = 2,
110+
.sampling_freq = KPB_SAMPLNG_FREQUENCY,
111+
.sampling_width = KPB_SAMPLING_WIDTH,
112+
};
102113

103-
source_data = test_malloc(entire_buff_size);
104-
sink_data = test_malloc(entire_buff_size);
105-
kpb_dev_mock = mock_comp_dev();
114+
/* Register KPB component to use its internal functions */
115+
sys_comp_kpb_init();
106116

107-
/* create mocks */
108-
kpb_dev_mock->private = mock_comp_kpb(state, his_buf_hp, his_buf_lp);
109-
source = mock_comp_buffer(state, KPB_SOURCE_BUFFER);
110-
sink = mock_comp_buffer(state, KPB_SINK_BUFFER);
117+
/* Create KPB component */
118+
kpb_dev_mock = kpb_drv_mock.ops.new((struct sof_ipc_comp *)&kpb);
111119

112-
/* mount coponents for test */
113-
source->source = kpb_dev_mock;
114-
source->sink = kpb_dev_mock;
115-
source->r_ptr = source_data;
116-
sink->w_ptr = sink_data;
117-
kpb_dev_mock->bsource_list.next = &source->sink_list;
118-
kpb_dev_mock->bsink_list.next = &sink->source_list;
119-
((struct kpb_comp_data *)kpb_dev_mock->private)->rt_sink = sink;
120+
/* Was device created properly? */
121+
assert_non_null(kpb_dev_mock);
122+
/* Verify if config was properly set */
123+
assert_int_equal(((struct comp_data *)
124+
kpb_dev_mock->private)->config.sampling_freq,
125+
KPB_SAMPLNG_FREQUENCY);
120126

121127
return 0;
122128
}
123129

124130
static int buffering_test_teardown(void **state)
125131
{
126-
/* free components memory */
127-
struct test_case *test_case_data = (struct test_case *)*state;
128-
struct kpb_comp_data *cd = comp_get_drvdata(kpb_dev_mock);
129-
130-
test_free(cd);
131-
test_free(source_data);
132-
test_free(sink_data);
133-
test_free(source);
134-
test_free(sink);
135-
136-
if (test_case_data->type == KPB_TEST_COPY_TWO_BUFFERS) {
137-
test_free(his_buf_lp);
138-
test_free(his_buf_hp);
139-
} else if (test_case_data->type == KPB_TEST_COPY_ONE_BUFFER) {
140-
test_free(his_buf_hp);
141-
} else {
142-
return -1;
143-
}
144-
145-
test_free(kpb_dev_mock);
146132
return 0;
147133
}
148134

149-
static struct comp_dev *mock_comp_dev(void)
150-
{
151-
struct comp_dev *dev = test_malloc(sizeof(struct comp_dev));
152-
153-
dev->is_dma_connected = 0;
154-
return dev;
155-
}
156-
157-
static struct kpb_comp_data *mock_comp_kpb(void **state, void *hp_buf,
158-
void *lp_buf)
159-
{
160-
struct kpb_comp_data *kpb = test_malloc(sizeof(struct kpb_comp_data));
161-
struct test_case *test_case_data = (struct test_case *)*state;
162-
163-
kpb->source_period_bytes = test_case_data->source_period_bytes;
164-
kpb->sink_period_bytes = test_case_data->sink_period_bytes;
165-
166-
if (test_case_data->type == KPB_TEST_COPY_TWO_BUFFERS) {
167-
int lp_buff_size = test_case_data->lp_buff_size;
168-
int hp_buff_size = test_case_data->hp_buff_size;
169-
/* LPSRAM buffer init */
170-
kpb->his_buf_lp.id = KPB_LP;
171-
kpb->his_buf_lp.state = KPB_BUFFER_FREE;
172-
kpb->his_buf_lp.w_ptr = lp_buf;
173-
kpb->his_buf_lp.end_addr = kpb->his_buf_lp.w_ptr + lp_buff_size;
174-
kpb->his_buf_lp.sta_addr = lp_buf;
175-
/* HPSRAM buffer init */
176-
kpb->his_buf_hp.id = KPB_HP;
177-
kpb->his_buf_hp.state = KPB_BUFFER_FREE;
178-
kpb->his_buf_hp.w_ptr = hp_buf;
179-
kpb->his_buf_hp.end_addr = kpb->his_buf_hp.w_ptr + hp_buff_size;
180-
kpb->his_buf_hp.sta_addr = hp_buf;
181-
} else if (test_case_data->type == KPB_TEST_COPY_ONE_BUFFER) {
182-
int hp_buff_size = test_case_data->hp_buff_size;
183-
/* HPSRAM buffer init only */
184-
kpb->his_buf_hp.id = KPB_HP;
185-
kpb->his_buf_hp.state = KPB_BUFFER_FREE;
186-
kpb->his_buf_hp.w_ptr = hp_buf;
187-
kpb->his_buf_hp.end_addr = kpb->his_buf_hp.w_ptr + hp_buff_size;
188-
kpb->his_buf_hp.sta_addr = hp_buf;
189-
} else {
190-
return NULL;
191-
}
192-
193-
return kpb;
194-
}
195-
196-
static struct comp_buffer *mock_comp_buffer(void **state,
197-
enum kpb_test_buff_type buff_type)
198-
{
199-
struct test_case *test_case_data = (struct test_case *)*state;
200-
struct comp_buffer *buffer = test_malloc(sizeof(struct comp_buffer));
201-
202-
buffer->size = test_case_data->lp_buff_size +
203-
test_case_data->hp_buff_size;
204-
205-
switch (buff_type) {
206-
case KPB_SOURCE_BUFFER:
207-
buffer->avail = buffer->size;
208-
buffer->w_ptr = &buffer->w_ptr; /* setup to NULL */
209-
buffer->addr = buffer->r_ptr;
210-
buffer->end_addr = buffer->r_ptr + buffer->size;
211-
break;
212-
case KPB_SINK_BUFFER:
213-
buffer->free = buffer->size;
214-
buffer->r_ptr = &buffer->r_ptr;
215-
buffer->addr = buffer->w_ptr;
216-
buffer->end_addr = buffer->w_ptr + buffer->size;
217-
break;
218-
}
219-
220-
buffer->cb = NULL;
221-
222-
return buffer;
223-
}
224-
225-
/* Mocking comp_register here so we can register our components properly */
135+
/* Mock comp_register here so we can register our components properly */
226136
int comp_register(struct comp_driver *drv)
227137
{
228138
void *dst;
@@ -235,6 +145,7 @@ int comp_register(struct comp_driver *drv)
235145
default:
236146
return -1;
237147
}
148+
238149
return 0;
239150
}
240151

@@ -243,103 +154,38 @@ int comp_register(struct comp_driver *drv)
243154
*/
244155
static void kpb_test_buffer_real_time_stream(void **state)
245156
{
246-
int i, ret = 0;
247-
struct test_case *test_case_data = (struct test_case *)*state;
248-
int buffer_size = test_case_data->hp_buff_size +
249-
test_case_data->lp_buff_size;
250-
char pattern = 0xAA;
251-
struct comp_buffer *source_test;
252-
struct comp_buffer *sink_test;
253-
char *r_ptr;
254-
/* register KPB component to use its internal functions */
255-
sys_comp_kpb_init();
256-
assert_int_equal(kpb_drv_mock.type, SOF_COMP_KPB);
257-
assert_non_null(kpb_drv_mock.ops.copy);
258-
259-
source_test = list_first_item(&kpb_dev_mock->bsource_list,
260-
struct comp_buffer,
261-
sink_list);
262-
sink_test = list_first_item(&kpb_dev_mock->bsink_list,
263-
struct comp_buffer,
264-
source_list);
265-
assert_ptr_equal(source, source_test);
266-
assert_ptr_equal(sink, sink_test);
267-
268-
/* fiil source buffer with test data */
269-
r_ptr = (char *)source_test->r_ptr;
270-
for (i = 0; i < buffer_size; i++)
271-
(*r_ptr++) = pattern;
272-
273-
/* perform kpb_copy test */
274-
ret = kpb_drv_mock.ops.copy(kpb_dev_mock);
275-
276-
assert_int_equal(ret, 0);
277-
/* verify if source was copied to sink */
278-
assert_memory_equal(source_data,
279-
sink_data,
280-
test_case_data->sink_period_bytes);
281-
282-
if (test_case_data->type == KPB_TEST_COPY_TWO_BUFFERS) {
283-
/* verify if LPSRAM internal buffer was filled properly */
284-
assert_memory_equal(source_data,
285-
his_buf_lp,
286-
test_case_data->lp_buff_size);
287-
/* verify if HPSRAM internal buffer was filled properly */
288-
assert_memory_equal(source_data,
289-
his_buf_hp,
290-
test_case_data->hp_buff_size);
291-
} else if (test_case_data->type == KPB_TEST_COPY_ONE_BUFFER) {
292-
/* verify if HPSRAM internal buffer was filled properly */
293-
assert_memory_equal(source_data,
294-
his_buf_hp,
295-
test_case_data->hp_buff_size);
296-
}
157+
/*TODO: Perform copy from source to sink */
297158
}
298159

299-
/* always successful test */
160+
/* Always successful test */
300161
static void null_test_success(void **state)
301162
{
302163
(void)state;
303164
}
304165

305-
/* test main function */
166+
/* Test main function */
306167
int main(void)
307168
{
308-
struct CMUnitTest tests[3];
309-
struct test_case internal_double_buffering = {
310-
.type = KPB_TEST_COPY_TWO_BUFFERS,
169+
struct CMUnitTest tests[2];
170+
struct test_case internal_buffering = {
311171
.no_buffers = 2,
312172
.lp_buff_size = 100,
313173
.hp_buff_size = 20,
314174
.source_period_bytes = 120,
315175
.sink_period_bytes = 120,
316176
};
317-
struct test_case internal_single_buffering = {
318-
.type = KPB_TEST_COPY_ONE_BUFFER,
319-
.no_buffers = 1,
320-
.lp_buff_size = 0,
321-
.hp_buff_size = 120,
322-
.source_period_bytes = 120,
323-
.sink_period_bytes = 120,
324-
};
325177

326-
tests[0].name = "dummy, always successful test";
178+
tests[0].name = "Dummy, always successful test";
327179
tests[0].test_func = null_test_success;
328180
tests[0].initial_state = NULL;
329181
tests[0].setup_func = NULL;
330182
tests[0].teardown_func = NULL;
331183

332184
tests[1].name = "KPB real time copy and buffering (Double Buffer)";
333185
tests[1].test_func = kpb_test_buffer_real_time_stream;
334-
tests[1].initial_state = &internal_double_buffering;
186+
tests[1].initial_state = &internal_buffering;
335187
tests[1].setup_func = buffering_test_setup;
336188
tests[1].teardown_func = buffering_test_teardown;
337189

338-
tests[2].name = "KPB real time copy and buffering (Single Buffer)";
339-
tests[2].test_func = kpb_test_buffer_real_time_stream;
340-
tests[2].initial_state = &internal_single_buffering;
341-
tests[2].setup_func = buffering_test_setup;
342-
tests[2].teardown_func = buffering_test_teardown;
343-
344190
return cmocka_run_group_tests(tests, NULL, NULL);
345191
}

0 commit comments

Comments
 (0)