1 /*
2 * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without modification,
5 * are permitted provided that the following conditions are met:
6 *
7 * 1. Redistributions of source code must retain the above copyright notice, this list of
8 * conditions and the following disclaimer.
9 *
10 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
11 * of conditions and the following disclaimer in the documentation and/or other materials
12 * provided with the distribution.
13 *
14 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
15 * to endorse or promote products derived from this software without specific prior written
16 * permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
20 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
22 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
25 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
27 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
28 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 #include "xts_cmsis.h"
32
33 osEventFlagsId_t g_eventId;
34 UINT16 g_cmsisTestEventCount;
35
36 LITE_TEST_SUIT(Cmsis, Cmsisevent, CmsisEventFuncTestSuite);
37
CmsisEventFuncTestSuiteSetUp(void)38 static BOOL CmsisEventFuncTestSuiteSetUp(void)
39 {
40 return TRUE;
41 }
42
CmsisEventFuncTestSuiteTearDown(void)43 static BOOL CmsisEventFuncTestSuiteTearDown(void)
44 {
45 return TRUE;
46 }
47
CmsisEventFlagsWaitFunc001(void const * argument)48 static void CmsisEventFlagsWaitFunc001(void const *argument)
49 {
50 (void)argument;
51 g_cmsisTestEventCount++;
52 UINT32 ret = osEventFlagsWait(g_eventId, EVENT_MASK_HEX_11, (osFlagsWaitAll | osFlagsNoClear), osWaitForever);
53 ICUNIT_ASSERT_EQUAL_VOID(ret, EVENT_MASK_HEX_11, ret);
54 g_cmsisTestEventCount++;
55 osThreadExit();
56 }
57
CmsisEventFlagsSetFunc002(void const * argument)58 static void CmsisEventFlagsSetFunc002(void const *argument)
59 {
60 (void)argument;
61 UINT32 ret;
62 g_cmsisTestEventCount++;
63 ret = osEventFlagsWait(g_eventId, EVENT_MASK_HEX_11, (osFlagsWaitAll | osFlagsNoClear), TIMEOUT_NUM_3);
64 ICUNIT_ASSERT_EQUAL_VOID(ret, osErrorTimeout, ret);
65 g_cmsisTestEventCount++;
66
67 ret = osEventFlagsWait(g_eventId, EVENT_MASK_HEX_4, (osFlagsWaitAll | osFlagsNoClear), osWaitForever);
68 ICUNIT_ASSERT_EQUAL_VOID(ret, TESTCOUNT_NUM_4, ret);
69 g_cmsisTestEventCount++;
70 osThreadExit();
71 }
72
CmsisEventFlagsClearFunc001(void const * argument)73 static void CmsisEventFlagsClearFunc001(void const *argument)
74 {
75 (void)argument;
76 g_cmsisTestEventCount++;
77 UINT32 ret = osEventFlagsWait(g_eventId, EVENT_MASK_HEX_1, osFlagsWaitAll, osWaitForever);
78 ICUNIT_ASSERT_EQUAL_VOID(ret, EVENT_MASK_HEX_1, ret);
79 g_cmsisTestEventCount++;
80 osThreadExit();
81 }
82
83 /**
84 * @tc.number : SUB_KERNEL_CMSIS_EVENT_OPERATION_0100
85 * @tc.name : event operation for creat
86 * @tc.desc : [C- SOFTWARE -0200]
87 */
88 LITE_TEST_CASE(CmsisEventFuncTestSuite, testOsEventFlagsNew001, Function | MediumTest | Level1)
89 {
90 g_eventId = osEventFlagsNew(NULL);
91 ICUNIT_ASSERT_NOT_EQUAL(g_eventId, NULL, g_eventId);
92 (void)osEventFlagsDelete(g_eventId);
93 return 0;
94 };
95
96 /**
97 * @tc.number : SUB_KERNEL_CMSIS_EVENT_OPERATION_0200
98 * @tc.name : event operation for delete
99 * @tc.desc : [C- SOFTWARE -0200]
100 */
101 LITE_TEST_CASE(CmsisEventFuncTestSuite, testOsEventFlagsDelete001, Function | MediumTest | Level1)
102 {
103 UINT32 ret;
104 g_eventId = osEventFlagsNew(NULL);
105 ICUNIT_ASSERT_NOT_EQUAL(g_eventId, NULL, g_eventId);
106 ret = osEventFlagsDelete(g_eventId);
107 ICUNIT_ASSERT_EQUAL(ret, osOK, ret);
108 return 0;
109 };
110
111 /**
112 * @tc.number : SUB_KERNEL_CMSIS_EVENT_OPERATION_0300
113 * @tc.name : event delete operation with EventFlagsId = NULL
114 * @tc.desc : [C- SOFTWARE -0200]
115 */
116 LITE_TEST_CASE(CmsisEventFuncTestSuite, testOsEventFlagsDelete002, Function | MediumTest | Level1)
117 {
118 UINT32 ret = osEventFlagsDelete(NULL);
119 ICUNIT_ASSERT_EQUAL(ret, osErrorParameter, ret);
120 return 0;
121 };
122
123 /**
124 * @tc.number : SUB_KERNEL_CMSIS_EVENT_OPERATION_0400
125 * @tc.name : event operation for flags set
126 * @tc.desc : [C- SOFTWARE -0200]
127 */
128 LITE_TEST_CASE(CmsisEventFuncTestSuite, testOsEventFlagsSet001, Function | MediumTest | Level1)
129 {
130 UINT32 ret;
131 g_eventId = osEventFlagsNew(NULL);
132 ret = osEventFlagsSet(g_eventId, EVENT_MASK_HEX_10);
133 ICUNIT_ASSERT_EQUAL(ret, EVENT_MASK_HEX_10, ret);
134 ret = osEventFlagsDelete(g_eventId);
135 ICUNIT_ASSERT_EQUAL(ret, osOK, ret);
136 return 0;
137 };
138
139 /**
140 * @tc.number : SUB_KERNEL_CMSIS_EVENT_OPERATION_0500
141 * @tc.name : event reliability test for flags set
142 * @tc.desc : [C- SOFTWARE -0200]
143 */
144 LITE_TEST_CASE(CmsisEventFuncTestSuite, testOsEventFlagsSet002, Function | MediumTest | Level1)
145 {
146 UINT32 ret;
147 osThreadId_t id;
148 osStatus_t status;
149 osThreadAttr_t attr;
150 attr.name = "test";
151 attr.attr_bits = 0U;
152 attr.cb_mem = NULL;
153 attr.cb_size = 0U;
154 attr.stack_mem = NULL;
155 attr.stack_size = TEST_TASK_STACK_SIZE;
156 attr.priority = osPriorityAboveNormal;
157
158 g_cmsisTestEventCount = 0;
159 g_eventId = osEventFlagsNew(NULL);
160 ICUNIT_ASSERT_NOT_EQUAL(g_eventId, NULL, g_eventId);
161 id = osThreadNew((osThreadFunc_t)CmsisEventFlagsSetFunc002, NULL, &attr);
162 ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
163 ICUNIT_ASSERT_EQUAL(g_cmsisTestEventCount, EVENT_MASK_HEX_1, g_cmsisTestEventCount);
164 g_cmsisTestEventCount++;
165 ret = osEventFlagsSet(g_eventId, EVENT_MASK_HEX_2);
166 status = osDelay(DELAY_TICKS_5);
167 ICUNIT_ASSERT_EQUAL(status, osOK, status);
168 ICUNIT_ASSERT_EQUAL(g_cmsisTestEventCount, TESTCOUNT_NUM_3, g_cmsisTestEventCount);
169
170 g_cmsisTestEventCount++;
171 ret = osEventFlagsSet(g_eventId, EVENT_MASK_HEX_11);
172 status = osDelay(DELAY_TICKS_5);
173 ICUNIT_ASSERT_EQUAL(status, osOK, status);
174
175 ICUNIT_ASSERT_EQUAL(g_cmsisTestEventCount, TESTCOUNT_NUM_4, g_cmsisTestEventCount);
176 ret = osEventFlagsSet(g_eventId, EVENT_MASK_HEX_4);
177 ICUNIT_ASSERT_EQUAL(g_cmsisTestEventCount, TESTCOUNT_NUM_5, g_cmsisTestEventCount);
178 ret = osEventFlagsDelete(g_eventId);
179 ICUNIT_ASSERT_EQUAL(ret, osOK, ret);
180
181 return 0;
182 };
183
184 /**
185 * @tc.number : SUB_KERNEL_CMSIS_EVENT_OPERATION_0600
186 * @tc.name : event flags set operation with EventFlagsId = NULL
187 * @tc.desc : [C- SOFTWARE -0200]
188 */
189 LITE_TEST_CASE(CmsisEventFuncTestSuite, testOsEventFlagsSet003, Function | MediumTest | Level1)
190 {
191 UINT32 ret = osEventFlagsSet(NULL, EVENT_MASK_HEX_10);
192 ICUNIT_ASSERT_EQUAL(ret, osFlagsErrorParameter, ret);
193 return 0;
194 };
195
196 /**
197 * @tc.number : SUB_KERNEL_CMSIS_EVENT_OPERATION_0700
198 * @tc.name : event operation for wait
199 * @tc.desc : [C- SOFTWARE -0200]
200 */
201 LITE_TEST_CASE(CmsisEventFuncTestSuite, testOsEventFlagsWait001, Function | MediumTest | Level1)
202 {
203 UINT32 ret;
204 osThreadId_t id;
205 osThreadAttr_t attr;
206 attr.name = "test";
207 attr.attr_bits = 0U;
208 attr.cb_mem = NULL;
209 attr.cb_size = 0U;
210 attr.stack_mem = NULL;
211 attr.stack_size = TEST_TASK_STACK_SIZE;
212 attr.priority = osPriorityAboveNormal;
213
214 g_cmsisTestEventCount = 0;
215 g_eventId = osEventFlagsNew(NULL);
216 ICUNIT_ASSERT_NOT_EQUAL(g_eventId, NULL, g_eventId);
217 id = osThreadNew((osThreadFunc_t)CmsisEventFlagsWaitFunc001, NULL, &attr);
218 ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
219
220 ret = osEventFlagsSet(g_eventId, EVENT_MASK_HEX_10);
221 ICUNIT_ASSERT_EQUAL(ret, EVENT_MASK_HEX_10, ret);
222 ICUNIT_ASSERT_EQUAL(g_cmsisTestEventCount, EVENT_MASK_HEX_1, g_cmsisTestEventCount);
223
224 ret = osEventFlagsSet(g_eventId, EVENT_MASK_HEX_1);
225 ICUNIT_ASSERT_EQUAL(ret, EVENT_MASK_HEX_11, ret);
226 ICUNIT_ASSERT_EQUAL(g_cmsisTestEventCount, TESTCOUNT_NUM_2, g_cmsisTestEventCount);
227
228 ret = osEventFlagsDelete(g_eventId);
229 ICUNIT_ASSERT_EQUAL(ret, osOK, ret);
230 return 0;
231 };
232
233 /**
234 * @tc.number : SUB_KERNEL_CMSIS_EVENT_OPERATION_0800
235 * @tc.name : event operation for invalid option
236 * @tc.desc : [C- SOFTWARE -0200]
237 */
238 LITE_TEST_CASE(CmsisEventFuncTestSuite, testOsEventFlagsWait002, Function | MediumTest | Level1)
239 {
240 UINT32 ret;
241 g_eventId = osEventFlagsNew(NULL);
242 ICUNIT_ASSERT_NOT_EQUAL(g_eventId, NULL, g_eventId);
243
244 ret = osEventFlagsWait(g_eventId, EVENT_MASK_HEX_11, INVALID_FLAG_OPTION, osWaitForever);
245 ICUNIT_ASSERT_EQUAL(ret, osFlagsErrorParameter, ret);
246
247 ret = osEventFlagsDelete(g_eventId);
248 ICUNIT_ASSERT_EQUAL(ret, osOK, ret);
249 return 0;
250 };
251
252 /**
253 * @tc.number : SUB_KERNEL_CMSIS_EVENT_OPERATION_0900
254 * @tc.name : event wait operation with EventFlagsId = NULL
255 * @tc.desc : [C- SOFTWARE -0200]
256 */
257 LITE_TEST_CASE(CmsisEventFuncTestSuite, testOsEventFlagsWait003, Function | MediumTest | Level1)
258 {
259 UINT32 ret = osEventFlagsWait(NULL, EVENT_MASK_HEX_11, (osFlagsWaitAll | osFlagsNoClear), osWaitForever);
260 ICUNIT_ASSERT_EQUAL(ret, osFlagsErrorParameter, ret);
261 return 0;
262 };
263
264 /**
265 * @tc.number : SUB_KERNEL_CMSIS_EVENT_OPERATION_1000
266 * @tc.name : event operation for flags get
267 * @tc.desc : [C- SOFTWARE -0200]
268 */
269 LITE_TEST_CASE(CmsisEventFuncTestSuite, testOsEventFlagsGet001, Function | MediumTest | Level1)
270 {
271 UINT32 ret;
272 g_eventId = osEventFlagsNew(NULL);
273 ret = osEventFlagsSet(g_eventId, EVENT_MASK_HEX_10);
274 ICUNIT_ASSERT_EQUAL(ret, EVENT_MASK_HEX_10, ret);
275 ret = osEventFlagsGet(g_eventId);
276 ICUNIT_ASSERT_EQUAL(ret, EVENT_MASK_HEX_10, ret);
277
278 ret = osEventFlagsDelete(g_eventId);
279 ICUNIT_ASSERT_EQUAL(ret, osOK, ret);
280
281 return 0;
282 };
283
284 /**
285 * @tc.number : SUB_KERNEL_CMSIS_EVENT_OPERATION_1100
286 * @tc.name : event flags get operation with EventFlagsId = NULL
287 * @tc.desc : [C- SOFTWARE -0200]
288 */
289 LITE_TEST_CASE(CmsisEventFuncTestSuite, testOsEventFlagsGet002, Function | MediumTest | Level1)
290 {
291 UINT32 ret = osEventFlagsGet(NULL);
292 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
293 return 0;
294 };
295
296 /**
297 * @tc.number : SUB_KERNEL_CMSIS_EVENT_OPERATION_1200
298 * @tc.name : event operation for flags clear
299 * @tc.desc : [C- SOFTWARE -0200]
300 */
301 LITE_TEST_CASE(CmsisEventFuncTestSuite, testOsEventFlagsClear001, Function | MediumTest | Level1)
302 {
303 UINT32 ret;
304 osThreadId_t id;
305
306 osThreadAttr_t attr;
307 attr.name = "test";
308 attr.attr_bits = 0U;
309 attr.cb_mem = NULL;
310 attr.cb_size = 0U;
311 attr.stack_mem = NULL;
312 attr.stack_size = TEST_TASK_STACK_SIZE;
313 attr.priority = osPriorityAboveNormal;
314
315 g_cmsisTestEventCount = 0;
316 g_eventId = osEventFlagsNew(NULL);
317 id = osThreadNew((osThreadFunc_t)CmsisEventFlagsClearFunc001, NULL, &attr);
318 ICUNIT_ASSERT_NOT_EQUAL(id, NULL, id);
319 ret = osEventFlagsSet(g_eventId, EVENT_MASK_HEX_10);
320 ICUNIT_ASSERT_EQUAL(ret, EVENT_MASK_HEX_10, ret);
321 ICUNIT_ASSERT_EQUAL(g_cmsisTestEventCount, EVENT_MASK_HEX_1, g_cmsisTestEventCount);
322
323 ret = osEventFlagsClear(g_eventId, 0xffff);
324 ICUNIT_ASSERT_EQUAL(ret, EVENT_MASK_HEX_10, ret);
325 ret = osEventFlagsGet(g_eventId);
326 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
327 ret = osEventFlagsSet(g_eventId, EVENT_MASK_HEX_1);
328 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
329 ICUNIT_ASSERT_EQUAL(g_cmsisTestEventCount, TESTCOUNT_NUM_2, g_cmsisTestEventCount);
330 ret = osEventFlagsDelete(g_eventId);
331 ICUNIT_ASSERT_EQUAL(ret, osOK, ret);
332 return 0;
333 };
334
335 /**
336 * @tc.number : SUB_KERNEL_CMSIS_EVENT_OPERATION_1300
337 * @tc.name : event flags clear operation with EventFlagsId = NULL
338 * @tc.desc : [C- SOFTWARE -0200]
339 */
340 LITE_TEST_CASE(CmsisEventFuncTestSuite, testOsEventFlagsClear002, Function | MediumTest | Level1)
341 {
342 UINT32 ret = osEventFlagsClear(NULL, 0xffff);
343 ICUNIT_ASSERT_EQUAL(ret, osFlagsErrorParameter, ret);
344 return 0;
345 };
346
347 RUN_TEST_SUITE(CmsisEventFuncTestSuite);
348
CmsisEventFuncTest(void)349 void CmsisEventFuncTest(void)
350 {
351 RUN_ONE_TESTCASE(testOsEventFlagsNew001);
352 RUN_ONE_TESTCASE(testOsEventFlagsDelete001);
353 RUN_ONE_TESTCASE(testOsEventFlagsDelete002);
354 RUN_ONE_TESTCASE(testOsEventFlagsSet001);
355 RUN_ONE_TESTCASE(testOsEventFlagsSet002);
356 RUN_ONE_TESTCASE(testOsEventFlagsSet003);
357 RUN_ONE_TESTCASE(testOsEventFlagsWait001);
358 RUN_ONE_TESTCASE(testOsEventFlagsWait002);
359 RUN_ONE_TESTCASE(testOsEventFlagsWait003);
360 RUN_ONE_TESTCASE(testOsEventFlagsGet001);
361 RUN_ONE_TESTCASE(testOsEventFlagsGet002);
362 RUN_ONE_TESTCASE(testOsEventFlagsClear001);
363 RUN_ONE_TESTCASE(testOsEventFlagsClear002);
364 }
365