summaryrefslogtreecommitdiff
path: root/examples/utest
diff options
context:
space:
mode:
Diffstat (limited to 'examples/utest')
-rw-r--r--examples/utest/configs/kernel/ipc.conf3
-rw-r--r--examples/utest/testcases/kernel/Kconfig5
-rw-r--r--examples/utest/testcases/kernel/SConscript3
-rw-r--r--examples/utest/testcases/kernel/event_tc.c344
4 files changed, 354 insertions, 1 deletions
diff --git a/examples/utest/configs/kernel/ipc.conf b/examples/utest/configs/kernel/ipc.conf
index 0dcb6bd052..ac70437df6 100644
--- a/examples/utest/configs/kernel/ipc.conf
+++ b/examples/utest/configs/kernel/ipc.conf
@@ -1,4 +1,5 @@
CONFIG_UTEST_SEMAPHORE_TC=y
-
+CONFIG_UTEST_EVENT_TC=y
# dependencies
CONFIG_RT_USING_SEMAPHORE=y
+CONFIG_RT_USING_EVENT=y
diff --git a/examples/utest/testcases/kernel/Kconfig b/examples/utest/testcases/kernel/Kconfig
index 97464ecd8a..1906911ed7 100644
--- a/examples/utest/testcases/kernel/Kconfig
+++ b/examples/utest/testcases/kernel/Kconfig
@@ -10,4 +10,9 @@ config UTEST_SEMAPHORE_TC
default n
depends on RT_USING_SEMAPHORE
+config UTEST_EVENT_TC
+ bool "event test"
+ default n
+ depends on RT_USING_EVENT
+
endmenu
diff --git a/examples/utest/testcases/kernel/SConscript b/examples/utest/testcases/kernel/SConscript
index ad6c959f4c..8b312781f9 100644
--- a/examples/utest/testcases/kernel/SConscript
+++ b/examples/utest/testcases/kernel/SConscript
@@ -11,6 +11,9 @@ if GetDepend(['UTEST_MEMHEAP_TC']):
if GetDepend(['UTEST_SEMAPHORE_TC']):
src += ['semaphore_tc.c']
+if GetDepend(['UTEST_EVENT_TC']):
+ src += ['event_tc.c']
+
CPPPATH = [cwd]
group = DefineGroup('utestcases', src, depend = [], CPPPATH = CPPPATH)
diff --git a/examples/utest/testcases/kernel/event_tc.c b/examples/utest/testcases/kernel/event_tc.c
new file mode 100644
index 0000000000..9847529214
--- /dev/null
+++ b/examples/utest/testcases/kernel/event_tc.c
@@ -0,0 +1,344 @@
+/*
+ * 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
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include <stdlib.h>
+
+#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;
+
+ALIGN(RT_ALIGN_SIZE)
+static char thread3_stack[1024];
+static struct rt_thread thread3;
+
+ALIGN(RT_ALIGN_SIZE)
+static char thread4_stack[1024];
+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;
+
+ALIGN(RT_ALIGN_SIZE)
+static char thread1_stack[1024];
+static struct rt_thread thread1;
+
+ALIGN(RT_ALIGN_SIZE)
+static char thread2_stack[1024];
+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);
generated by cgit v1.3.1 (git 2.54.0) at 2026-10-30 13:26:40 +0000