From 141e6a03e90671ec8f451e401fee099e1d30697d Mon Sep 17 00:00:00 2001 From: tyustli <1225613647@qq.com> Date: Thu, 12 Aug 2021 11:43:15 +0800 Subject: [add] add semaphore testcase src code and Kconfig --- examples/utest/testcases/kernel/Kconfig | 5 + examples/utest/testcases/kernel/SConscript | 3 + examples/utest/testcases/kernel/semaphore_tc.c | 559 +++++++++++++++++++++++++ 3 files changed, 567 insertions(+) create mode 100644 examples/utest/testcases/kernel/semaphore_tc.c (limited to 'examples') diff --git a/examples/utest/testcases/kernel/Kconfig b/examples/utest/testcases/kernel/Kconfig index 14334af16f..97464ecd8a 100644 --- a/examples/utest/testcases/kernel/Kconfig +++ b/examples/utest/testcases/kernel/Kconfig @@ -5,4 +5,9 @@ config UTEST_MEMHEAP_TC default y depends on RT_USING_MEMHEAP +config UTEST_SEMAPHORE_TC + bool "semaphore test" + default n + depends on RT_USING_SEMAPHORE + endmenu diff --git a/examples/utest/testcases/kernel/SConscript b/examples/utest/testcases/kernel/SConscript index 9411cdd9a0..ad6c959f4c 100644 --- a/examples/utest/testcases/kernel/SConscript +++ b/examples/utest/testcases/kernel/SConscript @@ -8,6 +8,9 @@ src = Split(''' if GetDepend(['UTEST_MEMHEAP_TC']): src += ['memheap_tc.c'] +if GetDepend(['UTEST_SEMAPHORE_TC']): + src += ['semaphore_tc.c'] + CPPPATH = [cwd] group = DefineGroup('utestcases', src, depend = [], CPPPATH = CPPPATH) 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 +#include +#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); -- cgit v1.3.1 From 8d1f0758d695d84c536a4b3f12c0bc7a97d1df7c Mon Sep 17 00:00:00 2001 From: tyustli <1225613647@qq.com> Date: Thu, 12 Aug 2021 19:48:27 +0800 Subject: [add] semaphore testcase ci config --- .github/workflows/action_utest.yml | 1 + examples/utest/configs/kernel/mem.conf | 2 ++ 2 files changed, 3 insertions(+) (limited to 'examples') diff --git a/.github/workflows/action_utest.yml b/.github/workflows/action_utest.yml index 7d0e2c44d8..985b82e831 100644 --- a/.github/workflows/action_utest.yml +++ b/.github/workflows/action_utest.yml @@ -12,6 +12,7 @@ jobs: matrix: legs: - {UTEST: "kernel/mem", RTT_BSP: "bsp/qemu-vexpress-a9", QEMU_ARCH: "arm", QEMU_MACHINE: "vexpress-a9", CONFIG_FILE: "kernel/mem.conf", SD_FILE: "sd.bin"} + - {UTEST: "kernel/semaphore", RTT_BSP: "bsp/qemu-vexpress-a9", QEMU_ARCH: "arm", QEMU_MACHINE: "vexpress-a9", CONFIG_FILE: "kernel/mem.conf", SD_FILE: "sd.bin"} - {UTEST: "components/utest", RTT_BSP: "bsp/qemu-vexpress-a9", QEMU_ARCH: "arm", QEMU_MACHINE: "vexpress-a9", CONFIG_FILE: "utest_self/self.conf", SD_FILE: "sd.bin"} - {UTEST: "kernel/mem/riscv64", RTT_BSP: "bsp/qemu-riscv-virt64", QEMU_ARCH: "riscv64", QEMU_MACHINE: "virt", CONFIG_FILE: "kernel/mem.conf", SD_FILE: "None"} env: diff --git a/examples/utest/configs/kernel/mem.conf b/examples/utest/configs/kernel/mem.conf index 1a311ab9dd..786532195d 100644 --- a/examples/utest/configs/kernel/mem.conf +++ b/examples/utest/configs/kernel/mem.conf @@ -1,4 +1,6 @@ CONFIG_UTEST_MEMHEAP_TC=y +CONFIG_UTEST_SEMAPHORE_TC=y # dependencies CONFIG_RT_USING_MEMHEAP=y +CONFIG_RT_USING_SEMAPHORE=y -- cgit v1.3.1 From 5074c86dcebc13cefa11114b29c918971d4da3b6 Mon Sep 17 00:00:00 2001 From: guozhanxin Date: Sun, 15 Aug 2021 16:16:00 +0800 Subject: [ci][autotest] add ipc.conf --- .github/workflows/action_utest.yml | 2 +- examples/utest/configs/kernel/ipc.conf | 4 ++++ examples/utest/configs/kernel/mem.conf | 2 -- 3 files changed, 5 insertions(+), 3 deletions(-) create mode 100644 examples/utest/configs/kernel/ipc.conf (limited to 'examples') diff --git a/.github/workflows/action_utest.yml b/.github/workflows/action_utest.yml index 985b82e831..2ff0bd8185 100644 --- a/.github/workflows/action_utest.yml +++ b/.github/workflows/action_utest.yml @@ -12,7 +12,7 @@ jobs: matrix: legs: - {UTEST: "kernel/mem", RTT_BSP: "bsp/qemu-vexpress-a9", QEMU_ARCH: "arm", QEMU_MACHINE: "vexpress-a9", CONFIG_FILE: "kernel/mem.conf", SD_FILE: "sd.bin"} - - {UTEST: "kernel/semaphore", RTT_BSP: "bsp/qemu-vexpress-a9", QEMU_ARCH: "arm", QEMU_MACHINE: "vexpress-a9", CONFIG_FILE: "kernel/mem.conf", SD_FILE: "sd.bin"} + - {UTEST: "kernel/ipc", RTT_BSP: "bsp/qemu-vexpress-a9", QEMU_ARCH: "arm", QEMU_MACHINE: "vexpress-a9", CONFIG_FILE: "kernel/ipc.conf", SD_FILE: "sd.bin"} - {UTEST: "components/utest", RTT_BSP: "bsp/qemu-vexpress-a9", QEMU_ARCH: "arm", QEMU_MACHINE: "vexpress-a9", CONFIG_FILE: "utest_self/self.conf", SD_FILE: "sd.bin"} - {UTEST: "kernel/mem/riscv64", RTT_BSP: "bsp/qemu-riscv-virt64", QEMU_ARCH: "riscv64", QEMU_MACHINE: "virt", CONFIG_FILE: "kernel/mem.conf", SD_FILE: "None"} env: diff --git a/examples/utest/configs/kernel/ipc.conf b/examples/utest/configs/kernel/ipc.conf new file mode 100644 index 0000000000..0dcb6bd052 --- /dev/null +++ b/examples/utest/configs/kernel/ipc.conf @@ -0,0 +1,4 @@ +CONFIG_UTEST_SEMAPHORE_TC=y + +# dependencies +CONFIG_RT_USING_SEMAPHORE=y diff --git a/examples/utest/configs/kernel/mem.conf b/examples/utest/configs/kernel/mem.conf index 786532195d..1a311ab9dd 100644 --- a/examples/utest/configs/kernel/mem.conf +++ b/examples/utest/configs/kernel/mem.conf @@ -1,6 +1,4 @@ CONFIG_UTEST_MEMHEAP_TC=y -CONFIG_UTEST_SEMAPHORE_TC=y # dependencies CONFIG_RT_USING_MEMHEAP=y -CONFIG_RT_USING_SEMAPHORE=y -- cgit v1.3.1 From f8c12d0f21011f7f980e9da90b144cbeaad317a0 Mon Sep 17 00:00:00 2001 From: liukangcc Date: Tue, 17 Aug 2021 14:59:36 +0800 Subject: [add] event test case. --- examples/utest/configs/kernel/ipc.conf | 3 +- examples/utest/testcases/kernel/Kconfig | 5 + examples/utest/testcases/kernel/SConscript | 3 + examples/utest/testcases/kernel/event_tc.c | 344 +++++++++++++++++++++++++++++ 4 files changed, 354 insertions(+), 1 deletion(-) create mode 100644 examples/utest/testcases/kernel/event_tc.c (limited to 'examples') 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 +#include "utest.h" +#include + +#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); -- cgit v1.3.1 From c8d73a76ced80f3795fd2ce738a641d18fe1fde0 Mon Sep 17 00:00:00 2001 From: supperthomas <78900636@qq.com> Date: Tue, 17 Aug 2021 22:14:33 +0800 Subject: add the utest of irq --- examples/utest/testcases/kernel/Kconfig | 6 ++++ examples/utest/testcases/kernel/SConscript | 4 +++ examples/utest/testcases/kernel/irq_tc.c | 55 ++++++++++++++++++++++++++++++ 3 files changed, 65 insertions(+) create mode 100644 examples/utest/testcases/kernel/irq_tc.c (limited to 'examples') diff --git a/examples/utest/testcases/kernel/Kconfig b/examples/utest/testcases/kernel/Kconfig index 1906911ed7..fd16b95c68 100644 --- a/examples/utest/testcases/kernel/Kconfig +++ b/examples/utest/testcases/kernel/Kconfig @@ -5,14 +5,20 @@ 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 8b312781f9..565d2d9774 100644 --- a/examples/utest/testcases/kernel/SConscript +++ b/examples/utest/testcases/kernel/SConscript @@ -8,12 +8,16 @@ 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/irq_tc.c b/examples/utest/testcases/kernel/irq_tc.c new file mode 100644 index 0000000000..2aebecba7c --- /dev/null +++ b/examples/utest/testcases/kernel/irq_tc.c @@ -0,0 +1,55 @@ +/* + * 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 +#include "utest.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) +{ + rt_interrupt_enter_sethook(irq_callback); + rt_thread_delay(2); + LOG_D("start irq_test OK!\n"); + 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); +} + + + + + +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 testcase(void) +{ + UTEST_UNIT_RUN(irq_test); +} +UTEST_TC_EXPORT(testcase, "testcases.kernel.irq_tc", utest_tc_init, utest_tc_cleanup, 10); -- cgit v1.3.1 From 210ff3c9df1598ae53c442b34a3785c5bd270d71 Mon Sep 17 00:00:00 2001 From: supperthomas <78900636@qq.com> Date: Tue, 17 Aug 2021 22:19:34 +0800 Subject: fix the space --- examples/utest/testcases/kernel/irq_tc.c | 4 ---- 1 file changed, 4 deletions(-) (limited to 'examples') diff --git a/examples/utest/testcases/kernel/irq_tc.c b/examples/utest/testcases/kernel/irq_tc.c index 2aebecba7c..a66e844a81 100644 --- a/examples/utest/testcases/kernel/irq_tc.c +++ b/examples/utest/testcases/kernel/irq_tc.c @@ -32,10 +32,6 @@ static void irq_test(void) uassert_int_not_equal(0, max_get_nest_count); } - - - - static rt_err_t utest_tc_init(void) { irq_count = 0; -- cgit v1.3.1 From 39353f5c1425ac4aec571056636dc78175ba83fa Mon Sep 17 00:00:00 2001 From: supperthomas <78900636@qq.com> Date: Wed, 18 Aug 2021 20:14:59 +0800 Subject: fix the space --- examples/utest/testcases/kernel/irq_tc.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) (limited to 'examples') diff --git a/examples/utest/testcases/kernel/irq_tc.c b/examples/utest/testcases/kernel/irq_tc.c index a66e844a81..27a9b64b5b 100644 --- a/examples/utest/testcases/kernel/irq_tc.c +++ b/examples/utest/testcases/kernel/irq_tc.c @@ -11,15 +11,16 @@ #include #include "utest.h" #define UTEST_NAME "irq_tc" -static uint32_t irq_count=0; +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++; + irq_count ++; } static void irq_test(void) @@ -27,8 +28,8 @@ static void irq_test(void) rt_interrupt_enter_sethook(irq_callback); rt_thread_delay(2); LOG_D("start irq_test OK!\n"); - 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); + 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); } -- cgit v1.3.1 From b4a46f8bbe548c18ce28aa721cc3819ba1980bb5 Mon Sep 17 00:00:00 2001 From: supperthomas <78900636@qq.com> Date: Thu, 19 Aug 2021 21:19:28 +0800 Subject: add the interrupt disable --- examples/utest/testcases/kernel/Kconfig | 2 -- examples/utest/testcases/kernel/SConscript | 1 - examples/utest/testcases/kernel/irq_tc.c | 30 ++++++++++++++++++++++++++++-- 3 files changed, 28 insertions(+), 5 deletions(-) (limited to 'examples') diff --git a/examples/utest/testcases/kernel/Kconfig b/examples/utest/testcases/kernel/Kconfig index fd16b95c68..e8dd3c2e97 100644 --- a/examples/utest/testcases/kernel/Kconfig +++ b/examples/utest/testcases/kernel/Kconfig @@ -14,11 +14,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 565d2d9774..26d5ddbf17 100644 --- a/examples/utest/testcases/kernel/SConscript +++ b/examples/utest/testcases/kernel/SConscript @@ -17,7 +17,6 @@ if GetDepend(['UTEST_SEMAPHORE_TC']): 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/irq_tc.c b/examples/utest/testcases/kernel/irq_tc.c index 27a9b64b5b..86b6c144f1 100644 --- a/examples/utest/testcases/kernel/irq_tc.c +++ b/examples/utest/testcases/kernel/irq_tc.c @@ -10,6 +10,8 @@ #include #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; @@ -25,12 +27,16 @@ static void irq_callback() static void irq_test(void) { + irq_count = 0; rt_interrupt_enter_sethook(irq_callback); - rt_thread_delay(2); - LOG_D("start irq_test OK!\n"); + 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) @@ -45,8 +51,28 @@ 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); -- cgit v1.3.1