Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
Mozi
rt-thread
提交
5a74bf33
R
rt-thread
项目概览
Mozi
/
rt-thread
与 Fork 源项目一致
Fork自
RT-Thread / rt-thread
通知
0
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
R
rt-thread
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
未验证
提交
5a74bf33
编写于
9月 09, 2021
作者:
G
guo
提交者:
GitHub
9月 09, 2021
浏览文件
操作
浏览文件
下载
差异文件
Merge pull request #5020 from tyustli/mutex_tc
[add] utest kernel mutex_tc.c file
上级
7fa1c819
0b55a752
变更
4
隐藏空白更改
内联
并排
Showing
4 changed file
with
685 addition
and
0 deletion
+685
-0
examples/utest/configs/kernel/ipc.conf
examples/utest/configs/kernel/ipc.conf
+2
-0
examples/utest/testcases/kernel/Kconfig
examples/utest/testcases/kernel/Kconfig
+4
-0
examples/utest/testcases/kernel/SConscript
examples/utest/testcases/kernel/SConscript
+3
-0
examples/utest/testcases/kernel/mutex_tc.c
examples/utest/testcases/kernel/mutex_tc.c
+676
-0
未找到文件。
examples/utest/configs/kernel/ipc.conf
浏览文件 @
5a74bf33
...
...
@@ -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
examples/utest/testcases/kernel/Kconfig
浏览文件 @
5a74bf33
...
...
@@ -31,4 +31,8 @@ config UTEST_SIGNAL_TC
bool "signal test"
default n
config UTEST_MUTEX_TC
bool "mutex test"
default n
endmenu
examples/utest/testcases/kernel/SConscript
浏览文件 @
5a74bf33
...
...
@@ -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
)
...
...
examples/utest/testcases/kernel/mutex_tc.c
0 → 100644
浏览文件 @
5a74bf33
/*
* 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 ************************/
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录