summaryrefslogtreecommitdiff
path: root/examples/utest
diff options
context:
space:
mode:
Diffstat (limited to 'examples/utest')
-rw-r--r--examples/utest/configs/kernel/ipc.conf5
-rw-r--r--examples/utest/testcases/kernel/Kconfig14
-rw-r--r--examples/utest/testcases/kernel/SConscript9
-rw-r--r--examples/utest/testcases/kernel/event_tc.c344
-rw-r--r--examples/utest/testcases/kernel/irq_tc.c78
-rw-r--r--examples/utest/testcases/kernel/semaphore_tc.c559
6 files changed, 1009 insertions, 0 deletions
diff --git a/examples/utest/configs/kernel/ipc.conf b/examples/utest/configs/kernel/ipc.conf
new file mode 100644
index 0000000000..ac70437df6
--- /dev/null
+++ b/examples/utest/configs/kernel/ipc.conf
@@ -0,0 +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 14334af16f..e8dd3c2e97 100644
--- a/examples/utest/testcases/kernel/Kconfig
+++ b/examples/utest/testcases/kernel/Kconfig
@@ -5,4 +5,18 @@ config UTEST_MEMHEAP_TC
default y
depends on RT_USING_MEMHEAP
+config UTEST_IRQ_TC
+ bool "IRQ test"
+ default n
+
+config UTEST_SEMAPHORE_TC
+ bool "semaphore test"
+ 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 9411cdd9a0..26d5ddbf17 100644
--- a/examples/utest/testcases/kernel/SConscript
+++ b/examples/utest/testcases/kernel/SConscript
@@ -8,6 +8,15 @@ src = Split('''
if GetDepend(['UTEST_MEMHEAP_TC']):
src += ['memheap_tc.c']
+if GetDepend(['UTEST_IRQ_TC']):
+ src += ['irq_tc.c']
+
+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);
diff --git a/examples/utest/testcases/kernel/irq_tc.c b/examples/utest/testcases/kernel/irq_tc.c
new file mode 100644
index 0000000000..86b6c144f1
--- /dev/null
+++ b/examples/utest/testcases/kernel/irq_tc.c
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-08-15 supperthomas add irq_test
+ */
+
+#include <rtthread.h>
+#include "utest.h"
+#include "rthw.h"
+
+#define UTEST_NAME "irq_tc"
+static uint32_t irq_count = 0;
+static uint32_t max_get_nest_count = 0;
+
+static void irq_callback()
+{
+ if(rt_interrupt_get_nest() > max_get_nest_count)
+ {
+ max_get_nest_count = rt_interrupt_get_nest();
+ }
+ irq_count ++;
+}
+
+static void irq_test(void)
+{
+ irq_count = 0;
+ rt_interrupt_enter_sethook(irq_callback);
+ rt_interrupt_leave_sethook(irq_callback);
+ rt_thread_mdelay(2);
+ LOG_D("%s test irq_test! irq_count %d max_get_nest_count %d\n", UTEST_NAME, irq_count, max_get_nest_count);
+ uassert_int_not_equal(0, irq_count);
+ uassert_int_not_equal(0, max_get_nest_count);
+ rt_interrupt_enter_sethook(RT_NULL);
+ rt_interrupt_leave_sethook(RT_NULL);
+ LOG_D("irq_test OK!\n");
+}
+
+static rt_err_t utest_tc_init(void)
+{
+ irq_count = 0;
+ max_get_nest_count = 0;
+ return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+ return RT_EOK;
+}
+
+static void interrupt_test(void)
+{
+ rt_base_t level;
+ uint32_t i = 1000;
+
+ rt_interrupt_enter_sethook(irq_callback);
+ rt_interrupt_leave_sethook(irq_callback);
+ irq_count = 0;
+ level = rt_hw_interrupt_disable();
+ while(i)
+ {
+ i --;
+ }
+ uassert_int_equal(0, irq_count);
+ rt_hw_interrupt_enable(level);
+ rt_interrupt_enter_sethook(RT_NULL);
+ rt_interrupt_leave_sethook(RT_NULL);
+
+}
+static void testcase(void)
+{
+ UTEST_UNIT_RUN(irq_test);
+ UTEST_UNIT_RUN(interrupt_test);
+}
+UTEST_TC_EXPORT(testcase, "testcases.kernel.irq_tc", utest_tc_init, utest_tc_cleanup, 10);
diff --git a/examples/utest/testcases/kernel/semaphore_tc.c b/examples/utest/testcases/kernel/semaphore_tc.c
new file mode 100644
index 0000000000..2992831d87
--- /dev/null
+++ b/examples/utest/testcases/kernel/semaphore_tc.c
@@ -0,0 +1,559 @@
+/*
+ * Copyright (c) 2006-2019, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-08-12 luckyzjq the first version
+ */
+
+#include <rtthread.h>
+#include <stdlib.h>
+#include "utest.h"
+
+static struct rt_semaphore static_semaphore;
+#ifdef RT_USING_HEAP
+static rt_sem_t dynamic_semaphore;
+#endif /* RT_USING_HEAP */
+
+static void test_static_semaphore_init(void)
+{
+ rt_err_t result;
+ int rand_num = rand() % 0x10000;
+
+ for (int i = 0; i < rand_num; i++)
+ {
+ result = rt_sem_init(&static_semaphore, "static_sem", i, RT_IPC_FLAG_PRIO);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ break;
+ }
+ rt_sem_detach(&static_semaphore);
+
+ result = rt_sem_init(&static_semaphore, "static_sem", i, RT_IPC_FLAG_FIFO);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ break;
+ }
+ rt_sem_detach(&static_semaphore);
+ }
+
+ uassert_true(RT_TRUE);
+}
+
+static void test_static_semaphore_detach(void)
+{
+ rt_err_t result;
+ int rand_num = rand() % 0x10000;
+
+ for (int i = 0; i < rand_num; i++)
+ {
+ result = rt_sem_init(&static_semaphore, "static_sem", i, RT_IPC_FLAG_PRIO);
+ if (RT_EOK != result)
+ {
+ break;
+ }
+
+ result = rt_sem_detach(&static_semaphore);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ break;
+ }
+
+ result = rt_sem_init(&static_semaphore, "static_sem", i, RT_IPC_FLAG_FIFO);
+ if (RT_EOK != result)
+ {
+ break;
+ }
+ result = rt_sem_detach(&static_semaphore);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ break;
+ }
+ }
+
+ uassert_true(RT_TRUE);
+}
+
+static void test_static_semaphore_take(void)
+{
+ rt_err_t result;
+ result = rt_sem_init(&static_semaphore, "static_sem", 1, RT_IPC_FLAG_PRIO);
+ if (RT_EOK == result)
+ {
+ /* first take */
+ result = rt_sem_take(&static_semaphore, RT_WAITING_FOREVER);
+ if (RT_EOK != result)
+ uassert_true(RT_FALSE);
+ /* second take */
+ result = rt_sem_take(&static_semaphore, 100);
+ if (-RT_ETIMEOUT != result)
+ uassert_true(RT_FALSE);
+ }
+ else
+ {
+ return;
+ }
+
+ rt_sem_detach(&static_semaphore);
+ uassert_true(RT_TRUE);
+
+ return;
+}
+
+static void test_static_semaphore_trytake(void)
+{
+ rt_err_t result;
+ result = rt_sem_init(&static_semaphore, "static_sem", 1, RT_IPC_FLAG_PRIO);
+ if (RT_EOK == result)
+ {
+ /* first take */
+ result = rt_sem_trytake(&static_semaphore);
+ if (RT_EOK != result)
+ uassert_true(RT_FALSE);
+ /* second take */
+ result = rt_sem_trytake(&static_semaphore);
+ if (-RT_ETIMEOUT != result)
+ uassert_true(RT_FALSE);
+ }
+ else
+ {
+ return;
+ }
+
+ rt_sem_detach(&static_semaphore);
+ uassert_true(RT_TRUE);
+
+ return;
+}
+
+static void test_static_semaphore_release(void)
+{
+ rt_err_t result;
+ result = rt_sem_init(&static_semaphore, "static_sem", 0, RT_IPC_FLAG_PRIO);
+ if (RT_EOK == result)
+ {
+ /* first take */
+ result = rt_sem_take(&static_semaphore, 100);
+ if (-RT_ETIMEOUT != result)
+ uassert_true(RT_FALSE);
+
+ /* release */
+ result = rt_sem_release(&static_semaphore);
+ if (RT_EOK != result)
+ uassert_true(RT_FALSE);
+
+ /* second take */
+ result = rt_sem_take(&static_semaphore, RT_WAITING_FOREVER);
+ if (RT_EOK != result)
+ uassert_true(RT_FALSE);
+ }
+ else
+ {
+ return;
+ }
+
+ rt_sem_detach(&static_semaphore);
+ uassert_true(RT_TRUE);
+
+ return;
+}
+
+static void test_static_semaphore_control(void)
+{
+ rt_err_t result;
+ int value = 0;
+
+ value = rand() % 100;
+ result = rt_sem_init(&static_semaphore, "static_sem", 1, RT_IPC_FLAG_PRIO);
+ if (RT_EOK == result)
+ {
+ result = rt_sem_control(&static_semaphore, RT_IPC_CMD_RESET, &value);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ }
+ }
+ else
+ {
+ return;
+ }
+
+ for (int i = 0; i < value; i++)
+ {
+ result = rt_sem_take(&static_semaphore, 10);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ }
+ }
+
+ rt_sem_detach(&static_semaphore);
+ uassert_true(RT_TRUE);
+}
+
+static void static_release_isr_hardware_callback(void *param)
+{
+ rt_err_t result;
+
+ result = rt_sem_release(&static_semaphore);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ }
+}
+
+static void static_release_isr_software_callback(void *param)
+{
+ rt_err_t result;
+
+ result = rt_sem_release(&static_semaphore);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ }
+}
+
+static void test_static_semaphore_release_isr(void)
+{
+ rt_err_t result;
+ rt_timer_t hardware_timer;
+ rt_timer_t software_timer;
+
+ /* create timer */
+ hardware_timer = rt_timer_create("release_isr",
+ static_release_isr_hardware_callback,
+ RT_NULL,
+ 100,
+ RT_TIMER_FLAG_HARD_TIMER | RT_TIMER_FLAG_ONE_SHOT);
+ software_timer = rt_timer_create("release_isr",
+ static_release_isr_software_callback,
+ RT_NULL,
+ 100,
+ RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_ONE_SHOT);
+ /* start tiemr */
+ if (hardware_timer)
+ rt_timer_start(hardware_timer);
+ if (software_timer)
+ rt_timer_start(software_timer);
+
+ result = rt_sem_init(&static_semaphore, "static_sem", 0, RT_IPC_FLAG_PRIO);
+ if (RT_EOK == result)
+ {
+ for (int i = 0; i < 2; i++)
+ {
+ result = rt_sem_take(&static_semaphore, 1000);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ }
+ }
+ }
+ else
+ {
+ return;
+ }
+
+ rt_sem_detach(&static_semaphore);
+ rt_timer_delete(hardware_timer);
+ rt_timer_delete(software_timer);
+
+ uassert_true(RT_TRUE);
+}
+
+#ifdef RT_USING_HEAP
+static void test_dynamic_semaphore_create(void)
+{
+ rt_err_t result;
+ int rand_num = rand() % 0x10000;
+
+ for (int i = 0; i < rand_num; i++)
+ {
+ dynamic_semaphore = rt_sem_create("static_sem", i, RT_IPC_FLAG_PRIO);
+ if (RT_NULL == dynamic_semaphore)
+ {
+ uassert_true(RT_FALSE);
+ break;
+ }
+ rt_sem_delete(dynamic_semaphore);
+
+ dynamic_semaphore = rt_sem_create("static_sem", i, RT_IPC_FLAG_FIFO);
+ if (RT_NULL == dynamic_semaphore)
+ {
+ uassert_true(RT_FALSE);
+ break;
+ }
+ rt_sem_delete(dynamic_semaphore);
+ }
+
+ uassert_true(RT_TRUE);
+}
+
+static void test_dynamic_semaphore_delete(void)
+{
+ rt_err_t result;
+ int rand_num = rand() % 0x10000;
+
+ for (int i = 0; i < rand_num; i++)
+ {
+ dynamic_semaphore = rt_sem_create("static_sem", i, RT_IPC_FLAG_PRIO);
+ if (RT_NULL == dynamic_semaphore)
+ {
+ break;
+ }
+
+ result = rt_sem_delete(dynamic_semaphore);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ break;
+ }
+
+ dynamic_semaphore = rt_sem_create("static_sem", i, RT_IPC_FLAG_FIFO);
+ if (RT_NULL == dynamic_semaphore)
+ {
+ break;
+ }
+ result = rt_sem_delete(dynamic_semaphore);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ break;
+ }
+ }
+
+ uassert_true(RT_TRUE);
+}
+
+static void test_dynamic_semaphore_take(void)
+{
+ rt_err_t result;
+ dynamic_semaphore = rt_sem_create("static_sem", 1, RT_IPC_FLAG_PRIO);
+ if (RT_NULL != dynamic_semaphore)
+ {
+ /* first take */
+ result = rt_sem_take(dynamic_semaphore, RT_WAITING_FOREVER);
+ if (RT_EOK != result)
+ uassert_true(RT_FALSE);
+ /* second take */
+ result = rt_sem_take(dynamic_semaphore, 100);
+ if (-RT_ETIMEOUT != result)
+ uassert_true(RT_FALSE);
+ }
+ else
+ {
+ return;
+ }
+
+ rt_sem_delete(dynamic_semaphore);
+ uassert_true(RT_TRUE);
+
+ return;
+}
+
+static void test_dynamic_semaphore_trytake(void)
+{
+ rt_err_t result;
+ dynamic_semaphore = rt_sem_create("static_sem", 1, RT_IPC_FLAG_PRIO);
+ if (RT_NULL != dynamic_semaphore)
+ {
+ /* first take */
+ result = rt_sem_trytake(dynamic_semaphore);
+ if (RT_EOK != result)
+ uassert_true(RT_FALSE);
+ /* second take */
+ result = rt_sem_trytake(dynamic_semaphore);
+ if (-RT_ETIMEOUT != result)
+ uassert_true(RT_FALSE);
+ }
+ else
+ {
+ return;
+ }
+
+ rt_sem_delete(dynamic_semaphore);
+ uassert_true(RT_TRUE);
+
+ return;
+}
+
+static void test_dynamic_semaphore_release(void)
+{
+ rt_err_t result;
+ dynamic_semaphore = rt_sem_create("static_sem", 0, RT_IPC_FLAG_PRIO);
+ if (RT_NULL != dynamic_semaphore)
+ {
+ /* first take */
+ result = rt_sem_take(dynamic_semaphore, 100);
+ if (-RT_ETIMEOUT != result)
+ uassert_true(RT_FALSE);
+
+ /* release */
+ result = rt_sem_release(dynamic_semaphore);
+ if (RT_EOK != result)
+ uassert_true(RT_FALSE);
+
+ /* second take */
+ result = rt_sem_take(dynamic_semaphore, RT_WAITING_FOREVER);
+ if (RT_EOK != result)
+ uassert_true(RT_FALSE);
+ }
+ else
+ {
+ return;
+ }
+
+ rt_sem_delete(dynamic_semaphore);
+ uassert_true(RT_TRUE);
+
+ return;
+}
+
+static void test_dynamic_semaphore_control(void)
+{
+ rt_err_t result;
+ int value = 0;
+
+ value = rand() % 100;
+ dynamic_semaphore = rt_sem_create("static_sem", 1, RT_IPC_FLAG_PRIO);
+ if (RT_NULL != dynamic_semaphore)
+ {
+ result = rt_sem_control(dynamic_semaphore, RT_IPC_CMD_RESET, &value);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ }
+ }
+ else
+ {
+ return;
+ }
+
+ for (int i = 0; i < value; i++)
+ {
+ result = rt_sem_take(dynamic_semaphore, 10);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ }
+ }
+
+ rt_sem_delete(dynamic_semaphore);
+ uassert_true(RT_TRUE);
+}
+
+static void dynamic_release_isr_hardware_callback(void *param)
+{
+ rt_err_t result;
+
+ result = rt_sem_release(dynamic_semaphore);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ }
+}
+
+static void dynamic_release_isr_software_callback(void *param)
+{
+ rt_err_t result;
+
+ result = rt_sem_release(dynamic_semaphore);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ }
+}
+
+static void test_dynamic_semaphore_release_isr(void)
+{
+ rt_err_t result;
+ rt_timer_t hardware_timer;
+ rt_timer_t software_timer;
+
+ /* create timer */
+ hardware_timer = rt_timer_create("release_isr",
+ dynamic_release_isr_hardware_callback,
+ RT_NULL,
+ 100,
+ RT_TIMER_FLAG_HARD_TIMER | RT_TIMER_FLAG_ONE_SHOT);
+ software_timer = rt_timer_create("release_isr",
+ dynamic_release_isr_software_callback,
+ RT_NULL,
+ 100,
+ RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_ONE_SHOT);
+ /* start tiemr */
+ if (hardware_timer)
+ rt_timer_start(hardware_timer);
+ if (software_timer)
+ rt_timer_start(software_timer);
+
+ dynamic_semaphore = rt_sem_create("static_sem", 0, RT_IPC_FLAG_PRIO);
+ if (RT_NULL != dynamic_semaphore)
+ {
+ for (int i = 0; i < 2; i++)
+ {
+ result = rt_sem_take(dynamic_semaphore, 1000);
+ if (RT_EOK != result)
+ {
+ uassert_true(RT_FALSE);
+ }
+ }
+ }
+ else
+ {
+ return;
+ }
+
+ rt_sem_delete(dynamic_semaphore);
+ rt_timer_delete(hardware_timer);
+ rt_timer_delete(software_timer);
+
+ uassert_true(RT_TRUE);
+}
+
+#endif /* RT_USING_HEAP */
+
+static rt_err_t utest_tc_init(void)
+{
+#ifdef RT_USING_HEAP
+ dynamic_semaphore = RT_NULL;
+#endif /* RT_USING_HEAP */
+
+ return RT_EOK;
+}
+
+static rt_err_t utest_tc_cleanup(void)
+{
+#ifdef RT_USING_HEAP
+ dynamic_semaphore = RT_NULL;
+#endif /* RT_USING_HEAP */
+
+ return RT_EOK;
+}
+
+static void testcase(void)
+{
+ UTEST_UNIT_RUN(test_static_semaphore_init);
+ UTEST_UNIT_RUN(test_static_semaphore_take);
+ UTEST_UNIT_RUN(test_static_semaphore_release);
+ UTEST_UNIT_RUN(test_static_semaphore_detach);
+ UTEST_UNIT_RUN(test_static_semaphore_trytake);
+ UTEST_UNIT_RUN(test_static_semaphore_control);
+ UTEST_UNIT_RUN(test_static_semaphore_release_isr);
+
+#ifdef RT_USING_HEAP
+ UTEST_UNIT_RUN(test_dynamic_semaphore_create);
+ UTEST_UNIT_RUN(test_dynamic_semaphore_take);
+ UTEST_UNIT_RUN(test_dynamic_semaphore_release);
+ UTEST_UNIT_RUN(test_dynamic_semaphore_delete);
+ UTEST_UNIT_RUN(test_dynamic_semaphore_trytake);
+ UTEST_UNIT_RUN(test_dynamic_semaphore_control);
+ UTEST_UNIT_RUN(test_dynamic_semaphore_release_isr);
+#endif /* RT_USING_HEAP */
+}
+UTEST_TC_EXPORT(testcase, "testcases.kernel.semaphore_tc", utest_tc_init, utest_tc_cleanup, 1000);
generated by cgit v1.3.1 (git 2.54.0) at 2026-10-30 15:28:37 +0000