py6atlu3x
/
openharmonydocs
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

Merge branch 'main' of https://bdgit.educoder.net/py6atlu3x/openharmonydocs

Browse Source
main^2
熊卓孜 7 months ago
parent 796b79839f 4e9288d1c6
commit fe05466eeb
3 changed files with 146 additions and 143 deletions
Show Stats Download Patch File Download Diff File

139
kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_atfork_test_001.cpp
Unescape View File

@ -29,66 +29,66 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "it_pthread_test.h"
// 全局变量
static volatile int g_count = 0; // 计数器，控制线程的执行
static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER; // 互斥锁，用于同步
static int g_testAtforkCount = 0; // 测试计数器，用于检查不同阶段
static int g_testAtforkPrepare = 0; // 用于检查fork前的准备阶段
static int g_testAtforkParent = 0; // 用于标记父进程执行的步骤
static int g_testAtforkChild = 0; // 用于标记子进程执行的步骤
static const int SLEEP_TIME = 2; // 睡眠时间，单位秒
// 准备函数，fork之前执行
// 全局变量
static volatile int g_count = 0; // 计数器，控制线程的执行
static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER; // 互斥锁，用于同步
static int g_testAtforkCount = 0; // 测试计数器，用于检查不同阶段
static int g_testAtforkPrepare = 0; // 用于检查fork前的准备阶段
static int g_testAtforkParent = 0; // 用于标记父进程执行的步骤
static int g_testAtforkChild = 0; // 用于标记子进程执行的步骤
static const int SLEEP_TIME = 2; // 睡眠时间，单位秒
// 准备函数，fork之前执行
static void Prepare()
{
int err;
ICUNIT_ASSERT_EQUAL_VOID(g_testAtforkCount, 1, g_testAtforkCount); // 确保g_testAtforkCount为1
err = pthread_mutex_lock(&g_lock); // 加锁
ICUNIT_ASSERT_EQUAL_VOID(err, 0, err); // 确保加锁成功
g_testAtforkPrepare++; // 标记准备阶段已执行
ICUNIT_ASSERT_EQUAL_VOID(g_testAtforkCount, 1, g_testAtforkCount); // 确保g_testAtforkCount为1
err = pthread_mutex_lock(&g_lock); // 加锁
ICUNIT_ASSERT_EQUAL_VOID(err, 0, err); // 确保加锁成功
g_testAtforkPrepare++; // 标记准备阶段已执行
}
// 父进程执行的函数
// 父进程执行的函数
static void Parent()
{
int err;
ICUNIT_ASSERT_EQUAL_VOID(g_testAtforkCount, 1, g_testAtforkCount); // 确保g_testAtforkCount为1
err = pthread_mutex_unlock(&g_lock); // 解锁
ICUNIT_ASSERT_EQUAL_VOID(err, 0, err); // 确保解锁成功
g_testAtforkParent++; // 标记父进程阶段已执行
ICUNIT_ASSERT_EQUAL_VOID(g_testAtforkCount, 1, g_testAtforkCount); // 确保g_testAtforkCount为1
err = pthread_mutex_unlock(&g_lock); // 解锁
ICUNIT_ASSERT_EQUAL_VOID(err, 0, err); // 确保解锁成功
g_testAtforkParent++; // 标记父进程阶段已执行
}
// 子进程执行的函数
// 子进程执行的函数
static void child()
{
int err;
ICUNIT_ASSERT_EQUAL_VOID(g_testAtforkCount, 1, g_testAtforkCount); // 确保g_testAtforkCount为1
err = pthread_mutex_unlock(&g_lock); // 解锁
ICUNIT_ASSERT_EQUAL_VOID(err, 0, err); // 确保解锁成功
g_testAtforkChild++; // 标记子进程阶段已执行
ICUNIT_ASSERT_EQUAL_VOID(g_testAtforkCount, 1, g_testAtforkCount); // 确保g_testAtforkCount为1
err = pthread_mutex_unlock(&g_lock); // 解锁
ICUNIT_ASSERT_EQUAL_VOID(err, 0, err); // 确保解锁成功
g_testAtforkChild++; // 标记子进程阶段已执行
}
// 线程执行的函数
// 线程执行的函数
static void *ThreadProc(void *arg)
{
int err;
// 当g_count小于5时，线程继续执行
while (g_count < 5) { // 5, 等待直到g_count == 5
err = pthread_mutex_lock(&g_lock); // 加锁
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保加锁成功
g_count++; // 增加计数
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
err = pthread_mutex_unlock(&g_lock); // 解锁
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保解锁成功
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
// 当g_count小于5时，线程继续执行
while (g_count < 5) { // 5, 等待直到g_count == 5
err = pthread_mutex_lock(&g_lock); // 加锁
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保加锁成功
g_count++; // 增加计数
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
err = pthread_mutex_unlock(&g_lock); // 解锁
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保解锁成功
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
}
EXIT:
return NULL;
}
// 测试pthread_atfork的函数
// 测试pthread_atfork的函数
static void *PthreadAtforkTest(void *arg)
{
int err;
@ -96,63 +96,63 @@ static void *PthreadAtforkTest(void *arg)
pthread_t tid;
int status = 0;
// 初始化全局变量
// 初始化全局变量
g_count = 0;
g_testAtforkCount = 0;
g_testAtforkPrepare = 0;
g_testAtforkParent = 0;
g_testAtforkChild = 0;
// 创建新线程
// 创建新线程
err = pthread_create(&tid, NULL, ThreadProc, NULL);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保线程创建成功
err = pthread_atfork(Prepare, Parent, child); // 注册fork前后要执行的函数
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保注册成功
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保线程创建成功
err = pthread_atfork(Prepare, Parent, child); // 注册fork前后要执行的函数
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保注册成功
g_testAtforkCount++; // 标记已执行测试的计数
g_testAtforkCount++; // 标记已执行测试的计数
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
// 创建子进程
// 创建子进程
pid = fork();
ICUNIT_GOTO_WITHIN_EQUAL(pid, 0, 100000, pid, EXIT); // 确保pid合理，子进程的pid不会超过100000
ICUNIT_GOTO_EQUAL(g_testAtforkPrepare, 1, g_testAtforkPrepare, EXIT); // 确保准备阶段已执行
ICUNIT_GOTO_WITHIN_EQUAL(pid, 0, 100000, pid, EXIT); // 确保pid合理，子进程的pid不会超过100000
ICUNIT_GOTO_EQUAL(g_testAtforkPrepare, 1, g_testAtforkPrepare, EXIT); // 确保准备阶段已执行
// 子进程执行的代码
// 子进程执行的代码
if (pid == 0) {
ICUNIT_GOTO_EQUAL(g_testAtforkChild, 1, g_testAtforkChild, EXIT); // 确保子进程阶段已执行
while (g_count < 5) { // 等待直到g_count == 5
err = pthread_mutex_lock(&g_lock); // 加锁
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保加锁成功
g_count++; // 增加计数
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
err = pthread_mutex_unlock(&g_lock); // 解锁
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保解锁成功
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
ICUNIT_GOTO_EQUAL(g_testAtforkChild, 1, g_testAtforkChild, EXIT); // 确保子进程阶段已执行
while (g_count < 5) { // 等待直到g_count == 5
err = pthread_mutex_lock(&g_lock); // 加锁
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保加锁成功
g_count++; // 增加计数
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
err = pthread_mutex_unlock(&g_lock); // 解锁
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保解锁成功
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
}
exit(15); // 退出并设置状态为15
exit(15); // 退出并设置状态为15
}
// 父进程的验证
// 父进程的验证
ICUNIT_GOTO_EQUAL(g_testAtforkParent, 1, g_testAtforkParent, EXIT_WAIT);
err = pthread_join(tid, NULL); // 等待线程结束
err = pthread_join(tid, NULL); // 等待线程结束
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT_WAIT);
// 父进程等待子进程结束并验证退出状态
// 父进程等待子进程结束并验证退出状态
err = waitpid(pid, &status, 0);
status = WEXITSTATUS(status);
ICUNIT_GOTO_EQUAL(err, pid, err, EXIT); // 确保waitpid成功
ICUNIT_GOTO_EQUAL(status, 15, status, EXIT); // 确保子进程的退出状态为15
ICUNIT_GOTO_EQUAL(err, pid, err, EXIT); // 确保waitpid成功
ICUNIT_GOTO_EQUAL(status, 15, status, EXIT); // 确保子进程的退出状态为15
EXIT:
return NULL;
EXIT_WAIT:
(void)waitpid(pid, &status, 0); // 等待子进程结束
(void)waitpid(pid, &status, 0); // 等待子进程结束
return NULL;
}
// 测试主程序
// 测试主程序
static int Testcase()
{
int ret;
@ -161,29 +161,30 @@ static int Testcase()
pthread_attr_t a = { 0 };
struct sched_param param = { 0 };
// 获取当前线程的调度参数
// 获取当前线程的调度参数
ret = pthread_getschedparam(pthread_self(), &curThreadPolicy, &param);
ICUNIT_ASSERT_EQUAL(ret, 0, -ret);
curThreadPri = param.sched_priority;
// 设置新的线程属性并创建新线程
// 设置新的线程属性并创建新线程
ret = pthread_attr_init(&a);
pthread_attr_setinheritsched(&a, PTHREAD_EXPLICIT_SCHED);
param.sched_priority = curThreadPri + 2; // 提高线程优先级
param.sched_priority = curThreadPri + 2; // 提高线程优先级
pthread_attr_setschedparam(&a, &param);
ret = pthread_create(&newPthread, &a, PthreadAtforkTest, 0); // 创建新线程
ret = pthread_create(&newPthread, &a, PthreadAtforkTest, 0); // 创建新线程
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
// 等待新线程结束
// 等待新线程结束
ret = pthread_join(newPthread, NULL);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
return 0;
}
// 测试用例的入口函数
// 测试用例的入口函数
void ItTestPthreadAtfork001(void)
{
TEST_ADD_CASE("IT_PTHREAD_ATFORK_001", Testcase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION);
}

81
kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_atfork_test_002.cpp
Unescape View File

@ -38,13 +38,13 @@
extern int nanosleep(const struct timespec *req, struct timespec *rem);
// 全局变量
// 全局变量
static pthread_mutex_t g_mux = PTHREAD_MUTEX_INITIALIZER;
static volatile int g_testAtforkCount = 0;
static int g_testAtforkPrepare = 0;
static int g_testAtforkParent = 0;
// 函数原型
// 函数原型
static void *Doit(void *arg);
static void *Doit1(void *arg);
static void Prepare(void);
@ -53,69 +53,69 @@ static void *PthreadAtforkTest(void *arg);
static int Testcase(void);
void ItTestPthreadAtfork002(void);
// Doit 函数（线程 1）
// Doit 函数（线程 1）
static void *Doit(void *arg)
{
int err;
struct timespec ts = { 2, 0 }; // 睡眠 2 秒
struct timespec ts = { 2, 0 }; // 睡眠 2 秒
// 确保全局变量 g_testAtforkCount 为 1
// 确保全局变量 g_testAtforkCount 为 1
if (g_testAtforkCount != 1) {
return NULL;
}
// 锁住互斥锁
// 锁住互斥锁
err = pthread_mutex_lock(&g_mux);
if (err != 0) return NULL;
(void)nanosleep(&ts, NULL); // 睡眠 2 秒
err = pthread_mutex_unlock(&g_mux); // 解锁互斥锁
(void)nanosleep(&ts, NULL); // 睡眠 2 秒
err = pthread_mutex_unlock(&g_mux); // 解锁互斥锁
if (err != 0) return NULL;
return NULL;
}
// Doit1 函数（线程 2 - 子进程）
// Doit1 函数（线程 2 - 子进程）
static void *Doit1(void *arg)
{
int err;
struct timespec ts = { 2, 0 }; // 睡眠 2 秒
struct timespec ts = { 2, 0 }; // 睡眠 2 秒
// 确保全局变量 g_testAtforkCount 为 1
// 确保全局变量 g_testAtforkCount 为 1
if (g_testAtforkCount != 1) {
return NULL;
}
// 锁住互斥锁
// 锁住互斥锁
err = pthread_mutex_lock(&g_mux);
if (err != 0) return NULL;
(void)nanosleep(&ts, NULL); // 睡眠 2 秒
err = pthread_mutex_unlock(&g_mux); // 解锁互斥锁
(void)nanosleep(&ts, NULL); // 睡眠 2 秒
err = pthread_mutex_unlock(&g_mux); // 解锁互斥锁
if (err != 0) return NULL;
return NULL;
}
// Prepare 函数（在 fork 前调用）
// Prepare 函数（在 fork 前调用）
static void Prepare(void)
{
int err;
err = pthread_mutex_unlock(&g_mux); // 在 fork 前解锁互斥锁
err = pthread_mutex_unlock(&g_mux); // 在 fork 前解锁互斥锁
if (err != 0) return;
g_testAtforkPrepare++; // 增加 prepare 计数
g_testAtforkPrepare++; // 增加 prepare 计数
}
// Parent 函数（在 fork 后父进程中调用）
// Parent 函数（在 fork 后父进程中调用）
static void Parent(void)
{
int err = pthread_mutex_lock(&g_mux); // 在父进程中锁住互斥锁
int err = pthread_mutex_lock(&g_mux); // 在父进程中锁住互斥锁
if (err != 0) return;
g_testAtforkParent++; // 增加父进程计数
g_testAtforkParent++; // 增加父进程计数
}
// PthreadAtforkTest 函数（主测试函数）
// PthreadAtforkTest 函数（主测试函数）
static void *PthreadAtforkTest(void *arg)
{
int err, ret;
@ -128,45 +128,45 @@ static void *PthreadAtforkTest(void *arg)
g_testAtforkPrepare = 0;
g_testAtforkParent = 0;
// 注册 pthread_atfork 的回调函数
// 注册 pthread_atfork 的回调函数
err = pthread_atfork(Prepare, Parent, NULL);
if (err != 0) return NULL;
g_testAtforkCount++; // 增加计数用于测试
g_testAtforkCount++; // 增加计数用于测试
// 创建一个线程执行 Doit 函数
// 创建一个线程执行 Doit 函数
err = pthread_create(&tid, NULL, Doit, NULL);
if (err != 0) return NULL;
nanosleep(&ts, NULL); // 睡眠 1 秒
pid = fork(); // 创建子进程
nanosleep(&ts, NULL); // 睡眠 1 秒
pid = fork(); // 创建子进程
// 检查 Prepare 函数是否被调用
// 检查 Prepare 函数是否被调用
if (g_testAtforkPrepare != 1) {
return NULL;
}
if (pid == 0) {
Doit1(NULL); // 在子进程中执行 Doit1 函数
exit(10); // 子进程退出，返回状态 10
Doit1(NULL); // 在子进程中执行 Doit1 函数
exit(10); // 子进程退出，返回状态 10
}
if (pid <= 0) {
return NULL;
}
// 检查 Parent 函数是否被调用
// 检查 Parent 函数是否被调用
if (g_testAtforkParent != 1) {
return NULL;
}
// 等待线程执行完毕
// 等待线程执行完毕
err = pthread_join(tid, NULL);
if (err != 0) return NULL;
// 等待子进程结束
// 等待子进程结束
err = waitpid(pid, &status, 0);
status = WEXITSTATUS(status); // 获取子进程退出状态
status = WEXITSTATUS(status); // 获取子进程退出状态
if (err != pid || status != 10) {
return NULL;
}
@ -174,7 +174,7 @@ static void *PthreadAtforkTest(void *arg)
return NULL;
}
// Testcase 函数（初始化线程调度参数并执行测试）
// Testcase 函数（初始化线程调度参数并执行测试）
static int Testcase(void)
{
int ret;
@ -183,33 +183,34 @@ static int Testcase(void)
pthread_attr_t a = { 0 };
struct sched_param param = { 0 };
// 获取当前线程的调度参数
// 获取当前线程的调度参数
ret = pthread_getschedparam(pthread_self(), &curThreadPolicy, &param);
if (ret != 0) return ret;
curThreadPri = param.sched_priority;
// 初始化线程属性
// 初始化线程属性
ret = pthread_attr_init(&a);
if (ret != 0) return ret;
pthread_attr_setinheritsched(&a, PTHREAD_EXPLICIT_SCHED);
param.sched_priority = curThreadPri + 2; // 设置线程优先级为当前优先级 + 2
param.sched_priority = curThreadPri + 2; // 设置线程优先级为当前优先级 + 2
pthread_attr_setschedparam(&a, &param);
// 创建新线程执行 PthreadAtforkTest 函数
// 创建新线程执行 PthreadAtforkTest 函数
ret = pthread_create(&newPthread, &a, PthreadAtforkTest, 0);
if (ret != 0) return ret;
// 等待新线程执行完毕
// 等待新线程执行完毕
ret = pthread_join(newPthread, NULL);
if (ret != 0) return ret;
return 0;
}
// ItTestPthreadAtfork002 函数（测试用例入口）
// ItTestPthreadAtfork002 函数（测试用例入口）
void ItTestPthreadAtfork002(void)
{
TEST_ADD_CASE("IT_PTHREAD_ATFORK_002", Testcase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION);
}

69
kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_001.cpp
Unescape View File

@ -29,99 +29,99 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <pthread.h>
#include "ICUnit.h" // 假设你有这个头文件来处理测试相关的宏
#include "ICUnit.h" // 假设你有这个头文件来处理测试相关的宏
static pthread_mutex_t g_pthreadMuxTest1; // 定义互斥锁
static pthread_cond_t g_pthdCondTest1; // 定义条件变量
static pthread_mutex_t g_pthreadMuxTest1; // 定义互斥锁
static pthread_cond_t g_pthdCondTest1; // 定义条件变量
// 线程1的函数
// 线程1的函数
static void *PthreadF01(void *t)
{
int rc;
// 锁住互斥锁
// 锁住互斥锁
rc = pthread_mutex_lock(&g_pthreadMuxTest1);
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
g_testCount++; // g_testCount加1
LosTaskDelay(100); // 延时100ms
ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT); // 断言g_testCount应为2
g_testCount++; // g_testCount再加1
g_testCount++; // g_testCount加1
LosTaskDelay(100); // 延时100ms
ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT); // 断言g_testCount应为2
g_testCount++; // g_testCount再加1
// 等待条件变量，释放互斥锁
// 等待条件变量，释放互斥锁
rc = pthread_cond_wait(&g_pthdCondTest1, &g_pthreadMuxTest1);
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
ICUNIT_GOTO_EQUAL(g_testCount, 5, g_testCount, EXIT); // 断言g_testCount应为5
rc = pthread_mutex_unlock(&g_pthreadMuxTest1); // 解锁互斥锁
ICUNIT_GOTO_EQUAL(g_testCount, 5, g_testCount, EXIT); // 断言g_testCount应为5
rc = pthread_mutex_unlock(&g_pthreadMuxTest1); // 解锁互斥锁
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
EXIT:
return NULL;
}
// 线程2的函数
// 线程2的函数
static void *PthreadF02(void *t)
{
int rc;
ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT); // 断言g_testCount应为1
g_testCount++; // g_testCount加1
ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT); // 断言g_testCount应为1
g_testCount++; // g_testCount加1
// 锁住互斥锁
// 锁住互斥锁
rc = pthread_mutex_lock(&g_pthreadMuxTest1);
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT); // 断言g_testCount应为3
g_testCount++; // g_testCount再加1
ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT); // 断言g_testCount应为3
g_testCount++; // g_testCount再加1
// 发送信号，唤醒线程1
// 发送信号，唤醒线程1
rc = pthread_cond_signal(&g_pthdCondTest1);
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
ICUNIT_GOTO_EQUAL(g_testCount, 4, g_testCount, EXIT); // 断言g_testCount应为4
g_testCount++; // g_testCount再加1
ICUNIT_GOTO_EQUAL(g_testCount, 4, g_testCount, EXIT); // 断言g_testCount应为4
g_testCount++; // g_testCount再加1
// 解锁互斥锁
// 解锁互斥锁
rc = pthread_mutex_unlock(&g_pthreadMuxTest1);
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
LosTaskDelay(2); // 延时2ms，控制时序
LosTaskDelay(2); // 延时2ms，控制时序
EXIT:
pthread_exit(NULL);
}
// 测试用例
// 测试用例
static unsigned int TestCase(void)
{
int rc;
pthread_t threads[2]; // 需要2个线程来进行测试
const int loopNum = 2; // 循环次数
pthread_t threads[2]; // 需要2个线程来进行测试
const int loopNum = 2; // 循环次数
g_testCount = 0;
pthread_mutex_init(&g_pthreadMuxTest1, NULL); // 初始化互斥锁
pthread_cond_init(&g_pthdCondTest1, NULL); // 初始化条件变量
pthread_mutex_init(&g_pthreadMuxTest1, NULL); // 初始化互斥锁
pthread_cond_init(&g_pthdCondTest1, NULL); // 初始化条件变量
// 创建线程1
// 创建线程1
rc = pthread_create(&threads[0], NULL, PthreadF01, NULL);
ICUNIT_ASSERT_EQUAL(rc, 0, rc);
// 创建线程2
// 创建线程2
rc = pthread_create(&threads[1], NULL, PthreadF02, NULL);
ICUNIT_ASSERT_EQUAL(rc, 0, rc);
// 等待线程结束
// 等待线程结束
for (int i = 0; i < loopNum; i++) {
rc = pthread_join(threads[i], NULL);
ICUNIT_ASSERT_EQUAL(rc, 0, rc);
}
// 销毁线程属性
// 销毁线程属性
rc = pthread_attr_destroy(NULL);
ICUNIT_ASSERT_EQUAL(rc, 0, rc);
// 销毁互斥锁和条件变量
// 销毁互斥锁和条件变量
rc = pthread_mutex_destroy(&g_pthreadMuxTest1);
ICUNIT_ASSERT_EQUAL(rc, 0, rc);
rc = pthread_cond_destroy(&g_pthdCondTest1);
@ -130,8 +130,9 @@ static unsigned int TestCase(void)
return 0;
}
// 测试用例入口函数
// 测试用例入口函数
void ItTestPthreadCond001(void)
{
TEST_ADD_CASE("IT_POSIX_PTHREAD_COND_001", TestCase, TEST_POSIX, TEST_PTHREAD, TEST_LEVEL2, TEST_FUNCTION);
}

Write Preview
Loading…
Cancel
Save