Skip to content

Commit 748aad9

Browse files
lgirdwoodlgirdwood
authored
Merge pull request #118 from bkokoszx/test_component_set_state
test: component: change to use 1 assert per test
2 parents e69ebdd + 8d9f9a7 commit 748aad9

3 files changed

Lines changed: 253 additions & 163 deletions

File tree

‎test/cmocka/Makefile.am‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -66,9 +66,9 @@ buffer_copy_LDADD = ../../src/audio/libaudio.a $(LDADD)
6666

6767
# component tests
6868

69-
check_PROGRAMS += component_set_state
70-
component_set_state_SOURCES = src/audio/component/component_set_state.c src/audio/component/mock.c
71-
component_set_state_LDADD = ../../src/audio/libaudio.a $(LDADD)
69+
check_PROGRAMS += comp_set_state
70+
comp_set_state_SOURCES = src/audio/component/comp_set_state.c src/audio/component/mock.c
71+
comp_set_state_LDADD = ../../src/audio/libaudio.a $(LDADD)
7272

7373
# list tests
7474

‎test/cmocka/src/audio/component/comp_set_state.c‎

Lines changed: 250 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,250 @@
1+
/*
2+
* Copyright (c) 2018, Intel Corporation
3+
* All rights reserved.
4+
*
5+
* Redistribution and use in source and binary forms, with or without
6+
* modification, are permitted provided that the following conditions are met:
7+
* * Redistributions of source code must retain the above copyright
8+
* notice, this list of conditions and the following disclaimer.
9+
* * Redistributions in binary form must reproduce the above copyright
10+
* notice, this list of conditions and the following disclaimer in the
11+
* documentation and/or other materials provided with the distribution.
12+
* * Neither the name of the Intel Corporation nor the
13+
* names of its contributors may be used to endorse or promote products
14+
* derived from this software without specific prior written permission.
15+
*
16+
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17+
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18+
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19+
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
20+
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21+
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22+
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23+
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24+
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25+
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26+
* POSSIBILITY OF SUCH DAMAGE.
27+
*
28+
* Author: Bartosz Kokoszko <bartoszx.kokoszko@linux.intel.com>
29+
*/
30+
31+
#include <sof/audio/component.h>
32+
#include <errno.h>
33+
34+
#include <stdarg.h>
35+
#include <stddef.h>
36+
#include <setjmp.h>
37+
#include <cmocka.h>
38+
#include <sof/sof.h>
39+
40+
enum test_type {
41+
SUCCEED = 0,
42+
FAIL,
43+
CORRECT_OUTPUT_STATE,
44+
45+
};
46+
47+
struct test_case {
48+
enum test_type type;
49+
uint16_t in_state;
50+
int cmd;
51+
uint16_t out_state;
52+
const char *name;
53+
};
54+
55+
#define TEST_CASE(type, in_state, cmd, out_state) \
56+
{(type), (in_state), (cmd), (out_state), \
57+
("comp_set_state__" #type "__" #in_state "__" #cmd "__" #out_state)}
58+
59+
60+
/*
61+
* NULL_STATE enum is used in every case, when new state of component is
62+
* insignificant due to action of testing function
63+
*/
64+
enum {
65+
NULL_STATE = -1
66+
};
67+
68+
struct test_case test_cases[] = {
69+
70+
/*succeed set state*/
71+
TEST_CASE(SUCCEED, COMP_STATE_PREPARE,
72+
COMP_TRIGGER_START, NULL_STATE),
73+
TEST_CASE(SUCCEED, COMP_STATE_PAUSED,
74+
COMP_TRIGGER_START, NULL_STATE),
75+
TEST_CASE(SUCCEED, COMP_STATE_PAUSED,
76+
COMP_TRIGGER_RELEASE, NULL_STATE),
77+
TEST_CASE(SUCCEED, COMP_STATE_ACTIVE,
78+
COMP_TRIGGER_STOP, NULL_STATE),
79+
TEST_CASE(SUCCEED, COMP_STATE_ACTIVE,
80+
COMP_TRIGGER_XRUN, NULL_STATE),
81+
TEST_CASE(SUCCEED, COMP_STATE_ACTIVE,
82+
COMP_TRIGGER_PAUSE, NULL_STATE),
83+
TEST_CASE(SUCCEED, COMP_STATE_INIT,
84+
COMP_TRIGGER_RESET, NULL_STATE),
85+
TEST_CASE(SUCCEED, COMP_STATE_READY,
86+
COMP_TRIGGER_RESET, NULL_STATE),
87+
TEST_CASE(SUCCEED, COMP_STATE_SUSPEND,
88+
COMP_TRIGGER_RESET, NULL_STATE),
89+
TEST_CASE(SUCCEED, COMP_STATE_PREPARE,
90+
COMP_TRIGGER_RESET, NULL_STATE),
91+
TEST_CASE(SUCCEED, COMP_STATE_PAUSED,
92+
COMP_TRIGGER_RESET, NULL_STATE),
93+
TEST_CASE(SUCCEED, COMP_STATE_ACTIVE,
94+
COMP_TRIGGER_RESET, NULL_STATE),
95+
TEST_CASE(SUCCEED, COMP_STATE_PREPARE,
96+
COMP_TRIGGER_PREPARE, NULL_STATE),
97+
TEST_CASE(SUCCEED, COMP_STATE_READY,
98+
COMP_TRIGGER_PREPARE, NULL_STATE),
99+
100+
/*fail set state*/
101+
TEST_CASE(FAIL, COMP_STATE_INIT, COMP_TRIGGER_START,
102+
NULL_STATE),
103+
TEST_CASE(FAIL, COMP_STATE_READY, COMP_TRIGGER_START,
104+
NULL_STATE),
105+
TEST_CASE(FAIL, COMP_STATE_SUSPEND, COMP_TRIGGER_START,
106+
NULL_STATE),
107+
TEST_CASE(FAIL, COMP_STATE_ACTIVE, COMP_TRIGGER_START,
108+
NULL_STATE),
109+
TEST_CASE(FAIL, COMP_STATE_INIT, COMP_TRIGGER_RELEASE,
110+
NULL_STATE),
111+
TEST_CASE(FAIL, COMP_STATE_READY, COMP_TRIGGER_RELEASE,
112+
NULL_STATE),
113+
TEST_CASE(FAIL, COMP_STATE_SUSPEND, COMP_TRIGGER_RELEASE,
114+
NULL_STATE),
115+
TEST_CASE(FAIL, COMP_STATE_PREPARE, COMP_TRIGGER_RELEASE,
116+
NULL_STATE),
117+
TEST_CASE(FAIL, COMP_STATE_INIT, COMP_TRIGGER_STOP,
118+
NULL_STATE),
119+
TEST_CASE(FAIL, COMP_STATE_READY, COMP_TRIGGER_STOP,
120+
NULL_STATE),
121+
TEST_CASE(FAIL, COMP_STATE_SUSPEND, COMP_TRIGGER_STOP,
122+
NULL_STATE),
123+
TEST_CASE(FAIL, COMP_STATE_PREPARE, COMP_TRIGGER_STOP,
124+
NULL_STATE),
125+
TEST_CASE(FAIL, COMP_STATE_PAUSED, COMP_TRIGGER_STOP,
126+
NULL_STATE),
127+
TEST_CASE(FAIL, COMP_STATE_INIT, COMP_TRIGGER_XRUN,
128+
NULL_STATE),
129+
TEST_CASE(FAIL, COMP_STATE_READY, COMP_TRIGGER_XRUN,
130+
NULL_STATE),
131+
TEST_CASE(FAIL, COMP_STATE_SUSPEND, COMP_TRIGGER_XRUN,
132+
NULL_STATE),
133+
TEST_CASE(FAIL, COMP_STATE_PREPARE, COMP_TRIGGER_XRUN,
134+
NULL_STATE),
135+
TEST_CASE(FAIL, COMP_STATE_PAUSED, COMP_TRIGGER_XRUN,
136+
NULL_STATE),
137+
TEST_CASE(FAIL, COMP_STATE_INIT, COMP_TRIGGER_PAUSE,
138+
NULL_STATE),
139+
TEST_CASE(FAIL, COMP_STATE_READY, COMP_TRIGGER_PAUSE,
140+
NULL_STATE),
141+
TEST_CASE(FAIL, COMP_STATE_SUSPEND, COMP_TRIGGER_PAUSE,
142+
NULL_STATE),
143+
TEST_CASE(FAIL, COMP_STATE_PREPARE, COMP_TRIGGER_PAUSE,
144+
NULL_STATE),
145+
TEST_CASE(FAIL, COMP_STATE_PAUSED, COMP_TRIGGER_PAUSE,
146+
NULL_STATE),
147+
TEST_CASE(FAIL, COMP_STATE_INIT, COMP_TRIGGER_PREPARE,
148+
NULL_STATE),
149+
TEST_CASE(FAIL, COMP_STATE_SUSPEND, COMP_TRIGGER_PREPARE,
150+
NULL_STATE),
151+
TEST_CASE(FAIL, COMP_STATE_PAUSED, COMP_TRIGGER_PREPARE,
152+
NULL_STATE),
153+
TEST_CASE(FAIL, COMP_STATE_ACTIVE, COMP_TRIGGER_PREPARE,
154+
NULL_STATE),
155+
156+
/*correct output state*/
157+
TEST_CASE(CORRECT_OUTPUT_STATE, COMP_STATE_PREPARE,
158+
COMP_TRIGGER_START, COMP_STATE_ACTIVE),
159+
TEST_CASE(CORRECT_OUTPUT_STATE, COMP_STATE_PAUSED,
160+
COMP_TRIGGER_START, COMP_STATE_ACTIVE),
161+
TEST_CASE(CORRECT_OUTPUT_STATE, COMP_STATE_PAUSED,
162+
COMP_TRIGGER_RELEASE, COMP_STATE_ACTIVE),
163+
TEST_CASE(CORRECT_OUTPUT_STATE, COMP_STATE_ACTIVE,
164+
COMP_TRIGGER_STOP, COMP_STATE_PREPARE),
165+
TEST_CASE(CORRECT_OUTPUT_STATE, COMP_STATE_ACTIVE,
166+
COMP_TRIGGER_XRUN, COMP_STATE_PREPARE),
167+
TEST_CASE(CORRECT_OUTPUT_STATE, COMP_STATE_ACTIVE,
168+
COMP_TRIGGER_PAUSE, COMP_STATE_PAUSED),
169+
TEST_CASE(CORRECT_OUTPUT_STATE, COMP_STATE_INIT,
170+
COMP_TRIGGER_RESET, COMP_STATE_READY),
171+
TEST_CASE(CORRECT_OUTPUT_STATE, COMP_STATE_READY,
172+
COMP_TRIGGER_RESET, COMP_STATE_READY),
173+
TEST_CASE(CORRECT_OUTPUT_STATE, COMP_STATE_SUSPEND,
174+
COMP_TRIGGER_RESET, COMP_STATE_READY),
175+
TEST_CASE(CORRECT_OUTPUT_STATE, COMP_STATE_PREPARE,
176+
COMP_TRIGGER_RESET, COMP_STATE_READY),
177+
TEST_CASE(CORRECT_OUTPUT_STATE, COMP_STATE_PAUSED,
178+
COMP_TRIGGER_RESET, COMP_STATE_READY),
179+
TEST_CASE(CORRECT_OUTPUT_STATE, COMP_STATE_ACTIVE,
180+
COMP_TRIGGER_RESET, COMP_STATE_READY),
181+
TEST_CASE(CORRECT_OUTPUT_STATE, COMP_STATE_PREPARE,
182+
COMP_TRIGGER_PREPARE, COMP_STATE_PREPARE),
183+
TEST_CASE(CORRECT_OUTPUT_STATE, COMP_STATE_READY,
184+
COMP_TRIGGER_PREPARE, COMP_STATE_PREPARE),
185+
};
186+
187+
static void test_audio_component_comp_set_state_succeed(struct test_case *tc)
188+
{
189+
struct comp_dev test_dev;
190+
191+
test_dev.state = tc->in_state;
192+
193+
assert_int_equal(comp_set_state(&test_dev, tc->cmd), 0);
194+
}
195+
196+
static void test_audio_component_comp_set_state_correct_output_state(struct test_case *tc)
197+
{
198+
struct comp_dev test_dev;
199+
200+
test_dev.state = tc->in_state;
201+
comp_set_state(&test_dev, tc->cmd);
202+
203+
assert_int_equal(test_dev.state, tc->out_state);
204+
}
205+
206+
static void test_audio_component_comp_set_state_fail(struct test_case *tc)
207+
{
208+
struct comp_dev test_drv;
209+
210+
test_drv.state = tc->in_state;
211+
assert_int_equal(comp_set_state(&test_drv, tc->cmd), -EINVAL);
212+
}
213+
214+
static void test_comp_set_state(void **state)
215+
{
216+
struct test_case *tc = *((struct test_case **) state);
217+
218+
switch (tc->type) {
219+
case SUCCEED:
220+
test_audio_component_comp_set_state_succeed(tc);
221+
break;
222+
case FAIL:
223+
test_audio_component_comp_set_state_fail(tc);
224+
break;
225+
case CORRECT_OUTPUT_STATE:
226+
test_audio_component_comp_set_state_correct_output_state(tc);
227+
break;
228+
}
229+
}
230+
231+
int main(void)
232+
{
233+
struct CMUnitTest tests[ARRAY_SIZE(test_cases)];
234+
235+
int i;
236+
237+
for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
238+
struct CMUnitTest *t = &tests[i];
239+
240+
t->name = test_cases[i].name;
241+
t->test_func = test_comp_set_state;
242+
t->initial_state = &test_cases[i];
243+
t->setup_func = NULL;
244+
t->teardown_func = NULL;
245+
246+
}
247+
cmocka_set_message_output(CM_OUTPUT_TAP);
248+
249+
return cmocka_run_group_tests(tests, NULL, NULL);
250+
}

0 commit comments

Comments
 (0)