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/SConscript | 3 +++ 1 file changed, 3 insertions(+) (limited to 'examples/utest/testcases/kernel/SConscript') 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) -- 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/utest/testcases/kernel/SConscript') 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/utest/testcases/kernel/SConscript') 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 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/utest/testcases/kernel/SConscript') 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 From 0596a98c80c53ef7f62b09879cb147ece597142e Mon Sep 17 00:00:00 2001 From: tyustli <1225613647@qq.com> Date: Mon, 23 Aug 2021 12:37:54 +0800 Subject: [add]kernel timer testcase --- examples/utest/testcases/kernel/Kconfig | 4 + examples/utest/testcases/kernel/SConscript | 3 + examples/utest/testcases/kernel/timer_tc.c | 521 +++++++++++++++++++++++++++++ 3 files changed, 528 insertions(+) create mode 100644 examples/utest/testcases/kernel/timer_tc.c (limited to 'examples/utest/testcases/kernel/SConscript') diff --git a/examples/utest/testcases/kernel/Kconfig b/examples/utest/testcases/kernel/Kconfig index e8dd3c2e97..1854721193 100644 --- a/examples/utest/testcases/kernel/Kconfig +++ b/examples/utest/testcases/kernel/Kconfig @@ -19,4 +19,8 @@ config UTEST_EVENT_TC default n depends on RT_USING_EVENT +config UTEST_TIMER_TC + bool "timer test" + default n + endmenu diff --git a/examples/utest/testcases/kernel/SConscript b/examples/utest/testcases/kernel/SConscript index 26d5ddbf17..758dea4d3f 100644 --- a/examples/utest/testcases/kernel/SConscript +++ b/examples/utest/testcases/kernel/SConscript @@ -17,6 +17,9 @@ if GetDepend(['UTEST_SEMAPHORE_TC']): if GetDepend(['UTEST_EVENT_TC']): src += ['event_tc.c'] +if GetDepend(['UTEST_TIMER_TC']): + src += ['timer_tc.c'] + CPPPATH = [cwd] group = DefineGroup('utestcases', src, depend = [], CPPPATH = CPPPATH) diff --git a/examples/utest/testcases/kernel/timer_tc.c b/examples/utest/testcases/kernel/timer_tc.c new file mode 100644 index 0000000000..f8c5728de6 --- /dev/null +++ b/examples/utest/testcases/kernel/timer_tc.c @@ -0,0 +1,521 @@ +/* + * 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 rt_uint8_t timer_flag_oneshot[] = { + RT_TIMER_FLAG_ONE_SHOT, + RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_HARD_TIMER, + RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER, +}; + +static rt_uint8_t timer_flag_periodic[] = { + RT_TIMER_FLAG_PERIODIC, + RT_TIMER_FLAG_PERIODIC | RT_TIMER_FLAG_HARD_TIMER, + RT_TIMER_FLAG_PERIODIC | RT_TIMER_FLAG_SOFT_TIMER, +}; + +typedef struct test_timer_struct +{ + struct rt_timer static_timer; /* static timer handler */ + rt_timer_t dynamic_timer; /* dynamic timer pointer */ + rt_tick_t expect_tick; /* expect tick */ + rt_uint8_t test_flag; /* timer callback done flag */ +} timer_struct; +static timer_struct timer; + +#define test_static_timer_start test_static_timer_init +#define test_static_timer_stop test_static_timer_init +#define test_static_timer_detach test_static_timer_init + +static void static_timer_oneshot(void *param) +{ + timer_struct *timer_call; + timer_call = (timer_struct *)param; + timer_call->test_flag = RT_TRUE; + + /* check expect tick */ + if (rt_tick_get() - timer_call->expect_tick > 1) + { + uassert_true(RT_FALSE); + } + + return; +} +static void static_timer_periodic(void *param) +{ + rt_err_t result; + timer_struct *timer_call; + timer_call = (timer_struct *)param; + timer_call->test_flag = RT_TRUE; + + /* check expect tick */ + if (rt_tick_get() - timer_call->expect_tick > 1) + { + uassert_true(RT_FALSE); + } + + /* periodic timer can stop */ + result = rt_timer_stop(&timer_call->static_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } + + return; +} + +static void test_static_timer_init(void) +{ + rt_err_t result; + int rand_num = rand() % 10; + + /* one shot timer test */ + for (int time_out = 0; time_out < rand_num; time_out++) + { + for (int i = 0; i < sizeof(timer_flag_oneshot); i++) + { + rt_timer_init(&timer.static_timer, + "static_timer", + static_timer_oneshot, + &timer, + time_out, + timer_flag_oneshot[i]); + + /* calc expect tick */ + timer.expect_tick = rt_tick_get() + time_out; + + /* start timer */ + result = rt_timer_start(&timer.static_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + /* wait for timerout */ + rt_thread_mdelay(time_out + 5); + + /* detach timer */ + result = rt_timer_detach(&timer.static_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + if (timer.test_flag != RT_TRUE) + { + uassert_true(RT_FALSE); + return; + } + } + } + + /* periodic timer test */ + for (int time_out = 0; time_out < rand_num; time_out++) + { + for (int i = 0; i < sizeof(timer_flag_periodic); i++) + { + rt_timer_init(&timer.static_timer, + "static_timer", + static_timer_periodic, + &timer, + time_out, + timer_flag_periodic[i]); + + /* calc expect tick */ + timer.expect_tick = rt_tick_get() + time_out; + + /* start timer */ + result = rt_timer_start(&timer.static_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + /* wait for timerout */ + rt_thread_mdelay(time_out + 5); + + /* detach timer */ + result = rt_timer_detach(&timer.static_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + if (timer.test_flag != RT_TRUE) + { + uassert_true(RT_FALSE); + return; + } + } + } + + timer.test_flag = RT_FALSE; + uassert_true(RT_TRUE); + + return; +} + +static void static_timer_control(void *param) +{ + rt_err_t result; + timer_struct *timer_call; + timer_call = (timer_struct *)param; + timer_call->test_flag = RT_TRUE; + + /* check expect tick */ + if (rt_tick_get() - timer_call->expect_tick > 1) + { + uassert_true(RT_FALSE); + } + + /* periodic timer can stop */ + result = rt_timer_stop(&timer_call->static_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } + + return; +} + +static void test_static_timer_control(void) +{ + rt_err_t result; + int rand_num = rand() % 10; + int set_data; + int get_data; + + rt_timer_init(&timer.static_timer, + "static_timer", + static_timer_control, + &timer, + 5, + RT_TIMER_FLAG_PERIODIC); + + /* test set data */ + set_data = rand_num; + result = rt_timer_control(&timer.static_timer, RT_TIMER_CTRL_SET_TIME, &set_data); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } + + /* test get data */ + result = rt_timer_control(&timer.static_timer, RT_TIMER_CTRL_GET_TIME, &get_data); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } + + /* a set of test */ + if (set_data != get_data) + { + uassert_true(RT_FALSE); + } + + /* calc expect tick */ + timer.expect_tick = rt_tick_get() + set_data; + + /* start timer */ + result = rt_timer_start(&timer.static_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + rt_thread_mdelay(set_data + 5); + + /* detach timer */ + result = rt_timer_detach(&timer.static_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + if (timer.test_flag != RT_TRUE) + { + uassert_true(RT_FALSE); + return; + } + + timer.test_flag = RT_FALSE; + uassert_true(RT_TRUE); +} + +#ifdef RT_USING_HEAP + +#define test_dynamic_timer_start test_dynamic_timer_create +#define test_dynamic_timer_stop test_dynamic_timer_create +#define test_dynamic_timer_delete test_dynamic_timer_create + + +static void dynamic_timer_oneshot(void *param) +{ + timer_struct *timer_call; + timer_call = (timer_struct *)param; + timer_call->test_flag = RT_TRUE; + + /* check expect tick */ + if (rt_tick_get() - timer_call->expect_tick > 1) + { + uassert_true(RT_FALSE); + } + + return; +} +static void dynamic_timer_periodic(void *param) +{ + rt_err_t result; + timer_struct *timer_call; + timer_call = (timer_struct *)param; + timer_call->test_flag = RT_TRUE; + + /* check expect tick */ + if (rt_tick_get() - timer_call->expect_tick > 1) + { + uassert_true(RT_FALSE); + } + + /* periodic timer can stop */ + result = rt_timer_stop(timer_call->dynamic_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } + + return; +} + +static void test_dynamic_timer_create(void) +{ + rt_err_t result; + int rand_num = rand() % 10; + + /* one shot timer test */ + for (int time_out = 0; time_out < rand_num; time_out++) + { + for (int i = 0; i < sizeof(timer_flag_oneshot); i++) + { + timer.dynamic_timer = rt_timer_create("dynamic_timer", + dynamic_timer_oneshot, + &timer, + time_out, + timer_flag_oneshot[i]); + + /* calc expect tick */ + timer.expect_tick = rt_tick_get() + time_out; + + /* start timer */ + result = rt_timer_start(timer.dynamic_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + /* wait for timerout */ + rt_thread_mdelay(time_out + 5); + + /* detach timer */ + result = rt_timer_delete(timer.dynamic_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + if (timer.test_flag != RT_TRUE) + { + uassert_true(RT_FALSE); + return; + } + } + } + + /* periodic timer test */ + for (int time_out = 0; time_out < rand_num; time_out++) + { + for (int i = 0; i < sizeof(timer_flag_periodic); i++) + { + timer.dynamic_timer = rt_timer_create("dynamic_timer", + dynamic_timer_periodic, + &timer, + time_out, + timer_flag_periodic[i]); + + /* calc expect tick */ + timer.expect_tick = rt_tick_get() + time_out; + + /* start timer */ + result = rt_timer_start(timer.dynamic_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + /* wait for timerout */ + rt_thread_mdelay(time_out + 5); + + /* detach timer */ + result = rt_timer_delete(timer.dynamic_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + if (timer.test_flag != RT_TRUE) + { + uassert_true(RT_FALSE); + return; + } + } + } + + timer.test_flag = RT_FALSE; + uassert_true(RT_TRUE); + + return; +} + +static void dynamic_timer_control(void *param) +{ + rt_err_t result; + timer_struct *timer_call; + timer_call = (timer_struct *)param; + timer_call->test_flag = RT_TRUE; + + /* check expect tick */ + if (rt_tick_get() - timer_call->expect_tick > 1) + { + uassert_true(RT_FALSE); + } + + /* periodic timer can stop */ + result = rt_timer_stop(timer_call->dynamic_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } + + return; +} + +static void test_dynamic_timer_control(void) +{ + rt_err_t result; + int rand_num = rand() % 10; + int set_data; + int get_data; + + timer.dynamic_timer = rt_timer_create("dynamic_timer", + dynamic_timer_control, + &timer, + 5, + RT_TIMER_FLAG_PERIODIC); + + /* test set data */ + set_data = rand_num; + result = rt_timer_control(timer.dynamic_timer, RT_TIMER_CTRL_SET_TIME, &set_data); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } + + /* test get data */ + result = rt_timer_control(timer.dynamic_timer, RT_TIMER_CTRL_GET_TIME, &get_data); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } + + /* a set of test */ + if (set_data != get_data) + { + uassert_true(RT_FALSE); + } + + /* calc expect tick */ + timer.expect_tick = rt_tick_get() + set_data; + + /* start timer */ + result = rt_timer_start(timer.dynamic_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + rt_thread_mdelay(set_data + 5); + + /* detach timer */ + result = rt_timer_delete(timer.dynamic_timer); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + if (timer.test_flag != RT_TRUE) + { + uassert_true(RT_FALSE); + return; + } + + timer.test_flag = RT_FALSE; + uassert_true(RT_TRUE); +} + +#endif /* RT_USING_HEAP */ + +static rt_err_t utest_tc_init(void) +{ + timer.dynamic_timer = RT_NULL; + timer.test_flag = RT_FALSE; + + return RT_EOK; +} + +static rt_err_t utest_tc_cleanup(void) +{ + timer.dynamic_timer = RT_NULL; + timer.test_flag = RT_FALSE; + + return RT_EOK; +} + +static void testcase(void) +{ + UTEST_UNIT_RUN(test_static_timer_init); + UTEST_UNIT_RUN(test_static_timer_start); + UTEST_UNIT_RUN(test_static_timer_stop); + UTEST_UNIT_RUN(test_static_timer_detach); + UTEST_UNIT_RUN(test_static_timer_control); +#ifdef RT_USING_HEAP + UTEST_UNIT_RUN(test_dynamic_timer_create); + UTEST_UNIT_RUN(test_dynamic_timer_start); + UTEST_UNIT_RUN(test_dynamic_timer_stop); + UTEST_UNIT_RUN(test_dynamic_timer_delete); + UTEST_UNIT_RUN(test_dynamic_timer_control); +#endif /* RT_USING_HEAP */ +} +UTEST_TC_EXPORT(testcase, "testcases.kernel.timer_tc", utest_tc_init, utest_tc_cleanup, 1000); + +/*********************** end of file ****************************/ -- cgit v1.3.1 From 7c24a01979545c753f4ca58abdcba58e6a3095a7 Mon Sep 17 00:00:00 2001 From: Sherman Date: Wed, 1 Sep 2021 10:13:00 +0800 Subject: [utestcase] 添加 message queue 测试用例 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- examples/utest/configs/kernel/ipc.conf | 2 + examples/utest/testcases/kernel/Kconfig | 4 + examples/utest/testcases/kernel/SConscript | 3 + examples/utest/testcases/kernel/messagequeue_tc.c | 192 ++++++++++++++++++++++ 4 files changed, 201 insertions(+) create mode 100644 examples/utest/testcases/kernel/messagequeue_tc.c (limited to 'examples/utest/testcases/kernel/SConscript') diff --git a/examples/utest/configs/kernel/ipc.conf b/examples/utest/configs/kernel/ipc.conf index ac70437df6..543ebf9e4c 100644 --- a/examples/utest/configs/kernel/ipc.conf +++ b/examples/utest/configs/kernel/ipc.conf @@ -1,5 +1,7 @@ CONFIG_UTEST_SEMAPHORE_TC=y CONFIG_UTEST_EVENT_TC=y +CONFIG_UTEST_MESSAGEQUEUE_TC=y # dependencies CONFIG_RT_USING_SEMAPHORE=y CONFIG_RT_USING_EVENT=y +CONFIG_RT_USING_MESSAGEQUEUE=y diff --git a/examples/utest/testcases/kernel/Kconfig b/examples/utest/testcases/kernel/Kconfig index 1854721193..0145d81373 100644 --- a/examples/utest/testcases/kernel/Kconfig +++ b/examples/utest/testcases/kernel/Kconfig @@ -23,4 +23,8 @@ config UTEST_TIMER_TC bool "timer test" default n +config UTEST_MESSAGEQUEUE_TC + bool "message queue test" + default n + endmenu diff --git a/examples/utest/testcases/kernel/SConscript b/examples/utest/testcases/kernel/SConscript index 758dea4d3f..6192bea3b0 100644 --- a/examples/utest/testcases/kernel/SConscript +++ b/examples/utest/testcases/kernel/SConscript @@ -20,6 +20,9 @@ if GetDepend(['UTEST_EVENT_TC']): if GetDepend(['UTEST_TIMER_TC']): src += ['timer_tc.c'] +if GetDepend(['UTEST_MESSAGEQUEUE_TC']): + src += ['messagequeue_tc.c'] + CPPPATH = [cwd] group = DefineGroup('utestcases', src, depend = [], CPPPATH = CPPPATH) diff --git a/examples/utest/testcases/kernel/messagequeue_tc.c b/examples/utest/testcases/kernel/messagequeue_tc.c new file mode 100644 index 0000000000..335c591ab6 --- /dev/null +++ b/examples/utest/testcases/kernel/messagequeue_tc.c @@ -0,0 +1,192 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-08-28 Sherman the first version + */ + +#include +#include "utest.h" + +#define MSG_SIZE 4 +#define MAX_MSGS 5 + +static struct rt_messagequeue static_mq; +static rt_uint8_t mq_buf[(MSG_SIZE + 4) * MAX_MSGS]; + +static struct rt_thread mq_send_thread; +static struct rt_thread mq_recv_thread; +static rt_uint8_t mq_send_stack[512]; +static rt_uint8_t mq_recv_stack[512]; + +static struct rt_event finish_e; +#define MQSEND_FINISH 0x01 +#define MQRECV_FINIHS 0x02 + +#ifdef RT_USING_HEAP +static rt_mq_t dynamic_mq; +#endif /* RT_USING_HEAP */ + +static void test_mq_init(void) +{ + rt_err_t ret; + ret = rt_mq_init(&static_mq,"testmq1", mq_buf, MSG_SIZE, sizeof(mq_buf), RT_IPC_FLAG_FIFO); + uassert_true(ret == RT_EOK); +} + +static void test_mq_create(void) +{ +#ifdef RT_USING_HEAP + dynamic_mq = rt_mq_create("testmq2", MSG_SIZE, MAX_MSGS, RT_IPC_FLAG_FIFO); + uassert_true(dynamic_mq != RT_NULL); +#endif /* RT_USING_HEAP */ +} + +static void mq_send_case(rt_mq_t testmq) +{ + rt_uint32_t send_buf[MAX_MSGS+1] = {0}; + rt_err_t ret = RT_EOK; + + for (int var = 0; var < MAX_MSGS; ++var) + { + send_buf[var] = var + 1; + ret = rt_mq_send_wait(testmq, &send_buf[var], sizeof(send_buf[0]), RT_WAITING_FOREVER); + uassert_true(ret == RT_EOK); + } + send_buf[MAX_MSGS] = MAX_MSGS + 1; + ret = rt_mq_send(testmq, &send_buf[MAX_MSGS], sizeof(send_buf[0])); + uassert_true(ret == -RT_EFULL); + + ret = rt_mq_send_wait(testmq, &send_buf[MAX_MSGS], sizeof(send_buf[0]), RT_WAITING_FOREVER); + uassert_true(ret == RT_EOK); + + while (testmq->entry != 0) + { + rt_thread_delay(100); + } + + ret = rt_mq_send(testmq, &send_buf[1], sizeof(send_buf[0])); + uassert_true(ret == RT_EOK); + + ret = rt_mq_send(testmq, &send_buf[2], sizeof(send_buf[0])); + uassert_true(ret == RT_EOK); + + ret = rt_mq_urgent(testmq, &send_buf[0], sizeof(send_buf[0])); + uassert_true(ret == RT_EOK); + + while (testmq->entry != 0) + { + rt_thread_delay(100); + } + + ret = rt_mq_send(testmq, &send_buf[1], sizeof(send_buf[0])); + uassert_true(ret == RT_EOK); + ret = rt_mq_control(testmq, RT_IPC_CMD_RESET, RT_NULL); + uassert_true(ret == RT_EOK); + uassert_true(testmq->entry == 0); +} + +static void mq_send_entry(void *param) +{ + mq_send_case(&static_mq); + +#ifdef RT_USING_HEAP + if(dynamic_mq != RT_NULL) + { + mq_send_case(dynamic_mq); + } +#endif /* RT_USING_HEAP */ + + rt_event_send(&finish_e, MQSEND_FINISH); +} + +static void mq_recv_case(rt_mq_t testmq) +{ + rt_uint32_t recv_buf[MAX_MSGS+1] = {0}; + rt_err_t ret = RT_EOK; + + for (int var = 0; var < MAX_MSGS + 1; ++var) + { + ret = rt_mq_recv(testmq, &recv_buf[var], sizeof(recv_buf[0]), RT_WAITING_FOREVER); + uassert_true(ret == RT_EOK); + uassert_true(recv_buf[var] == (var + 1)); + } + + for (int var = 0; var < 3; ++var) + { + ret = rt_mq_recv(testmq, &recv_buf[var], sizeof(recv_buf[0]), RT_WAITING_FOREVER); + uassert_true(ret == RT_EOK); + uassert_true(recv_buf[var] == (var + 1)); + } +} + +static void mq_recv_entry(void *param) +{ + mq_recv_case(&static_mq); + +#ifdef RT_USING_HEAP + if(dynamic_mq != RT_NULL) + { + mq_recv_case(dynamic_mq); + } +#endif /* RT_USING_HEAP */ + rt_event_send(&finish_e, MQRECV_FINIHS); +} + +static void test_mq_testcase(void) +{ + rt_thread_startup(&mq_send_thread); + rt_thread_startup(&mq_recv_thread); + + rt_event_recv(&finish_e, MQSEND_FINISH | MQRECV_FINIHS, RT_EVENT_FLAG_AND, RT_WAITING_FOREVER, RT_NULL); +} + +static void test_mq_detach(void) +{ + rt_err_t ret = rt_mq_detach(&static_mq); + uassert_true(ret == RT_EOK); +} + +static void test_mq_delete(void) +{ +#ifdef RT_USING_HEAP + rt_err_t ret = rt_mq_delete(dynamic_mq); + uassert_true(ret == RT_EOK); +#endif /* RT_USING_HEAP */ +} + +static rt_err_t utest_tc_init(void) +{ + rt_err_t ret ; + ret = rt_thread_init(&mq_send_thread, "mq_send", mq_send_entry, RT_NULL, mq_send_stack, sizeof(mq_send_stack), 22, 20); + if(ret != RT_EOK) + return -RT_ERROR; + + ret = rt_thread_init(&mq_recv_thread, "mq_recv", mq_recv_entry, RT_NULL, mq_recv_stack, sizeof(mq_recv_stack), 23, 20); + if(ret != RT_EOK) + return -RT_ERROR; + + ret = rt_event_init(&finish_e, "finish", RT_IPC_FLAG_FIFO); + if(ret != RT_EOK) + return -RT_ERROR; + + return RT_EOK; +} + +static rt_err_t utest_tc_cleanup(void) +{ + return RT_EOK; +} + +static void testcase(void) +{ + UTEST_UNIT_RUN(test_mq_init); + UTEST_UNIT_RUN(test_mq_create); + UTEST_UNIT_RUN(test_mq_testcase); + UTEST_UNIT_RUN(test_mq_detach); + UTEST_UNIT_RUN(test_mq_delete); +} +UTEST_TC_EXPORT(testcase, "testcases.kernel.messagequeue_tc", utest_tc_init, utest_tc_cleanup, 1000); -- cgit v1.3.1 From 389077897e76ba9772860d4e1d9d18f1a1f39606 Mon Sep 17 00:00:00 2001 From: guozhanxin Date: Sat, 4 Sep 2021 18:04:37 +0800 Subject: [add] signal testcases --- examples/utest/configs/kernel/ipc.conf | 2 + examples/utest/testcases/kernel/Kconfig | 4 + examples/utest/testcases/kernel/SConscript | 3 + examples/utest/testcases/kernel/signal_tc.c | 199 ++++++++++++++++++++++++++++ 4 files changed, 208 insertions(+) create mode 100644 examples/utest/testcases/kernel/signal_tc.c (limited to 'examples/utest/testcases/kernel/SConscript') diff --git a/examples/utest/configs/kernel/ipc.conf b/examples/utest/configs/kernel/ipc.conf index 543ebf9e4c..f8e687e633 100644 --- a/examples/utest/configs/kernel/ipc.conf +++ b/examples/utest/configs/kernel/ipc.conf @@ -1,7 +1,9 @@ CONFIG_UTEST_SEMAPHORE_TC=y CONFIG_UTEST_EVENT_TC=y CONFIG_UTEST_MESSAGEQUEUE_TC=y +CONFIG_UTEST_SIGNAL_TC=y # dependencies CONFIG_RT_USING_SEMAPHORE=y CONFIG_RT_USING_EVENT=y CONFIG_RT_USING_MESSAGEQUEUE=y +CONFIG_RT_USING_SIGNALS=y diff --git a/examples/utest/testcases/kernel/Kconfig b/examples/utest/testcases/kernel/Kconfig index 0145d81373..f4673aebb9 100644 --- a/examples/utest/testcases/kernel/Kconfig +++ b/examples/utest/testcases/kernel/Kconfig @@ -27,4 +27,8 @@ config UTEST_MESSAGEQUEUE_TC bool "message queue test" default n +config UTEST_SIGNAL_TC + bool "signal test" + default n + endmenu diff --git a/examples/utest/testcases/kernel/SConscript b/examples/utest/testcases/kernel/SConscript index 6192bea3b0..ca34db6fed 100644 --- a/examples/utest/testcases/kernel/SConscript +++ b/examples/utest/testcases/kernel/SConscript @@ -23,6 +23,9 @@ if GetDepend(['UTEST_TIMER_TC']): if GetDepend(['UTEST_MESSAGEQUEUE_TC']): src += ['messagequeue_tc.c'] +if GetDepend(['UTEST_SIGNAL_TC']): + src += ['signal_tc.c'] + CPPPATH = [cwd] group = DefineGroup('utestcases', src, depend = [], CPPPATH = CPPPATH) diff --git a/examples/utest/testcases/kernel/signal_tc.c b/examples/utest/testcases/kernel/signal_tc.c new file mode 100644 index 0000000000..40c08f7402 --- /dev/null +++ b/examples/utest/testcases/kernel/signal_tc.c @@ -0,0 +1,199 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-08-12 flybreak the first version + * + * case 1:rt_signal_install, install all available signal + * case 2:rt_signal_install, install illegal signal + * case 3:rt_signal_mask/unmask, one thread self, install and unmask, then kill, should received. + * case 4:rt_signal_mask/unmask, one thread self, install and unmask and mask, then kill, should can't received. + * case 5:rt_signal_wait, two thread, thread1: install and unmask, then wait 1s; thread2: kill, should received. + * case 6:rt_signal_wait, two thread, thread1: install and unmask, then wait 1s; thread2: sleep 2s then kill, should can't received. + * case 7:rt_signal_kill, kill legal thread, return 0; + * case 8:rt_signal_kill, kill illegal thread, return failed (unused); + * case 9:rt_signal_kill, kill illegal signo, return -RT_EINVAL; + * + */ + +#include +#include "utest.h" + +int recive_sig = 0; + +void sig_handle_default(int signo) +{ + recive_sig = signo; +} + +static void rt_signal_install_test(void) +{ + int signo; + rt_sighandler_t result; + + /* case 1:rt_signal_install, install all available signal. */ + for (signo = 0; signo < RT_SIG_MAX; signo++) + { + result = rt_signal_install(signo, sig_handle_default); + uassert_true(result != SIG_ERR); + } + /* case 2:rt_signal_install, install illegal signal. */ + result = rt_signal_install(signo, sig_handle_default); + uassert_true(result == SIG_ERR); + + return; +} + +static void rt_signal_mask_test(void) +{ + int signo; + rt_sighandler_t result; + + /* case 3:rt_signal_mask/unmask, one thread self, install and unmask, then kill, should received. */ + for (signo = 0; signo < RT_SIG_MAX; signo++) + { + recive_sig = -1; + result = rt_signal_install(signo, sig_handle_default); + uassert_true(result != SIG_ERR); + rt_signal_unmask(signo); + uassert_int_equal(rt_thread_kill(rt_thread_self(), signo), RT_EOK); + rt_thread_mdelay(1); + uassert_int_equal(recive_sig, signo); + } + + return; +} + +static void rt_signal_unmask_test(void) +{ + int signo; + rt_sighandler_t result; + + /* case 4:rt_signal_mask/unmask, one thread self, install and unmask and mask, then kill, should can't received. */ + for (signo = 0; signo < RT_SIG_MAX; signo++) + { + recive_sig = -1; + result = rt_signal_install(signo, sig_handle_default); + uassert_true(result != SIG_ERR); + rt_signal_unmask(signo); + rt_signal_mask(signo); + uassert_int_equal(rt_thread_kill(rt_thread_self(), signo), RT_EOK); + rt_thread_mdelay(1); + uassert_int_not_equal(recive_sig, signo); + } + + return; +} + +static void rt_signal_kill_test(void) +{ + int signo; + rt_sighandler_t result; + + /* case 7:rt_signal_kill, kill legal thread, return 0; */ + for (signo = 0; signo < RT_SIG_MAX; signo++) + { + recive_sig = -1; + result = rt_signal_install(signo, sig_handle_default); + uassert_true(result != SIG_ERR); + rt_signal_unmask(signo); + uassert_int_equal(rt_thread_kill(rt_thread_self(), signo), RT_EOK); + rt_thread_mdelay(1); + uassert_int_equal(recive_sig, signo); + } + /* case 8:rt_signal_kill, kill illegal thread, return failed; */ +// uassert_true(rt_thread_kill((rt_thread_t)-1, signo) == -RT_ERROR); + + /* case 9:rt_signal_kill, kill illegal signo, return -RT_EINVAL; */ + uassert_true(rt_thread_kill(rt_thread_self(), -1) == -RT_EINVAL); + + return; +} + +void rt_signal_wait_thread(void *parm) +{ + sigset_t selectset; + siginfo_t recive_si; + + rt_signal_install(SIGUSR1, sig_handle_default); + rt_signal_unmask(SIGUSR1); + + sigemptyset(&selectset); + sigaddset(&selectset, SIGUSR1); + + /* case 5:rt_signal_wait, two thread, thread1: install and unmask, then wait 1s; thread2: kill, should received. */ + if (rt_signal_wait(&selectset, &recive_si, RT_TICK_PER_SECOND) != RT_EOK) + { + return; + } + + recive_sig = recive_si.si_signo; +} + +static void rt_signal_wait_test(void) +{ + rt_thread_t t1; + + recive_sig = -1; + t1 = rt_thread_create("sig_t1", rt_signal_wait_thread, 0, 4096, 14, 10); + if (t1) + { + rt_thread_startup(t1); + } + + rt_thread_mdelay(1); + /* case 5:rt_signal_wait, two thread, thread1: install and unmask, then wait 1s; thread2: kill, should received. */ + uassert_int_equal(rt_thread_kill(t1, SIGUSR1), RT_EOK); + rt_thread_mdelay(1); + uassert_int_equal(recive_sig, SIGUSR1); + + return; +} + +static void rt_signal_wait_test2(void) +{ + rt_thread_t t1; + + recive_sig = -1; + t1 = rt_thread_create("sig_t1", rt_signal_wait_thread, 0, 4096, 14, 10); + if (t1) + { + rt_thread_startup(t1); + } + + /* case 6:rt_signal_wait, two thread, thread1: install and unmask, then wait 1s; thread2: sleep 2s then kill, should can't received. */ + rt_thread_mdelay(2000); + uassert_int_equal(rt_thread_kill(t1, SIGUSR1), RT_EOK); + rt_thread_mdelay(1); + uassert_int_not_equal(recive_sig, SIGUSR1); + + return; +} + +static rt_err_t utest_tc_init(void) +{ + return RT_EOK; +} + +static rt_err_t utest_tc_cleanup(void) +{ + return RT_EOK; +} + +static void testcase(void) +{ +#ifdef RT_USING_HEAP + UTEST_UNIT_RUN(rt_signal_install_test); + UTEST_UNIT_RUN(rt_signal_mask_test); + UTEST_UNIT_RUN(rt_signal_unmask_test); + UTEST_UNIT_RUN(rt_signal_kill_test); + UTEST_UNIT_RUN(rt_signal_wait_test); + UTEST_UNIT_RUN(rt_signal_wait_test2); +#endif /* RT_USING_HEAP */ +} +UTEST_TC_EXPORT(testcase, "testcases.kernel.signal_tc", utest_tc_init, utest_tc_cleanup, 1000); + +/*********************** end of file ****************************/ -- cgit v1.3.1 From f4abcef96f9dd52a3a2355e37eeee810029f295f Mon Sep 17 00:00:00 2001 From: tyustli <1225613647@qq.com> Date: Mon, 6 Sep 2021 15:30:08 +0800 Subject: [add] utest kernel mutex_tc.c file --- examples/utest/configs/kernel/ipc.conf | 2 + examples/utest/testcases/kernel/Kconfig | 4 + examples/utest/testcases/kernel/SConscript | 3 + examples/utest/testcases/kernel/mutex_tc.c | 676 +++++++++++++++++++++++++++++ 4 files changed, 685 insertions(+) create mode 100644 examples/utest/testcases/kernel/mutex_tc.c (limited to 'examples/utest/testcases/kernel/SConscript') diff --git a/examples/utest/configs/kernel/ipc.conf b/examples/utest/configs/kernel/ipc.conf index f8e687e633..f961e082e1 100644 --- a/examples/utest/configs/kernel/ipc.conf +++ b/examples/utest/configs/kernel/ipc.conf @@ -2,8 +2,10 @@ CONFIG_UTEST_SEMAPHORE_TC=y CONFIG_UTEST_EVENT_TC=y CONFIG_UTEST_MESSAGEQUEUE_TC=y CONFIG_UTEST_SIGNAL_TC=y +CONFIG_UTEST_MUTEX_TC=y # dependencies CONFIG_RT_USING_SEMAPHORE=y CONFIG_RT_USING_EVENT=y CONFIG_RT_USING_MESSAGEQUEUE=y CONFIG_RT_USING_SIGNALS=y +CONFIG_RT_USING_MUTEX=y \ No newline at end of file diff --git a/examples/utest/testcases/kernel/Kconfig b/examples/utest/testcases/kernel/Kconfig index f4673aebb9..fd4e1fecb9 100644 --- a/examples/utest/testcases/kernel/Kconfig +++ b/examples/utest/testcases/kernel/Kconfig @@ -31,4 +31,8 @@ config UTEST_SIGNAL_TC bool "signal test" default n +config UTEST_MUTEX_TC + bool "mutex test" + default n + endmenu diff --git a/examples/utest/testcases/kernel/SConscript b/examples/utest/testcases/kernel/SConscript index ca34db6fed..4bf0a2e60b 100644 --- a/examples/utest/testcases/kernel/SConscript +++ b/examples/utest/testcases/kernel/SConscript @@ -26,6 +26,9 @@ if GetDepend(['UTEST_MESSAGEQUEUE_TC']): if GetDepend(['UTEST_SIGNAL_TC']): src += ['signal_tc.c'] +if GetDepend(['UTEST_MUTEX_TC']): + src += ['mutex_tc.c'] + CPPPATH = [cwd] group = DefineGroup('utestcases', src, depend = [], CPPPATH = CPPPATH) diff --git a/examples/utest/testcases/kernel/mutex_tc.c b/examples/utest/testcases/kernel/mutex_tc.c new file mode 100644 index 0000000000..0ec443318a --- /dev/null +++ b/examples/utest/testcases/kernel/mutex_tc.c @@ -0,0 +1,676 @@ +/* + * Copyright (c) 2006-2019, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-09.01 luckyzjq the first version + */ + +#include +#include +#include "utest.h" + +static struct rt_mutex static_mutex; + +#ifdef RT_USING_HEAP +static rt_mutex_t dynamic_mutex; +#endif /* RT_USING_HEAP */ + +/* init test */ +static void test_static_mutex_init(void) +{ + rt_err_t result = -RT_ERROR; + + result = rt_mutex_init(&static_mutex, "static_mutex", RT_IPC_FLAG_PRIO); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } + + result = rt_mutex_detach(&static_mutex); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } + + result = rt_mutex_init(&static_mutex, "static_mutex", RT_IPC_FLAG_FIFO); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } + + result = rt_mutex_detach(&static_mutex); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } + + uassert_true(RT_TRUE); +} + +/* static take test */ +static void static_mutex_take_entry(void *param) +{ + rt_err_t result; + rt_mutex_t mutex; + + int rand_num = rand() % 0x1000; + mutex = (rt_mutex_t)param; + + result = rt_mutex_take(mutex, rand_num); + if (RT_EOK == result) + { + uassert_true(RT_FALSE); + } +} +static void test_static_mutex_take(void) +{ + rt_err_t result; + + result = rt_mutex_init(&static_mutex, "static_mutex", RT_IPC_FLAG_PRIO); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + /* take mutex and not release */ + result = rt_mutex_take(&static_mutex, RT_WAITING_FOREVER); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + rt_thread_t tid = rt_thread_create("mutex_th", + static_mutex_take_entry, + &static_mutex, + 2048, + 10, + 10); + if (RT_NULL == tid) + { + uassert_true(RT_FALSE); + return; + } + + /* startup thread take second */ + rt_thread_startup(tid); + + /* let system schedule */ + rt_thread_mdelay(5); + + result = rt_mutex_detach(&static_mutex); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + uassert_true(RT_TRUE); +} + +/* static release test */ +static void static_mutex_release_entry(void *param) +{ + rt_err_t result; + rt_mutex_t mutex; + + int rand_num = rand() % 0x1000; + mutex = (rt_mutex_t)param; + + result = rt_mutex_take(mutex, rand_num); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } +} +static void test_static_mutex_release(void) +{ + rt_err_t result; + + result = rt_mutex_init(&static_mutex, "static_mutex", RT_IPC_FLAG_PRIO); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + /* take mutex */ + result = rt_mutex_take(&static_mutex, RT_WAITING_FOREVER); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + /* release mutex */ + result = rt_mutex_release(&static_mutex); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + rt_thread_t tid = rt_thread_create("mutex_th", + static_mutex_release_entry, + &static_mutex, + 2048, + 10, + 10); + if (RT_NULL == tid) + { + uassert_true(RT_FALSE); + return; + } + + /* startup thread adn take mutex second */ + rt_thread_startup(tid); + + /* let system schedule */ + rt_thread_mdelay(5); + + result = rt_mutex_detach(&static_mutex); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + uassert_true(RT_TRUE); +} + +/* static trytake test */ +static void static_mutex_trytake_entry(void *param) +{ + rt_err_t result; + rt_mutex_t mutex; + + mutex = (rt_mutex_t)param; + + result = rt_mutex_trytake(mutex); + if (RT_EOK == result) + { + uassert_true(RT_FALSE); + } +} +static void test_static_mutex_trytake(void) +{ + rt_err_t result; + + result = rt_mutex_init(&static_mutex, "static_mutex", RT_IPC_FLAG_PRIO); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + /* take mutex and not release */ + result = rt_mutex_take(&static_mutex, RT_WAITING_FOREVER); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + rt_thread_t tid = rt_thread_create("mutex_th", + static_mutex_trytake_entry, + &static_mutex, + 2048, + 10, + 10); + if (RT_NULL == tid) + { + uassert_true(RT_FALSE); + return; + } + + /* startup thread and trytake mutex second */ + rt_thread_startup(tid); + + /* let system schedule */ + rt_thread_mdelay(5); + + result = rt_mutex_detach(&static_mutex); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + uassert_true(RT_TRUE); +} + +static rt_thread_t tid1 = RT_NULL; +static rt_thread_t tid2 = RT_NULL; +static rt_thread_t tid3 = RT_NULL; + +/* static mutex priority reverse test */ +static void static_thread1_entry(void *param) +{ + /* let system schedule */ + rt_thread_mdelay(100); + + /* thread3 hode mutex thread2 take mutex */ + /* check thread2 and thread3 priority */ + if (tid2->current_priority != tid3->current_priority) + { + uassert_true(RT_FALSE); + } + else + { + uassert_true(RT_TRUE); + } +} + +static void static_thread2_entry(void *param) +{ + rt_err_t result; + rt_mutex_t mutex = (rt_mutex_t)param; + + /* let system schedule */ + rt_thread_mdelay(50); + + result = rt_mutex_take(mutex, RT_WAITING_FOREVER); + if (result == RT_EOK) + { + rt_mutex_release(mutex); + } +} +static void static_thread3_entry(void *param) +{ + rt_tick_t tick; + rt_err_t result; + rt_mutex_t mutex = (rt_mutex_t)param; + + result = rt_mutex_take(mutex, RT_WAITING_FOREVER); + if (result != RT_EOK) + { + uassert_true(RT_FALSE); + } + + tick = rt_tick_get(); + while (rt_tick_get() - tick < (RT_TICK_PER_SECOND / 2)); + + rt_mutex_release(mutex); +} + +static void test_static_pri_reverse(void) +{ + rt_err_t result; + tid1 = RT_NULL; + tid2 = RT_NULL; + tid3 = RT_NULL; + + result = rt_mutex_init(&static_mutex, "static_mutex", RT_IPC_FLAG_PRIO); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + return; + } + + /* 创建线程 1 */ + tid1 = rt_thread_create("thread1", + static_thread1_entry, + &static_mutex, + 1024, + 10 - 1, + 10); + if (tid1 != RT_NULL) + rt_thread_startup(tid1); + + /* 创建线程 2 */ + tid2 = rt_thread_create("thread2", + static_thread2_entry, + &static_mutex, + 1024, + 10, + 10); + if (tid2 != RT_NULL) + rt_thread_startup(tid2); + + /* 创建线程 3 */ + tid3 = rt_thread_create("thread3", + static_thread3_entry, + &static_mutex, + 1024, + 10 + 1, + 10); + if (tid3 != RT_NULL) + rt_thread_startup(tid3); + + rt_thread_mdelay(1000); + + result = rt_mutex_detach(&static_mutex); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + uassert_true(RT_TRUE); +} + +/* create test */ +static void test_dynamic_mutex_create(void) +{ + rt_err_t result = -RT_ERROR; + + /* PRIO mode */ + dynamic_mutex = rt_mutex_create("dynamic_mutex", RT_IPC_FLAG_PRIO); + if (RT_NULL == result) + { + uassert_true(RT_FALSE); + } + + result = rt_mutex_delete(dynamic_mutex); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } + + /* FIFO mode */ + dynamic_mutex = rt_mutex_create("dynamic_mutex", RT_IPC_FLAG_FIFO); + if (RT_NULL == dynamic_mutex) + { + uassert_true(RT_FALSE); + } + + result = rt_mutex_delete(dynamic_mutex); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } + + uassert_true(RT_TRUE); +} + +/* dynamic take test */ +static void dynamic_mutex_take_entry(void *param) +{ + rt_err_t result; + rt_mutex_t mutex; + + int rand_num = rand() % 0x1000; + mutex = (rt_mutex_t)param; + + result = rt_mutex_take(mutex, rand_num); + if (RT_EOK == result) + { + uassert_true(RT_FALSE); + } +} +static void test_dynamic_mutex_take(void) +{ + rt_err_t result; + + dynamic_mutex = rt_mutex_create("dynamic_mutex", RT_IPC_FLAG_PRIO); + if (RT_NULL == dynamic_mutex) + { + uassert_true(RT_FALSE); + return; + } + + /* take mutex and not release */ + result = rt_mutex_take(dynamic_mutex, RT_WAITING_FOREVER); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + rt_thread_t tid = rt_thread_create("mutex_th", + dynamic_mutex_take_entry, + dynamic_mutex, + 2048, + 10, + 10); + if (RT_NULL == tid) + { + uassert_true(RT_FALSE); + return; + } + + /* startup thread take second */ + rt_thread_startup(tid); + + /* let system schedule */ + rt_thread_mdelay(5); + + result = rt_mutex_delete(dynamic_mutex); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + uassert_true(RT_TRUE); +} + +/* dynamic release test */ +static void dynamic_mutex_release_entry(void *param) +{ + rt_err_t result; + rt_mutex_t mutex; + + int rand_num = rand() % 0x1000; + mutex = (rt_mutex_t)param; + + result = rt_mutex_take(mutex, rand_num); + if (RT_EOK != result) + { + uassert_true(RT_FALSE); + } +} +static void test_dynamic_mutex_release(void) +{ + rt_err_t result; + + dynamic_mutex = rt_mutex_create("dynamic_mutex", RT_IPC_FLAG_PRIO); + if (RT_NULL == dynamic_mutex) + { + uassert_true(RT_FALSE); + return; + } + + /* take mutex */ + result = rt_mutex_take(dynamic_mutex, RT_WAITING_FOREVER); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + /* release mutex */ + result = rt_mutex_release(dynamic_mutex); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + rt_thread_t tid = rt_thread_create("mutex_th", + dynamic_mutex_release_entry, + dynamic_mutex, + 2048, + 10, + 10); + if (RT_NULL == tid) + { + uassert_true(RT_FALSE); + return; + } + + /* startup thread adn take mutex second */ + rt_thread_startup(tid); + + /* let system schedule */ + rt_thread_mdelay(5); + + result = rt_mutex_delete(dynamic_mutex); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + uassert_true(RT_TRUE); +} + +/* dynamic trytake test */ +static void dynamic_mutex_trytake_entry(void *param) +{ + rt_err_t result; + rt_mutex_t mutex; + + mutex = (rt_mutex_t)param; + + result = rt_mutex_trytake(mutex); + if (RT_EOK == result) + { + uassert_true(RT_FALSE); + } +} +static void test_dynamic_mutex_trytake(void) +{ + rt_err_t result; + + dynamic_mutex = rt_mutex_create("dynamic_mutex", RT_IPC_FLAG_PRIO); + if (RT_NULL == dynamic_mutex) + { + uassert_true(RT_FALSE); + return; + } + + /* take mutex and not release */ + result = rt_mutex_take(dynamic_mutex, RT_WAITING_FOREVER); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + rt_thread_t tid = rt_thread_create("mutex_th", + dynamic_mutex_trytake_entry, + dynamic_mutex, + 2048, + 10, + 10); + if (RT_NULL == tid) + { + uassert_true(RT_FALSE); + return; + } + + /* startup thread and trytake mutex second */ + rt_thread_startup(tid); + + /* let system schedule */ + rt_thread_mdelay(5); + + result = rt_mutex_delete(dynamic_mutex); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + uassert_true(RT_TRUE); +} + +/* dynamic mutex priority reverse test */ +static void dynamic_thread1_entry(void *param) +{ + /* let system schedule */ + rt_thread_mdelay(100); + + /* thread3 hode mutex thread2 take mutex */ + /* check thread2 and thread3 priority */ + if (tid2->current_priority != tid3->current_priority) + { + uassert_true(RT_FALSE); + } + else + { + uassert_true(RT_TRUE); + } +} + +static void dynamic_thread2_entry(void *param) +{ + rt_err_t result; + rt_mutex_t mutex = (rt_mutex_t)param; + + /* let system schedule */ + rt_thread_mdelay(50); + + result = rt_mutex_take(mutex, RT_WAITING_FOREVER); + if (result == RT_EOK) + { + rt_mutex_release(mutex); + } +} +static void dynamic_thread3_entry(void *param) +{ + rt_tick_t tick; + rt_err_t result; + rt_mutex_t mutex = (rt_mutex_t)param; + + result = rt_mutex_take(mutex, RT_WAITING_FOREVER); + if (result != RT_EOK) + { + uassert_true(RT_FALSE); + } + + tick = rt_tick_get(); + while (rt_tick_get() - tick < (RT_TICK_PER_SECOND / 2)); + + rt_mutex_release(mutex); +} + +static void test_dynamic_pri_reverse(void) +{ + rt_err_t result; + tid1 = RT_NULL; + tid2 = RT_NULL; + tid3 = RT_NULL; + + dynamic_mutex = rt_mutex_create("dynamic_mutex", RT_IPC_FLAG_PRIO); + if (RT_NULL == dynamic_mutex) + { + uassert_true(RT_FALSE); + return; + } + + /* 创建线程 1 */ + tid1 = rt_thread_create("thread1", + dynamic_thread1_entry, + dynamic_mutex, + 1024, + 10 - 1, + 10); + if (tid1 != RT_NULL) + rt_thread_startup(tid1); + + /* 创建线程 2 */ + tid2 = rt_thread_create("thread2", + dynamic_thread2_entry, + dynamic_mutex, + 1024, + 10, + 10); + if (tid2 != RT_NULL) + rt_thread_startup(tid2); + + /* 创建线程 3 */ + tid3 = rt_thread_create("thread3", + dynamic_thread3_entry, + dynamic_mutex, + 1024, + 10 + 1, + 10); + if (tid3 != RT_NULL) + rt_thread_startup(tid3); + + rt_thread_mdelay(1000); + + result = rt_mutex_delete(dynamic_mutex); + if (RT_EOK != result) + uassert_true(RT_FALSE); + + uassert_true(RT_TRUE); +} + +static rt_err_t utest_tc_init(void) +{ +#ifdef RT_USING_HEAP + dynamic_mutex = RT_NULL; +#endif /* RT_USING_HEAP */ + + return RT_EOK; +} + +static rt_err_t utest_tc_cleanup(void) +{ +#ifdef RT_USING_HEAP + dynamic_mutex = RT_NULL; +#endif /* RT_USING_HEAP */ + + return RT_EOK; +} + +static void testcase(void) +{ + UTEST_UNIT_RUN(test_static_mutex_init); + UTEST_UNIT_RUN(test_static_mutex_take); + UTEST_UNIT_RUN(test_static_mutex_release); + UTEST_UNIT_RUN(test_static_mutex_trytake); + UTEST_UNIT_RUN(test_static_pri_reverse); +#ifdef RT_USING_HEAP + UTEST_UNIT_RUN(test_dynamic_mutex_create); + UTEST_UNIT_RUN(test_dynamic_mutex_take); + UTEST_UNIT_RUN(test_dynamic_mutex_release); + UTEST_UNIT_RUN(test_dynamic_mutex_trytake); + UTEST_UNIT_RUN(test_dynamic_pri_reverse); +#endif +} +UTEST_TC_EXPORT(testcase, "testcases.kernel.mutex_tc", utest_tc_init, utest_tc_cleanup, 1000); + +/********************* end of file ************************/ -- cgit v1.3.1 From bf94a69afdb8faf004d70f0089da2702dc6c3671 Mon Sep 17 00:00:00 2001 From: liukangcc Date: Thu, 9 Sep 2021 10:15:26 +0800 Subject: [add] mailbox testcase. --- examples/utest/configs/kernel/ipc.conf | 4 +- examples/utest/testcases/kernel/Kconfig | 4 + examples/utest/testcases/kernel/SConscript | 3 + examples/utest/testcases/kernel/mailbox_tc.c | 371 +++++++++++++++++++++++++++ 4 files changed, 381 insertions(+), 1 deletion(-) create mode 100644 examples/utest/testcases/kernel/mailbox_tc.c (limited to 'examples/utest/testcases/kernel/SConscript') diff --git a/examples/utest/configs/kernel/ipc.conf b/examples/utest/configs/kernel/ipc.conf index f961e082e1..8af98d607a 100644 --- a/examples/utest/configs/kernel/ipc.conf +++ b/examples/utest/configs/kernel/ipc.conf @@ -3,9 +3,11 @@ CONFIG_UTEST_EVENT_TC=y CONFIG_UTEST_MESSAGEQUEUE_TC=y CONFIG_UTEST_SIGNAL_TC=y CONFIG_UTEST_MUTEX_TC=y +CONFIG_UTEST_MAILBOX_TC=y # dependencies CONFIG_RT_USING_SEMAPHORE=y CONFIG_RT_USING_EVENT=y CONFIG_RT_USING_MESSAGEQUEUE=y CONFIG_RT_USING_SIGNALS=y -CONFIG_RT_USING_MUTEX=y \ No newline at end of file +CONFIG_RT_USING_MUTEX=y +CONFIG_RT_USING_MAILBOX=y diff --git a/examples/utest/testcases/kernel/Kconfig b/examples/utest/testcases/kernel/Kconfig index fd4e1fecb9..fba3b8c511 100644 --- a/examples/utest/testcases/kernel/Kconfig +++ b/examples/utest/testcases/kernel/Kconfig @@ -35,4 +35,8 @@ config UTEST_MUTEX_TC bool "mutex test" default n +config UTEST_MAILBOX_TC + bool "mailbox test" + default n + endmenu diff --git a/examples/utest/testcases/kernel/SConscript b/examples/utest/testcases/kernel/SConscript index 4bf0a2e60b..484f1fbf3b 100644 --- a/examples/utest/testcases/kernel/SConscript +++ b/examples/utest/testcases/kernel/SConscript @@ -29,6 +29,9 @@ if GetDepend(['UTEST_SIGNAL_TC']): if GetDepend(['UTEST_MUTEX_TC']): src += ['mutex_tc.c'] +if GetDepend(['UTEST_MAILBOX_TC']): + src += ['mailbox_tc.c'] + CPPPATH = [cwd] group = DefineGroup('utestcases', src, depend = [], CPPPATH = CPPPATH) diff --git a/examples/utest/testcases/kernel/mailbox_tc.c b/examples/utest/testcases/kernel/mailbox_tc.c new file mode 100644 index 0000000000..e18613b559 --- /dev/null +++ b/examples/utest/testcases/kernel/mailbox_tc.c @@ -0,0 +1,371 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-09-08 liukang the first version + */ + +#include +#include "utest.h" +#include + +static struct rt_mailbox test_static_mb; +static char mb_pool[128]; + +static rt_mailbox_t test_dynamic_mb; + +static uint8_t static_mb_recv_thread_finish, static_mb_send_thread_finish; +static uint8_t dynamic_mb_recv_thread_finish, dynamic_mb_send_thread_finish; + +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 rt_thread_t mb_send = RT_NULL; +static rt_thread_t mb_recv = RT_NULL; + +static rt_uint8_t mb_send_str1[] = "this is first mail!"; +static rt_uint8_t mb_send_str2[] = "this is second mail!"; +static rt_uint8_t mb_send_str3[] = "this is thirdy mail!"; + +static rt_uint8_t *mb_recv_str1; +static rt_uint8_t *mb_recv_str2; +static rt_uint8_t *mb_recv_str3; + +static void test_mailbox_init(void) +{ + rt_err_t result; + + result = rt_mb_init(&test_static_mb, "mbt", &mb_pool[0], sizeof(mb_pool) / 4, RT_IPC_FLAG_FIFO); + if (result != RT_EOK) + { + uassert_false(1); + } + result = rt_mb_detach(&test_static_mb); + if (result != RT_EOK) + { + uassert_false(1); + } + + result = rt_mb_init(&test_static_mb, "mbt", &mb_pool[0], sizeof(mb_pool) / 4, RT_IPC_FLAG_PRIO); + if (result != RT_EOK) + { + uassert_false(1); + } + + result = rt_mb_detach(&test_static_mb); + if (result != RT_EOK) + { + uassert_false(1); + } + + uassert_true(1); +} + +static void test_mailbox_deatch(void) +{ + rt_err_t result; + + result = rt_mb_init(&test_static_mb, "mbt", &mb_pool[0], sizeof(mb_pool) / 4, RT_IPC_FLAG_FIFO); + if (result != RT_EOK) + { + uassert_false(1); + } + result = rt_mb_detach(&test_static_mb); + if (result != RT_EOK) + { + uassert_false(1); + } + + result = rt_mb_init(&test_static_mb, "mbt", &mb_pool[0], sizeof(mb_pool) / 4, RT_IPC_FLAG_PRIO); + if (result != RT_EOK) + { + uassert_false(1); + } + result = rt_mb_detach(&test_static_mb); + if (result != RT_EOK) + { + uassert_false(1); + } + + uassert_true(1); +} + +static void test_mailbox_create(void) +{ + rt_err_t result; + + test_dynamic_mb = rt_mb_create("test_dynamic_mb", sizeof(mb_pool) / 4, RT_IPC_FLAG_FIFO); + if (test_dynamic_mb == RT_NULL) + { + uassert_false(1); + } + result = rt_mb_delete(test_dynamic_mb); + if (result != RT_EOK) + { + uassert_false(1); + } + + test_dynamic_mb = rt_mb_create("test_dynamic_mb", sizeof(mb_pool) / 4, RT_IPC_FLAG_PRIO); + if (test_dynamic_mb == RT_NULL) + { + uassert_false(1); + } + result = rt_mb_delete(test_dynamic_mb); + if (result != RT_EOK) + { + uassert_false(1); + } + + uassert_true(1); +} + +static void test_mailbox_delete(void) +{ + rt_err_t result; + + test_dynamic_mb = rt_mb_create("test_dynamic_mb", sizeof(mb_pool) / 4, RT_IPC_FLAG_FIFO); + if (test_dynamic_mb == RT_NULL) + { + uassert_false(1); + } + result = rt_mb_delete(test_dynamic_mb); + if (result != RT_EOK) + { + uassert_false(1); + } + + test_dynamic_mb = rt_mb_create("test_dynamic_mb", sizeof(mb_pool) / 4, RT_IPC_FLAG_PRIO); + if (test_dynamic_mb == RT_NULL) + { + uassert_false(1); + } + result = rt_mb_delete(test_dynamic_mb); + if (result != RT_EOK) + { + uassert_false(1); + } + + uassert_true(1); +} + +static void thread2_send_static_mb(void *arg) +{ + rt_err_t res = RT_EOK; + + res = rt_mb_send(&test_static_mb, (rt_ubase_t)&mb_send_str1); + if (res != RT_EOK) + { + uassert_false(1); + } + rt_thread_mdelay(100); + + res = rt_mb_send_wait(&test_static_mb, (rt_ubase_t)&mb_send_str2, 10); + if (res != RT_EOK) + { + uassert_false(1); + } + rt_thread_mdelay(100); + + res = rt_mb_urgent(&test_static_mb, (rt_ubase_t)&mb_send_str3); + if (res != RT_EOK) + { + uassert_false(1); + } + + static_mb_send_thread_finish = 1; +} + +static void thread1_recv_static_mb(void *arg) +{ + rt_err_t result = RT_EOK; + + result = rt_mb_recv(&test_static_mb, (rt_ubase_t *)&mb_recv_str1, RT_WAITING_FOREVER); + if (result != RT_EOK || strcmp(mb_recv_str1, mb_send_str1) != 0) + { + uassert_false(1); + } + + result = rt_mb_recv(&test_static_mb, (rt_ubase_t *)&mb_recv_str2, RT_WAITING_FOREVER); + if (result != RT_EOK || strcmp(mb_recv_str2, mb_send_str2) != 0) + { + uassert_false(1); + } + + result = rt_mb_recv(&test_static_mb, (rt_ubase_t *)&mb_recv_str3, RT_WAITING_FOREVER); + if (result != RT_EOK || strcmp(mb_recv_str3, mb_send_str3) != 0) + { + uassert_false(1); + } + + static_mb_recv_thread_finish = 1; +} + +static void test_static_mailbox_send_recv(void) +{ + rt_err_t result; + + result = rt_mb_init(&test_static_mb, "mbt", &mb_pool[0], sizeof(mb_pool) / 4, RT_IPC_FLAG_FIFO); + if (result != RT_EOK) + { + uassert_false(1); + } + + rt_thread_init(&thread1, + "thread1", + thread1_recv_static_mb, + 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_mb, + RT_NULL, + &thread2_stack[0], + sizeof(thread2_stack), + THREAD_PRIORITY, THREAD_TIMESLICE); + rt_thread_startup(&thread2); + + while (static_mb_recv_thread_finish != 1 || static_mb_send_thread_finish != 1) + { + rt_thread_delay(1); + } + + if (rt_mb_detach(&test_static_mb) != RT_EOK) + { + uassert_false(1); + } + + uassert_true(1); +} + +static void thread4_send_dynamic_mb(void *arg) +{ + rt_err_t res = RT_EOK; + + res = rt_mb_send(test_dynamic_mb, (rt_ubase_t)&mb_send_str1); + if (res != RT_EOK) + { + uassert_false(1); + } + rt_thread_mdelay(100); + + res = rt_mb_send_wait(test_dynamic_mb, (rt_ubase_t)&mb_send_str2, 10); + if (res != RT_EOK) + { + uassert_false(1); + } + rt_thread_mdelay(100); + + res = rt_mb_urgent(test_dynamic_mb, (rt_ubase_t)&mb_send_str3); + if (res != RT_EOK) + { + uassert_false(1); + } + + dynamic_mb_send_thread_finish = 1; +} + +static void thread3_recv_dynamic_mb(void *arg) +{ + rt_err_t result = RT_EOK; + + result = rt_mb_recv(test_dynamic_mb, (rt_ubase_t *)&mb_recv_str1, RT_WAITING_FOREVER); + if (result != RT_EOK || strcmp(mb_recv_str1, mb_send_str1) != 0) + { + uassert_false(1); + } + + result = rt_mb_recv(test_dynamic_mb, (rt_ubase_t *)&mb_recv_str2, RT_WAITING_FOREVER); + if (result != RT_EOK || strcmp(mb_recv_str2, mb_send_str2) != 0) + { + uassert_false(1); + } + + result = rt_mb_recv(test_dynamic_mb, (rt_ubase_t *)&mb_recv_str3, RT_WAITING_FOREVER); + if (result != RT_EOK || strcmp(mb_recv_str3, mb_send_str3) != 0) + { + uassert_false(1); + } + + dynamic_mb_recv_thread_finish = 1; +} + +static void test_dynamic_mailbox_send_recv(void) +{ + test_dynamic_mb = rt_mb_create("mbt", sizeof(mb_pool) / 4, RT_IPC_FLAG_FIFO); + if (test_dynamic_mb == RT_NULL) + { + uassert_false(1); + } + + mb_recv = rt_thread_create("mb_recv_thread", + thread3_recv_dynamic_mb, + RT_NULL, + 1024, + THREAD_PRIORITY - 1, + THREAD_TIMESLICE); + if (mb_recv == RT_NULL) + { + uassert_false(1); + } + rt_thread_startup(mb_recv); + + mb_send = rt_thread_create("mb_send_thread", + thread4_send_dynamic_mb, + RT_NULL, + 1024, + THREAD_PRIORITY - 1, + THREAD_TIMESLICE); + if (mb_send == RT_NULL) + { + uassert_false(1); + } + rt_thread_startup(mb_send); + + while (dynamic_mb_recv_thread_finish != 1 || dynamic_mb_send_thread_finish != 1) + { + rt_thread_delay(1); + } + + if (rt_mb_delete(test_dynamic_mb) != RT_EOK) + { + uassert_false(1); + } + + uassert_true(1); +} + +static rt_err_t utest_tc_init(void) +{ + return RT_EOK; +} + +static rt_err_t utest_tc_cleanup(void) +{ + return RT_EOK; +} + +static void testcase(void) +{ + UTEST_UNIT_RUN(test_mailbox_init); + UTEST_UNIT_RUN(test_mailbox_deatch); + UTEST_UNIT_RUN(test_mailbox_create); + UTEST_UNIT_RUN(test_mailbox_delete); + UTEST_UNIT_RUN(test_static_mailbox_send_recv); + UTEST_UNIT_RUN(test_dynamic_mailbox_send_recv); +} +UTEST_TC_EXPORT(testcase, "src.ipc.mailbox_tc", utest_tc_init, utest_tc_cleanup, 60); -- cgit v1.3.1 From c3465dfab7de0fec94a5b76a88e0f7eb69801de1 Mon Sep 17 00:00:00 2001 From: mazhiyuan Date: Mon, 11 Oct 2021 13:47:26 +0800 Subject: add thread testcase --- .github/workflows/action_utest.yml | 1 + examples/utest/configs/kernel/thread.conf | 4 + examples/utest/testcases/kernel/Kconfig | 6 + examples/utest/testcases/kernel/SConscript | 3 + examples/utest/testcases/kernel/thread_tc.c | 641 ++++++++++++++++++++++++++++ 5 files changed, 655 insertions(+) create mode 100644 examples/utest/configs/kernel/thread.conf create mode 100644 examples/utest/testcases/kernel/thread_tc.c (limited to 'examples/utest/testcases/kernel/SConscript') diff --git a/.github/workflows/action_utest.yml b/.github/workflows/action_utest.yml index 197537a9b4..06d8ec15ff 100644 --- a/.github/workflows/action_utest.yml +++ b/.github/workflows/action_utest.yml @@ -15,6 +15,7 @@ jobs: - {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: "kernel/irq", RTT_BSP: "bsp/qemu-vexpress-a9", QEMU_ARCH: "arm", QEMU_MACHINE: "vexpress-a9", CONFIG_FILE: "kernel/irq.conf", SD_FILE: "sd.bin"} - {UTEST: "kernel/timer", RTT_BSP: "bsp/qemu-vexpress-a9", QEMU_ARCH: "arm", QEMU_MACHINE: "vexpress-a9", CONFIG_FILE: "kernel/timer.conf", SD_FILE: "sd.bin"} + - {UTEST: "kernel/thread", RTT_BSP: "bsp/qemu-vexpress-a9", QEMU_ARCH: "arm", QEMU_MACHINE: "vexpress-a9", CONFIG_FILE: "kernel/thread.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/thread.conf b/examples/utest/configs/kernel/thread.conf new file mode 100644 index 0000000000..9b3234f0d7 --- /dev/null +++ b/examples/utest/configs/kernel/thread.conf @@ -0,0 +1,4 @@ +CONFIG_UTEST_THREAD_TC=y +# dependencies +CONFIG_RT_USING_TIMER_SOFT=y +CONFIG_RT_USING_THREAD=y diff --git a/examples/utest/testcases/kernel/Kconfig b/examples/utest/testcases/kernel/Kconfig index fba3b8c511..08c3022b77 100644 --- a/examples/utest/testcases/kernel/Kconfig +++ b/examples/utest/testcases/kernel/Kconfig @@ -39,4 +39,10 @@ config UTEST_MAILBOX_TC bool "mailbox test" default n +config UTEST_THREAD_TC + bool "thread test" + default n + select RT_USING_TIMER_SOFT + select RT_USING_THREAD + endmenu diff --git a/examples/utest/testcases/kernel/SConscript b/examples/utest/testcases/kernel/SConscript index 484f1fbf3b..0d2645427b 100644 --- a/examples/utest/testcases/kernel/SConscript +++ b/examples/utest/testcases/kernel/SConscript @@ -32,6 +32,9 @@ if GetDepend(['UTEST_MUTEX_TC']): if GetDepend(['UTEST_MAILBOX_TC']): src += ['mailbox_tc.c'] +if GetDepend(['UTEST_THREAD_TC']): + src += ['thread_tc.c'] + CPPPATH = [cwd] group = DefineGroup('utestcases', src, depend = [], CPPPATH = CPPPATH) diff --git a/examples/utest/testcases/kernel/thread_tc.c b/examples/utest/testcases/kernel/thread_tc.c new file mode 100644 index 0000000000..ea350cb46a --- /dev/null +++ b/examples/utest/testcases/kernel/thread_tc.c @@ -0,0 +1,641 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-09.01 yangjie the firet version + * 2021-10.11 mazhiyuan add idle, yield, suspend, control, priority, delay_until + */ + +#include +#include +#include "utest.h" + +#define THREAD_STACK_SIZE 512 +#define THREAD_TIMESLICE 10 + +ALIGN(RT_ALIGN_SIZE) +static char thread2_stack[1024]; +static struct rt_thread thread2; +#ifdef RT_USING_HEAP +static rt_thread_t tid1 = RT_NULL; +static rt_thread_t tid3 = RT_NULL; +static rt_thread_t tid4 = RT_NULL; +static rt_thread_t tid5 = RT_NULL; +static rt_thread_t tid6 = RT_NULL; +static rt_thread_t tid7 = RT_NULL; +#endif /* RT_USING_HEAP */ + +static rt_uint32_t tid3_delay_pass_flag = 0; +static rt_uint32_t tid3_finish_flag = 0; +static rt_uint32_t tid4_finish_flag = 0; +static rt_uint32_t tid6_finish_flag = 0; +static rt_uint32_t thread5_source = 0; + +#ifndef RT_USING_SMP +static rt_uint32_t thread_yield_flag = 0; +#endif +static rt_uint32_t entry_idle_hook_times = 0; +static rt_thread_t __current_thread; +static rt_uint8_t change_priority; +static rt_uint32_t count = 0; + +void thread1_entry(void* param) +{ + while(1); +} + +static void test_dynamic_thread(void) +{ + rt_err_t ret_startup = -RT_ERROR; + rt_err_t ret_delete = -RT_ERROR; + + tid1 = rt_thread_create("thread1", + thread1_entry, + (void*)1, + THREAD_STACK_SIZE, + __current_thread->current_priority + 1, + THREAD_TIMESLICE - 5); + if (tid1 == RT_NULL) + { + uassert_false(tid1 == RT_NULL); + goto __exit; + } + + ret_startup = rt_thread_startup(tid1); + if(ret_startup != RT_EOK) + { + uassert_false(ret_startup != RT_EOK); + goto __exit; + } + + ret_delete = rt_thread_delete(tid1); + if (ret_delete != RT_EOK) + { + uassert_false(ret_delete != RT_EOK); + goto __exit; + } + + uassert_true(tid1 != RT_NULL && ret_startup == RT_EOK && ret_delete == RT_EOK); + +__exit: + if (tid1 != RT_NULL && ret_delete != RT_EOK) + { + rt_thread_delete(tid1); + } + return; +} + +void thread2_entry(void* param) +{ + while(1); +} + +static void test_static_thread(void) +{ + rt_err_t ret_init = -RT_ERROR; + rt_err_t ret_startup = -RT_ERROR; + rt_err_t ret_detach = - RT_ERROR; + + ret_init = rt_thread_init(&thread2, + "thread2", + thread2_entry, + (void*)2, + &thread2_stack[0], + sizeof(thread2_stack), + __current_thread->current_priority + 1, + THREAD_TIMESLICE); + if (ret_init != RT_EOK) + { + uassert_false(ret_init != RT_EOK); + goto __exit; + } + + ret_startup = rt_thread_startup(&thread2); + if (ret_startup != RT_EOK) + { + uassert_false(ret_startup != RT_EOK); + goto __exit; + } + + ret_detach = rt_thread_detach(&thread2); + if (ret_detach != RT_EOK) + { + uassert_false(ret_detach != RT_EOK); + goto __exit; + } + + uassert_true(ret_init == RT_EOK && ret_startup == RT_EOK && ret_detach == RT_EOK); + +__exit: + if (ret_init == RT_EOK && ret_detach != RT_EOK) + { + rt_thread_detach(&thread2); + } + return; +} + +static void thread3_entry(void *parameter) +{ + rt_tick_t tick; + tick = rt_tick_get(); + rt_thread_delay(15); + if (rt_tick_get() - tick > 16) + { + tid3_finish_flag = 1; + tid3_delay_pass_flag = 0; + return; + } + tid3_delay_pass_flag = 1; + tid3_finish_flag = 1; +} + +static void test_thread_delay(void) +{ + rt_err_t ret_startup = -RT_ERROR; + + tid3 = rt_thread_create("thread3", + thread3_entry, + RT_NULL, + THREAD_STACK_SIZE, + __current_thread->current_priority - 1, + THREAD_TIMESLICE); + if (tid3 == RT_NULL) + { + LOG_E("rt_thread_create failed!"); + uassert_false(tid3 == RT_NULL); + goto __exit; + } + + ret_startup = rt_thread_startup(tid3); + if (ret_startup != RT_EOK) + { + LOG_E("rt_thread_startup failed!"); + uassert_false(1); + goto __exit; + } + + while (tid3_finish_flag != 1); + uassert_true(tid3_delay_pass_flag == 1); + +__exit: + return; +} + +static void idle_hook(void) +{ + entry_idle_hook_times ++; +} + +static void thread4_entry(void *parameter) +{ + rt_uint32_t delay_times = 5; + while (delay_times --) + { + rt_thread_mdelay(300); + } + rt_thread_idle_delhook(idle_hook); + tid4_finish_flag = 1; +} + +static void test_idle_hook(void) +{ + rt_err_t ret_startup = -RT_ERROR; + + rt_thread_idle_sethook(idle_hook); + + tid4 = rt_thread_create("thread4", + thread4_entry, + RT_NULL, + THREAD_STACK_SIZE, + __current_thread->current_priority - 1, + THREAD_TIMESLICE); + if (tid4 == RT_NULL) + { + LOG_E("rt_thread_create failed!"); + uassert_false(tid4 == RT_NULL); + goto __exit; + } + + ret_startup = rt_thread_startup(tid4); + if (ret_startup != RT_EOK) + { + LOG_E("rt_thread_startup failed!"); + uassert_false(1); + goto __exit; + } + + while (tid4_finish_flag != 1) + { + rt_thread_mdelay(200); + } + uassert_true(entry_idle_hook_times > 0); + +__exit: + return; +} + +static void thread5_entry(void *parameter) +{ + while (1) + { + thread5_source ++; + rt_thread_delay(5); + if (thread5_source == 5) + { + rt_thread_yield(); + } + } +} + +static void thread6_entry(void *parameter) +{ + while (++ thread5_source <= 9); + tid6_finish_flag = 1; +} + +static void test_thread_yield(void) +{ + rt_err_t ret_startup = -RT_ERROR; + tid5 = rt_thread_create("thread5", + thread5_entry, + RT_NULL, + THREAD_STACK_SIZE, + __current_thread->current_priority - 1, + THREAD_TIMESLICE); + if (tid5 == RT_NULL) + { + LOG_E("rt_thread_create failed!"); + uassert_false(tid5 == RT_NULL); + goto __exit; + } + ret_startup = rt_thread_startup(tid5); + if (ret_startup != RT_EOK) + { + LOG_E("rt_thread_startup failed!"); + uassert_false(1); + goto __exit; + } + tid6 = rt_thread_create("thread6", + thread6_entry, + RT_NULL, + THREAD_STACK_SIZE, + __current_thread->current_priority - 1, + THREAD_TIMESLICE); + if (tid6 == RT_NULL) + { + LOG_E("rt_thread_create failed!"); + uassert_false(tid6 == RT_NULL); + goto __exit; + } + ret_startup = rt_thread_startup(tid6); + if (ret_startup != RT_EOK) + { + LOG_E("rt_thread_startup failed!"); + uassert_false(1); + goto __exit; + } + + while (tid6_finish_flag != 1); + uassert_true(thread5_source == 10); + +__exit: + if (tid5 != RT_NULL) + { + rt_thread_delete(tid5); + } + return; +} + +static void thread7_entry(void *parameter) +{ + while (1); +} + +static void test_thread_control(void) +{ + rt_err_t ret_control = -RT_ERROR; + rt_err_t rst_delete = -RT_ERROR; + + tid7 = rt_thread_create("thread7", + thread7_entry, + RT_NULL, + THREAD_STACK_SIZE, + __current_thread->current_priority + 1, + THREAD_TIMESLICE); + if (tid7 == RT_NULL) + { + LOG_E("rt_thread_create failed!"); + uassert_false(tid7 == RT_NULL); + goto __exit; + } + + ret_control = rt_thread_control(tid7, RT_THREAD_CTRL_STARTUP, RT_NULL); + if (ret_control != RT_EOK) + { + LOG_E("rt_thread_control failed!"); + uassert_false(1); + goto __exit; + } + rt_thread_mdelay(200); + rt_thread_control(tid7, RT_THREAD_CTRL_CHANGE_PRIORITY, &change_priority); + if (tid7->current_priority != change_priority) + { + LOG_E("rt_thread_control failed!"); + uassert_false(1); + goto __exit; + } + rst_delete = rt_thread_control(tid7, RT_THREAD_CTRL_CLOSE, RT_NULL); + if (rst_delete != RT_EOK) + { + LOG_E("rt_thread_control failed!"); + uassert_false(rst_delete != RT_EOK); + goto __exit; + } + + uassert_true(1); + +__exit: + if (tid7 != RT_NULL && rst_delete != RT_EOK) + { + rt_thread_delete(tid7); + } + return; +} + +static void thread8_entry(void *parameter) +{ + for (; count < 10; count ++); +} + +static void test_thread_priority(void) +{ + rt_err_t ret_startup = -RT_ERROR; + rt_thread_t tid8 = RT_NULL; + + tid8 = rt_thread_create("thread8", + thread8_entry, + RT_NULL, + THREAD_STACK_SIZE, + __current_thread->current_priority - 1, + THREAD_TIMESLICE); + if (tid8 == RT_NULL) + { + LOG_E("rt_thread_create failed!"); + uassert_false(tid8 == RT_NULL); + return; + } + count = 0; + ret_startup = rt_thread_startup(tid8); + if(ret_startup != RT_EOK) + { + uassert_false(ret_startup != RT_EOK); + return ; + } + uassert_true(count == 10); + + return; +} + +static void test_delay_until(void) +{ + rt_tick_t tick; + rt_tick_t check_tick = 0; + rt_tick_t delta = 0; + + tick = rt_tick_get(); + + check_tick = tick; + rt_thread_delay_until(&tick, 100); + delta = rt_tick_get() - check_tick; + rt_kprintf("delta[100] -> %d\n", delta); + uassert_int_equal(delta, 100); + + check_tick = tick; + rt_thread_delay(2); + rt_thread_delay_until(&tick, 200); + delta = rt_tick_get() - check_tick; + rt_kprintf("delta[200] -> %d\n", delta); + uassert_int_equal(delta, 200); + + check_tick = tick; + rt_thread_delay(2); + rt_thread_delay_until(&tick, 300); + delta = rt_tick_get() - check_tick; + rt_kprintf("delta[300] -> %d\n", delta); + uassert_int_equal(delta, 300); + + check_tick = tick; + rt_thread_delay(2); + rt_thread_delay_until(&tick, 100); + delta = rt_tick_get() - check_tick; + uassert_int_equal(delta, 100); + + check_tick = tick; + rt_thread_delay(2); + rt_thread_delay_until(&tick, 50); + delta = rt_tick_get() - check_tick; + rt_kprintf("delta[50] -> %d\n", delta); + uassert_int_equal(delta, 50); + + check_tick = tick; + rt_thread_delay(2); + rt_thread_delay_until(&tick, 20); + delta = rt_tick_get() - check_tick; + rt_kprintf("delta[20] -> %d\n", delta); + uassert_int_equal(delta, 20); + + check_tick = tick; + rt_thread_delay(2); + rt_thread_delay_until(&tick, 10); + delta = rt_tick_get() - check_tick; + rt_kprintf("delta[10] -> %d\n", delta); + uassert_int_equal(delta, 10); +} + +#ifndef RT_USING_SMP +static volatile rt_uint32_t yield_count; + +static void test_thread_yield_inc_entry(void* parameter) +{ + rt_uint32_t loop = 0; + + while (1) + { + if (loop++ > 10001) + break; + yield_count++; + rt_thread_yield(); + } +} + +static void test_thread_yield_entry(void* parameter) +{ + rt_err_t ret_startup = -RT_ERROR; + + rt_thread_t tid; + rt_uint32_t loop = 0; + rt_uint32_t count_before; + + tid = rt_thread_create("inc", test_thread_yield_inc_entry, RT_NULL, + 2048, 1, 10); + if (!tid) + { + LOG_E("rt_thread_create failed!"); + return; + } + + ret_startup = rt_thread_startup(tid); + if (ret_startup != RT_EOK) + { + LOG_E("rt_thread_startup failed!"); + uassert_false(1); + return ; + } + + while (1) + { + if (loop++ > 10000) + break; + + count_before = yield_count; + rt_thread_yield(); + if (yield_count == count_before) + { + LOG_E("yield error!"); + return; + } + } + thread_yield_flag = 1; +} + +void test_thread_yield_nosmp(void) +{ + rt_err_t ret_startup = -RT_ERROR; + + rt_thread_t tid; + + yield_count = 0; + + tid = rt_thread_create("chkcnt", test_thread_yield_entry, RT_NULL, + 2048, 1, 10); + if (!tid) + { + LOG_E("rt_thread_create failed!"); + return; + } + + ret_startup = rt_thread_startup(tid); + if (ret_startup != RT_EOK) + { + LOG_E("rt_thread_startup failed!"); + uassert_false(1); + return ; + } + + uassert_true(thread_yield_flag == 1); +} + +static rt_uint32_t thread9_count = 0; +static void thread9_entry(void *parameter) +{ + while(1) + { + thread9_count ++; + } + +} +static void test_thread_suspend(void){ + static rt_thread_t tid; + rt_err_t ret_startup = -RT_ERROR; + uint32_t count_before_suspend, count_before_resume, count_after_resume; + tid = rt_thread_create("thread9", + thread9_entry, + RT_NULL, + THREAD_STACK_SIZE, + __current_thread->current_priority + 1, + THREAD_TIMESLICE); + if (tid == RT_NULL) + { + LOG_E("rt_thread_create failed!"); + uassert_false(tid4 == RT_NULL); + goto __exit; + } + + ret_startup = rt_thread_startup(tid); + if (ret_startup != RT_EOK) + { + LOG_E("rt_thread_startup failed!"); + uassert_false(1); + goto __exit; + } + rt_thread_delay(5); + rt_thread_suspend(tid); + count_before_suspend = thread9_count; + uassert_true(count_before_suspend != 0); + rt_thread_delay(5); + count_before_resume = thread9_count; + uassert_true(count_before_suspend == count_before_resume); + rt_thread_resume(tid); + rt_thread_delay(5); + count_after_resume = thread9_count; + uassert_true(count_after_resume != count_before_resume); + +__exit: + if (tid != RT_NULL) + { + rt_thread_delete(tid); + } + return; +} +#endif + +static rt_err_t utest_tc_init(void) +{ + __current_thread = rt_thread_self(); + change_priority = __current_thread->current_priority + 5; + tid3_delay_pass_flag = 0; + tid3_finish_flag = 0; + tid4_finish_flag = 0; + tid6_finish_flag = 0; + entry_idle_hook_times = 0; + count = 0; + return RT_EOK; +} + +static rt_err_t utest_tc_cleanup(void) +{ + return RT_EOK; +} + +static void testcase(void) +{ + /* init, detach */ + UTEST_UNIT_RUN(test_static_thread); + /* create, delete */ + UTEST_UNIT_RUN(test_dynamic_thread); + /* delay */ + UTEST_UNIT_RUN(test_thread_delay); + /* idle_sethook, idle_delhook */ + UTEST_UNIT_RUN(test_idle_hook); + /* yield */ + UTEST_UNIT_RUN(test_thread_yield); +#ifndef RT_USING_SMP + /* yield_nosmp */ + UTEST_UNIT_RUN(test_thread_yield_nosmp); + /* suspend, resume */ + UTEST_UNIT_RUN(test_thread_suspend); +#endif + /* control */ + UTEST_UNIT_RUN(test_thread_control); + UTEST_UNIT_RUN(test_thread_priority); + /* delay_until */ + UTEST_UNIT_RUN(test_delay_until); +} + + +UTEST_TC_EXPORT(testcase, "testcases.kernel.thread_tc", utest_tc_init, utest_tc_cleanup, 1000); + +/********************* end of file ************************/ -- cgit v1.3.1