Merge remote-tracking branch 'remotes/rtt_github/master'

6 files changed, 1466 insertions, 0 deletions

diff --git a/examples/utest/testcases/kernel/Kconfig b/examples/utest/testcases/kernel/Kconfig
index 1854721193..fba3b8c511 100644
--- a/examples/utest/testcases/kernel/Kconfig
+++ b/examples/utest/testcases/kernel/Kconfig
@@ -23,4 +23,20 @@ config UTEST_TIMER_TC
     bool "timer test"
     default n
 
+config UTEST_MESSAGEQUEUE_TC
+    bool "message queue test"
+    default n
+
+config UTEST_SIGNAL_TC
+    bool "signal test"
+    default n
+
+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 758dea4d3f..484f1fbf3b 100644
--- a/examples/utest/testcases/kernel/SConscript
+++ b/examples/utest/testcases/kernel/SConscript
@@ -20,6 +20,18 @@ if GetDepend(['UTEST_EVENT_TC']):
 if GetDepend(['UTEST_TIMER_TC']):
     src += ['timer_tc.c']
 
+if GetDepend(['UTEST_MESSAGEQUEUE_TC']):
+    src += ['messagequeue_tc.c']
+
+if GetDepend(['UTEST_SIGNAL_TC']):
+    src += ['signal_tc.c']
+
+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 <rtthread.h>
+#include "utest.h"
+#include <stdlib.h>
+
+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);
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 <rtthread.h>
+#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);
diff --git a/examples/utest/testcases/kernel/mutex_tc.c b/examples/utest/testcases/kernel/mutex_tc.c
new file mode 100644
index 0000000000..f50e3e43f7
--- /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 <rtthread.h>
+#include <stdlib.h>
+#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 and 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;
+    }
+
+    /* thread1 */
+    tid1 = rt_thread_create("thread1",
+                            static_thread1_entry,
+                            &static_mutex,
+                            1024,
+                            10 - 1,
+                            10);
+    if (tid1 != RT_NULL)
+        rt_thread_startup(tid1);
+
+    /* thread2 */
+    tid2 = rt_thread_create("thread2",
+                            static_thread2_entry,
+                            &static_mutex,
+                            1024,
+                            10,
+                            10);
+    if (tid2 != RT_NULL)
+        rt_thread_startup(tid2);
+
+    /* thread3 */
+    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 and 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;
+    }
+
+    /* thread1 */
+    tid1 = rt_thread_create("thread1",
+                            dynamic_thread1_entry,
+                            dynamic_mutex,
+                            1024,
+                            10 - 1,
+                            10);
+    if (tid1 != RT_NULL)
+        rt_thread_startup(tid1);
+
+    /* thread2 */
+    tid2 = rt_thread_create("thread2",
+                            dynamic_thread2_entry,
+                            dynamic_mutex,
+                            1024,
+                            10,
+                            10);
+    if (tid2 != RT_NULL)
+        rt_thread_startup(tid2);
+
+    /* thread3 */
+    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 ************************/
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 <rtthread.h>
+#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 ****************************/