1 /*
2 * Copyright (c) 2006-2021, RT-Thread Development Team
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 * 2021-09-08 liukang the first version
9 * 2023-09-15 xqyjlj change stack size in cpu64
10 */
11
12 #include <rtthread.h>
13 #include "utest.h"
14 #include <stdlib.h>
15
16 #define THREAD_STACKSIZE UTEST_THR_STACK_SIZE
17
18 static struct rt_mailbox test_static_mb;
19 static char mb_pool[128];
20
21 static rt_mailbox_t test_dynamic_mb;
22
23 static uint8_t static_mb_recv_thread_finish, static_mb_send_thread_finish;
24 static uint8_t dynamic_mb_recv_thread_finish, dynamic_mb_send_thread_finish;
25
26 rt_align(RT_ALIGN_SIZE)
27 static char thread1_stack[UTEST_THR_STACK_SIZE];
28 static struct rt_thread thread1;
29
30 rt_align(RT_ALIGN_SIZE)
31 static char thread2_stack[UTEST_THR_STACK_SIZE];
32 static struct rt_thread thread2;
33
34 #define THREAD_PRIORITY 9
35 #define THREAD_TIMESLICE 5
36
37 static rt_thread_t mb_send = RT_NULL;
38 static rt_thread_t mb_recv = RT_NULL;
39
40 static rt_uint8_t mb_send_str1[] = "this is first mail!";
41 static rt_uint8_t mb_send_str2[] = "this is second mail!";
42 static rt_uint8_t mb_send_str3[] = "this is thirdy mail!";
43
44 static rt_uint8_t *mb_recv_str1;
45 static rt_uint8_t *mb_recv_str2;
46 static rt_uint8_t *mb_recv_str3;
47
test_mailbox_init(void)48 static void test_mailbox_init(void)
49 {
50 rt_err_t result;
51
52 result = rt_mb_init(&test_static_mb, "mbt", &mb_pool[0], sizeof(mb_pool) / 4, RT_IPC_FLAG_FIFO);
53 if (result != RT_EOK)
54 {
55 uassert_false(1);
56 }
57 result = rt_mb_detach(&test_static_mb);
58 if (result != RT_EOK)
59 {
60 uassert_false(1);
61 }
62
63 result = rt_mb_init(&test_static_mb, "mbt", &mb_pool[0], sizeof(mb_pool) / 4, RT_IPC_FLAG_PRIO);
64 if (result != RT_EOK)
65 {
66 uassert_false(1);
67 }
68
69 result = rt_mb_detach(&test_static_mb);
70 if (result != RT_EOK)
71 {
72 uassert_false(1);
73 }
74
75 uassert_true(1);
76 }
77
test_mailbox_deatch(void)78 static void test_mailbox_deatch(void)
79 {
80 rt_err_t result;
81
82 result = rt_mb_init(&test_static_mb, "mbt", &mb_pool[0], sizeof(mb_pool) / 4, RT_IPC_FLAG_FIFO);
83 if (result != RT_EOK)
84 {
85 uassert_false(1);
86 }
87 result = rt_mb_detach(&test_static_mb);
88 if (result != RT_EOK)
89 {
90 uassert_false(1);
91 }
92
93 result = rt_mb_init(&test_static_mb, "mbt", &mb_pool[0], sizeof(mb_pool) / 4, RT_IPC_FLAG_PRIO);
94 if (result != RT_EOK)
95 {
96 uassert_false(1);
97 }
98 result = rt_mb_detach(&test_static_mb);
99 if (result != RT_EOK)
100 {
101 uassert_false(1);
102 }
103
104 uassert_true(1);
105 }
106
test_mailbox_create(void)107 static void test_mailbox_create(void)
108 {
109 rt_err_t result;
110
111 test_dynamic_mb = rt_mb_create("test_dynamic_mb", sizeof(mb_pool) / 4, RT_IPC_FLAG_FIFO);
112 if (test_dynamic_mb == RT_NULL)
113 {
114 uassert_false(1);
115 }
116 result = rt_mb_delete(test_dynamic_mb);
117 if (result != RT_EOK)
118 {
119 uassert_false(1);
120 }
121
122 test_dynamic_mb = rt_mb_create("test_dynamic_mb", sizeof(mb_pool) / 4, RT_IPC_FLAG_PRIO);
123 if (test_dynamic_mb == RT_NULL)
124 {
125 uassert_false(1);
126 }
127 result = rt_mb_delete(test_dynamic_mb);
128 if (result != RT_EOK)
129 {
130 uassert_false(1);
131 }
132
133 uassert_true(1);
134 }
135
test_mailbox_delete(void)136 static void test_mailbox_delete(void)
137 {
138 rt_err_t result;
139
140 test_dynamic_mb = rt_mb_create("test_dynamic_mb", sizeof(mb_pool) / 4, RT_IPC_FLAG_FIFO);
141 if (test_dynamic_mb == RT_NULL)
142 {
143 uassert_false(1);
144 }
145 result = rt_mb_delete(test_dynamic_mb);
146 if (result != RT_EOK)
147 {
148 uassert_false(1);
149 }
150
151 test_dynamic_mb = rt_mb_create("test_dynamic_mb", sizeof(mb_pool) / 4, RT_IPC_FLAG_PRIO);
152 if (test_dynamic_mb == RT_NULL)
153 {
154 uassert_false(1);
155 }
156 result = rt_mb_delete(test_dynamic_mb);
157 if (result != RT_EOK)
158 {
159 uassert_false(1);
160 }
161
162 uassert_true(1);
163 }
164
thread2_send_static_mb(void * arg)165 static void thread2_send_static_mb(void *arg)
166 {
167 rt_err_t res = RT_EOK;
168
169 res = rt_mb_send(&test_static_mb, (rt_ubase_t)&mb_send_str1);
170 if (res != RT_EOK)
171 {
172 uassert_false(1);
173 }
174 rt_thread_mdelay(100);
175
176 res = rt_mb_send_wait(&test_static_mb, (rt_ubase_t)&mb_send_str2, 10);
177 if (res != RT_EOK)
178 {
179 uassert_false(1);
180 }
181 rt_thread_mdelay(100);
182
183 res = rt_mb_urgent(&test_static_mb, (rt_ubase_t)&mb_send_str3);
184 if (res != RT_EOK)
185 {
186 uassert_false(1);
187 }
188
189 static_mb_send_thread_finish = 1;
190 }
191
thread1_recv_static_mb(void * arg)192 static void thread1_recv_static_mb(void *arg)
193 {
194 rt_err_t result = RT_EOK;
195
196 result = rt_mb_recv(&test_static_mb, (rt_ubase_t *)&mb_recv_str1, RT_WAITING_FOREVER);
197 if (result != RT_EOK || rt_strcmp((const char *)mb_recv_str1, (const char *)mb_send_str1) != 0)
198 {
199 uassert_false(1);
200 }
201
202 result = rt_mb_recv(&test_static_mb, (rt_ubase_t *)&mb_recv_str2, RT_WAITING_FOREVER);
203 if (result != RT_EOK || rt_strcmp((const char *)mb_recv_str2, (const char *)mb_send_str2) != 0)
204 {
205 uassert_false(1);
206 }
207
208 result = rt_mb_recv(&test_static_mb, (rt_ubase_t *)&mb_recv_str3, RT_WAITING_FOREVER);
209 if (result != RT_EOK || rt_strcmp((const char *)mb_recv_str3, (const char *)mb_send_str3) != 0)
210 {
211 uassert_false(1);
212 }
213
214 static_mb_recv_thread_finish = 1;
215 }
216
test_static_mailbox_send_recv(void)217 static void test_static_mailbox_send_recv(void)
218 {
219 rt_err_t result;
220
221 result = rt_mb_init(&test_static_mb, "mbt", &mb_pool[0], sizeof(mb_pool) / 4, RT_IPC_FLAG_FIFO);
222 if (result != RT_EOK)
223 {
224 uassert_false(1);
225 }
226
227 rt_thread_init(&thread1,
228 "thread1",
229 thread1_recv_static_mb,
230 RT_NULL,
231 &thread1_stack[0],
232 sizeof(thread1_stack),
233 THREAD_PRIORITY - 1, THREAD_TIMESLICE);
234 rt_thread_startup(&thread1);
235
236 rt_thread_init(&thread2,
237 "thread2",
238 thread2_send_static_mb,
239 RT_NULL,
240 &thread2_stack[0],
241 sizeof(thread2_stack),
242 THREAD_PRIORITY, THREAD_TIMESLICE);
243 rt_thread_startup(&thread2);
244
245 while (static_mb_recv_thread_finish != 1 || static_mb_send_thread_finish != 1)
246 {
247 rt_thread_delay(1);
248 }
249
250 if (rt_mb_detach(&test_static_mb) != RT_EOK)
251 {
252 uassert_false(1);
253 }
254
255 uassert_true(1);
256 }
257
thread4_send_dynamic_mb(void * arg)258 static void thread4_send_dynamic_mb(void *arg)
259 {
260 rt_err_t res = RT_EOK;
261
262 res = rt_mb_send(test_dynamic_mb, (rt_ubase_t)&mb_send_str1);
263 if (res != RT_EOK)
264 {
265 uassert_false(1);
266 }
267 rt_thread_mdelay(100);
268
269 res = rt_mb_send_wait(test_dynamic_mb, (rt_ubase_t)&mb_send_str2, 10);
270 if (res != RT_EOK)
271 {
272 uassert_false(1);
273 }
274 rt_thread_mdelay(100);
275
276 res = rt_mb_urgent(test_dynamic_mb, (rt_ubase_t)&mb_send_str3);
277 if (res != RT_EOK)
278 {
279 uassert_false(1);
280 }
281
282 dynamic_mb_send_thread_finish = 1;
283 }
284
thread3_recv_dynamic_mb(void * arg)285 static void thread3_recv_dynamic_mb(void *arg)
286 {
287 rt_err_t result = RT_EOK;
288
289 result = rt_mb_recv(test_dynamic_mb, (rt_ubase_t *)&mb_recv_str1, RT_WAITING_FOREVER);
290 if (result != RT_EOK || rt_strcmp((const char *)mb_recv_str1, (const char *)mb_send_str1) != 0)
291 {
292 uassert_false(1);
293 }
294
295 result = rt_mb_recv(test_dynamic_mb, (rt_ubase_t *)&mb_recv_str2, RT_WAITING_FOREVER);
296 if (result != RT_EOK || rt_strcmp((const char *)mb_recv_str2, (const char *)mb_send_str2) != 0)
297 {
298 uassert_false(1);
299 }
300
301 result = rt_mb_recv(test_dynamic_mb, (rt_ubase_t *)&mb_recv_str3, RT_WAITING_FOREVER);
302 if (result != RT_EOK || rt_strcmp((const char *)mb_recv_str3, (const char *)mb_send_str3) != 0)
303 {
304 uassert_false(1);
305 }
306
307 dynamic_mb_recv_thread_finish = 1;
308 }
309
test_dynamic_mailbox_send_recv(void)310 static void test_dynamic_mailbox_send_recv(void)
311 {
312 test_dynamic_mb = rt_mb_create("mbt", sizeof(mb_pool) / 4, RT_IPC_FLAG_FIFO);
313 if (test_dynamic_mb == RT_NULL)
314 {
315 uassert_false(1);
316 }
317
318 mb_recv = rt_thread_create("mb_recv_thread",
319 thread3_recv_dynamic_mb,
320 RT_NULL,
321 UTEST_THR_STACK_SIZE,
322 THREAD_PRIORITY - 1,
323 THREAD_TIMESLICE);
324 if (mb_recv == RT_NULL)
325 {
326 uassert_false(1);
327 }
328 rt_thread_startup(mb_recv);
329
330 mb_send = rt_thread_create("mb_send_thread",
331 thread4_send_dynamic_mb,
332 RT_NULL,
333 UTEST_THR_STACK_SIZE,
334 THREAD_PRIORITY - 1,
335 THREAD_TIMESLICE);
336 if (mb_send == RT_NULL)
337 {
338 uassert_false(1);
339 }
340 rt_thread_startup(mb_send);
341
342 while (dynamic_mb_recv_thread_finish != 1 || dynamic_mb_send_thread_finish != 1)
343 {
344 rt_thread_delay(1);
345 }
346
347 if (rt_mb_delete(test_dynamic_mb) != RT_EOK)
348 {
349 uassert_false(1);
350 }
351
352 uassert_true(1);
353 }
354
utest_tc_init(void)355 static rt_err_t utest_tc_init(void)
356 {
357 return RT_EOK;
358 }
359
utest_tc_cleanup(void)360 static rt_err_t utest_tc_cleanup(void)
361 {
362 return RT_EOK;
363 }
364
testcase(void)365 static void testcase(void)
366 {
367 UTEST_UNIT_RUN(test_mailbox_init);
368 UTEST_UNIT_RUN(test_mailbox_deatch);
369 UTEST_UNIT_RUN(test_mailbox_create);
370 UTEST_UNIT_RUN(test_mailbox_delete);
371 UTEST_UNIT_RUN(test_static_mailbox_send_recv);
372 UTEST_UNIT_RUN(test_dynamic_mailbox_send_recv);
373 }
374 UTEST_TC_EXPORT(testcase, "src.ipc.mailbox_tc", utest_tc_init, utest_tc_cleanup, 60);
375