347 lines
8.0 KiB
C
347 lines
8.0 KiB
C
/*
|
|
* Copyright (c) 2006-2019, RT-Thread Development Team
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Change Logs:
|
|
* Date Author Notes
|
|
* 2021-08-15 liukang the first version
|
|
* 2023-09-15 xqyjlj change stack size in cpu64
|
|
*/
|
|
|
|
#include <rtthread.h>
|
|
#include "utest.h"
|
|
#include <stdlib.h>
|
|
|
|
#define THREAD_STACKSIZE UTEST_THR_STACK_SIZE
|
|
#define EVENT_FLAG3 (1 << 3)
|
|
#define EVENT_FLAG5 (1 << 5)
|
|
|
|
static struct rt_event static_event = {0};
|
|
#ifdef RT_USING_HEAP
|
|
static rt_event_t dynamic_event = RT_NULL;
|
|
static rt_uint32_t dynamic_event_recv_thread_finish = 0, dynamic_event_send_thread_finish = 0;
|
|
|
|
rt_align(RT_ALIGN_SIZE)
|
|
static char thread3_stack[UTEST_THR_STACK_SIZE];
|
|
static struct rt_thread thread3;
|
|
|
|
rt_align(RT_ALIGN_SIZE)
|
|
static char thread4_stack[UTEST_THR_STACK_SIZE];
|
|
static struct rt_thread thread4;
|
|
#endif /* RT_USING_HEAP */
|
|
|
|
static rt_uint32_t recv_event_times1 = 0, recv_event_times2 = 0;
|
|
static rt_uint32_t static_event_recv_thread_finish = 0, static_event_send_thread_finish = 0;
|
|
|
|
rt_align(RT_ALIGN_SIZE)
|
|
static char thread1_stack[UTEST_THR_STACK_SIZE];
|
|
static struct rt_thread thread1;
|
|
|
|
rt_align(RT_ALIGN_SIZE)
|
|
static char thread2_stack[UTEST_THR_STACK_SIZE];
|
|
static struct rt_thread thread2;
|
|
|
|
#define THREAD_PRIORITY 9
|
|
#define THREAD_TIMESLICE 5
|
|
|
|
static void test_event_init(void)
|
|
{
|
|
rt_err_t result;
|
|
|
|
result = rt_event_init(&static_event, "event", RT_IPC_FLAG_PRIO);
|
|
if (result != RT_EOK)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
result = rt_event_detach(&static_event);
|
|
if (result != RT_EOK)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
|
|
result = rt_event_init(&static_event, "event", RT_IPC_FLAG_FIFO);
|
|
if (result != RT_EOK)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
result = rt_event_detach(&static_event);
|
|
if (result != RT_EOK)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
|
|
uassert_true(1);
|
|
}
|
|
|
|
static void test_event_detach(void)
|
|
{
|
|
rt_err_t result = RT_EOK;
|
|
|
|
result = rt_event_init(&static_event, "event", RT_IPC_FLAG_PRIO);
|
|
if (result != RT_EOK)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
|
|
result = rt_event_detach(&static_event);
|
|
if (result != RT_EOK)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
|
|
uassert_true(1);
|
|
}
|
|
|
|
static void thread1_recv_static_event(void *param)
|
|
{
|
|
rt_uint32_t e;
|
|
|
|
if (rt_event_recv(&static_event, (EVENT_FLAG3 | EVENT_FLAG5),
|
|
RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
|
|
RT_WAITING_FOREVER, &e) != RT_EOK)
|
|
{
|
|
return;
|
|
}
|
|
|
|
recv_event_times1 = e;
|
|
|
|
rt_thread_mdelay(50);
|
|
|
|
if (rt_event_recv(&static_event, (EVENT_FLAG3 | EVENT_FLAG5),
|
|
RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
|
|
RT_WAITING_FOREVER, &e) != RT_EOK)
|
|
{
|
|
return;
|
|
}
|
|
recv_event_times2 = e;
|
|
|
|
static_event_recv_thread_finish = 1;
|
|
}
|
|
|
|
static void thread2_send_static_event(void *param)
|
|
{
|
|
rt_event_send(&static_event, EVENT_FLAG3);
|
|
rt_thread_mdelay(10);
|
|
|
|
rt_event_send(&static_event, EVENT_FLAG5);
|
|
rt_thread_mdelay(10);
|
|
|
|
rt_event_send(&static_event, EVENT_FLAG3);
|
|
|
|
static_event_send_thread_finish = 1;
|
|
}
|
|
|
|
|
|
static void test_static_event_send_recv(void)
|
|
{
|
|
rt_err_t result = RT_EOK;
|
|
|
|
result = rt_event_init(&static_event, "event", RT_IPC_FLAG_PRIO);
|
|
if (result != RT_EOK)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
|
|
rt_thread_init(&thread1,
|
|
"thread1",
|
|
thread1_recv_static_event,
|
|
RT_NULL,
|
|
&thread1_stack[0],
|
|
sizeof(thread1_stack),
|
|
THREAD_PRIORITY - 1, THREAD_TIMESLICE);
|
|
rt_thread_startup(&thread1);
|
|
|
|
rt_thread_init(&thread2,
|
|
"thread2",
|
|
thread2_send_static_event,
|
|
RT_NULL,
|
|
&thread2_stack[0],
|
|
sizeof(thread2_stack),
|
|
THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
rt_thread_startup(&thread2);
|
|
|
|
while (static_event_recv_thread_finish != 1 || static_event_send_thread_finish != 1)
|
|
{
|
|
rt_thread_delay(1);
|
|
}
|
|
|
|
if (recv_event_times1 == EVENT_FLAG3 && recv_event_times2 == (EVENT_FLAG3 | EVENT_FLAG5))
|
|
{
|
|
if (rt_event_detach(&static_event) != RT_EOK)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
uassert_true(1);
|
|
}
|
|
else
|
|
{
|
|
if (rt_event_detach(&static_event) != RT_EOK)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
uassert_false(1);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
#ifdef RT_USING_HEAP
|
|
static void test_event_create(void)
|
|
{
|
|
rt_err_t result = RT_EOK;
|
|
|
|
dynamic_event = rt_event_create("dynamic_event", RT_IPC_FLAG_FIFO);
|
|
if (dynamic_event == RT_NULL)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
|
|
result = rt_event_delete(dynamic_event);
|
|
if (result != RT_EOK)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
|
|
uassert_true(1);
|
|
}
|
|
|
|
static void test_event_delete(void)
|
|
{
|
|
rt_err_t result;
|
|
|
|
dynamic_event = rt_event_create("dynamic_event", RT_IPC_FLAG_FIFO);
|
|
if (dynamic_event == RT_NULL)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
|
|
result = rt_event_delete(dynamic_event);
|
|
if (result != RT_EOK)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
|
|
uassert_true(1);
|
|
}
|
|
|
|
static void thread3_recv_dynamic_event(void *param)
|
|
{
|
|
rt_uint32_t e;
|
|
|
|
if (rt_event_recv(dynamic_event, (EVENT_FLAG3 | EVENT_FLAG5),
|
|
RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
|
|
RT_WAITING_FOREVER, &e) != RT_EOK)
|
|
{
|
|
return;
|
|
}
|
|
|
|
recv_event_times1 = e;
|
|
|
|
rt_thread_mdelay(50);
|
|
|
|
if (rt_event_recv(dynamic_event, (EVENT_FLAG3 | EVENT_FLAG5),
|
|
RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
|
|
RT_WAITING_FOREVER, &e) != RT_EOK)
|
|
{
|
|
return;
|
|
}
|
|
recv_event_times2 = e;
|
|
|
|
dynamic_event_recv_thread_finish = 1;
|
|
}
|
|
|
|
static void thread4_send_dynamic_event(void *param)
|
|
{
|
|
rt_event_send(dynamic_event, EVENT_FLAG3);
|
|
rt_thread_mdelay(10);
|
|
|
|
rt_event_send(dynamic_event, EVENT_FLAG5);
|
|
rt_thread_mdelay(10);
|
|
|
|
rt_event_send(dynamic_event, EVENT_FLAG3);
|
|
|
|
dynamic_event_send_thread_finish = 1;
|
|
}
|
|
|
|
static void test_dynamic_event_send_recv(void)
|
|
{
|
|
dynamic_event = rt_event_create("dynamic_event", RT_IPC_FLAG_PRIO);
|
|
if (dynamic_event == RT_NULL)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
|
|
rt_thread_init(&thread3,
|
|
"thread3",
|
|
thread3_recv_dynamic_event,
|
|
RT_NULL,
|
|
&thread3_stack[0],
|
|
sizeof(thread3_stack),
|
|
THREAD_PRIORITY - 1, THREAD_TIMESLICE);
|
|
rt_thread_startup(&thread3);
|
|
|
|
rt_thread_init(&thread4,
|
|
"thread4",
|
|
thread4_send_dynamic_event,
|
|
RT_NULL,
|
|
&thread4_stack[0],
|
|
sizeof(thread4_stack),
|
|
THREAD_PRIORITY, THREAD_TIMESLICE);
|
|
rt_thread_startup(&thread4);
|
|
|
|
while (dynamic_event_recv_thread_finish != 1 || dynamic_event_send_thread_finish != 1)
|
|
{
|
|
rt_thread_delay(1);
|
|
}
|
|
|
|
if (recv_event_times1 == EVENT_FLAG3 && recv_event_times2 == (EVENT_FLAG3 | EVENT_FLAG5))
|
|
{
|
|
if (rt_event_delete(dynamic_event) != RT_EOK)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
uassert_true(1);
|
|
}
|
|
else
|
|
{
|
|
if (rt_event_delete(dynamic_event) != RT_EOK)
|
|
{
|
|
uassert_false(1);
|
|
}
|
|
uassert_false(1);
|
|
}
|
|
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
static rt_err_t utest_tc_init(void)
|
|
{
|
|
static_event_recv_thread_finish = 0;
|
|
static_event_send_thread_finish = 0;
|
|
#ifdef RT_USING_HEAP
|
|
dynamic_event_recv_thread_finish = 0;
|
|
dynamic_event_send_thread_finish = 0;
|
|
#endif
|
|
return RT_EOK;
|
|
}
|
|
|
|
static rt_err_t utest_tc_cleanup(void)
|
|
{
|
|
return RT_EOK;
|
|
}
|
|
|
|
static void testcase(void)
|
|
{
|
|
UTEST_UNIT_RUN(test_event_init);
|
|
UTEST_UNIT_RUN(test_event_detach);
|
|
UTEST_UNIT_RUN(test_static_event_send_recv);
|
|
#ifdef RT_USING_HEAP
|
|
UTEST_UNIT_RUN(test_event_create);
|
|
UTEST_UNIT_RUN(test_event_delete);
|
|
UTEST_UNIT_RUN(test_dynamic_event_send_recv);
|
|
#endif
|
|
}
|
|
UTEST_TC_EXPORT(testcase, "src.ipc.event_tc", utest_tc_init, utest_tc_cleanup, 60);
|