diff --git a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_atfork_test_002.cpp b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_atfork_test_002.cpp index 018d613..ba6e98e 100644 --- a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_atfork_test_002.cpp +++ b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_atfork_test_002.cpp @@ -1,3 +1,4 @@ +// 版权声明 /* * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved. * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved. @@ -28,27 +29,35 @@ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +// 包含头文件 #include "it_pthread_test.h" #include +// 声明外部函数nanosleep，用于线程休眠 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; +// 线程函数Doit，用于测试pthread_atfork static void *Doit(void *arg) { int err; - struct timespec ts = { 2, 0 }; // 2, set time 2s. + struct timespec ts = { 2, 0 }; // 设置休眠时间为2秒 + // 断言g_testAtforkCount为1 ICUNIT_GOTO_EQUAL(g_testAtforkCount, 1, g_testAtforkCount, EXIT); + // 尝试获取互斥锁 err = pthread_mutex_lock(&g_mux); ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); + // 休眠2秒 (void)nanosleep(&ts, NULL); + // 释放互斥锁 err = pthread_mutex_unlock(&g_mux); ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); @@ -56,17 +65,22 @@ EXIT: return NULL; } +// 线程函数Doit1，与Doit类似，用于测试pthread_atfork static void *Doit1(void *arg) { int err; - struct timespec ts = { 2, 0 }; // 2, set time 2s. + struct timespec ts = { 2, 0 }; // 设置休眠时间为2秒 + // 断言g_testAtforkCount为1 ICUNIT_GOTO_EQUAL(g_testAtforkCount, 1, g_testAtforkCount, EXIT); + // 尝试获取互斥锁 err = pthread_mutex_lock(&g_mux); ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); + // 休眠2秒 (void)nanosleep(&ts, NULL); + // 释放互斥锁 err = pthread_mutex_unlock(&g_mux); ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); @@ -74,15 +88,19 @@ EXIT: return NULL; } +// Prepare函数，在fork之前调用 static void Prepare(void) { int err; + // 释放互斥锁 err = pthread_mutex_unlock(&g_mux); ICUNIT_ASSERT_EQUAL_VOID(err, 0, err); + // 增加Prepare函数的调用次数 g_testAtforkPrepare++; } +// Parent函数，在fork之后在父进程中调用 static void Parent(void) { int err = pthread_mutex_lock(&g_mux); @@ -90,79 +108,56 @@ static void Parent(void) g_testAtforkParent++; } +// 测试pthread_atfork的函数 static void *PthreadAtforkTest(void *arg) { int err, ret; int pid; int status = 0; - struct timespec ts = { 1, 0 }; + struct timespec ts = { 1, 0 }; // 设置休眠时间为1秒 pthread_t tid; + // 初始化测试变量 g_testAtforkCount = 0; g_testAtforkPrepare = 0; g_testAtforkParent = 0; + // 设置fork时的回调函数 err = pthread_atfork(Prepare, Parent, NULL); ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); + // 增加fork调用次数 g_testAtforkCount++; + // 创建线程Doit err = pthread_create(&tid, NULL, Doit, NULL); ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); + // 休眠1秒 nanosleep(&ts, NULL); + // 执行fork pid = fork(); ICUNIT_GOTO_EQUAL(g_testAtforkPrepare, 1, g_testAtforkPrepare, EXIT); if (pid == 0) { + // 子进程中执行Doit1 Doit1(NULL); - exit(10); // 10, set exit status. + // 设置退出状态 + exit(10); // 设置退出状态为10 } - ICUNIT_GOTO_WITHIN_EQUAL(pid, 0, 100000, pid, EXIT_WAIT); // 100000, The pid will never exceed 100000. + // 父进程等待子进程结束 + ICUNIT_GOTO_WITHIN_EQUAL(pid, 0, 100000, pid, EXIT_WAIT); // 确保pid不会超过100000 ICUNIT_GOTO_EQUAL(g_testAtforkParent, 1, g_testAtforkParent, EXIT_WAIT); + // 等待线程Doit结束 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); - ICUNIT_GOTO_EQUAL(status, 10, status, EXIT); // 10, get exit status. + ICUNIT_GOTO_EQUAL(status, 10, status, EXIT); // 获取子进程的退出状态 EXIT: return NULL; -EXIT_WAIT: - (void)waitpid(pid, 0, 0); - return NULL; -} - -static int Testcase(void) -{ - int ret; - pthread_t newPthread; - int curThreadPri, curThreadPolicy; - pthread_attr_t a = { 0 }; - struct sched_param param = { 0 }; - - ret = pthread_getschedparam(pthread_self(), &curThreadPolicy, ¶m); - 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; // 2, adjust the priority. - pthread_attr_setschedparam(&a, ¶m); - 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 ItTestPthreadAtfork002(void) -{ - TEST_ADD_CASE("IT_PTHREAD_ATFORK_002", Testcase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION); -} +EXIT \ No newline at end of file diff --git a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_001.cpp b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_001.cpp index ed5debc..affc4c4 100644 --- a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_001.cpp +++ b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_001.cpp @@ -1,3 +1,4 @@ +// 版权声明 /* * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved. * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved. @@ -28,27 +29,33 @@ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "it_pthread_test.h" +#include "it_pthread_test.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; // 全局条件变量 +// 线程函数PthreadF01 static void *PthreadF01(void *t) { - int rc; + int rc; // 用于存储函数返回值 + // 加锁 rc = pthread_mutex_lock(&g_pthreadMuxTest1); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); + // 增加测试计数器 g_testCount++; - LosTaskDelay(100); - ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT); // 2, here assert the result. - g_testCount++; + LosTaskDelay(100); // 延迟100ms + ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT); // 断言测试计数器值为2 + + g_testCount++; // 增加测试计数器 + // 等待条件变量 rc = pthread_cond_wait(&g_pthdCondTest1, &g_pthreadMuxTest1); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); - ICUNIT_GOTO_EQUAL(g_testCount, 5, g_testCount, EXIT); // 5, here assert the result. + ICUNIT_GOTO_EQUAL(g_testCount, 5, g_testCount, EXIT); // 断言测试计数器值为5 rc = pthread_mutex_unlock(&g_pthreadMuxTest1); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); @@ -56,6 +63,7 @@ EXIT: return NULL; } +// 线程函数PthreadF02 static void *PthreadF02(void *t) { int i; @@ -66,50 +74,56 @@ static void *PthreadF02(void *t) rc = pthread_mutex_lock(&g_pthreadMuxTest1); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); - ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT); // 3, here assert the result. + ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT); // 断言测试计数器值为3 g_testCount++; - rc = pthread_cond_signal(&g_pthdCondTest1); + rc = pthread_cond_signal(&g_pthdCondTest1); // 发送条件变量信号 ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); - ICUNIT_GOTO_EQUAL(g_testCount, 4, g_testCount, EXIT); // 4, here assert the result. + ICUNIT_GOTO_EQUAL(g_testCount, 4, g_testCount, EXIT); // 断言测试计数器值为4 g_testCount++; rc = pthread_mutex_unlock(&g_pthreadMuxTest1); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); - LosTaskDelay(2); // 2, delay for Timing control. + LosTaskDelay(2); // 延迟2ms，用于时间控制 EXIT: - pthread_exit(NULL); + pthread_exit(NULL); // 退出线程 + return NULL; } +// 测试用例函数 static unsigned int TestCase(void) { int i; long t1 = 1; long t2 = 2; int rc; - pthread_t threads[3]; // 3, need 3 pthread for test. + pthread_t threads[3]; // 创建3个线程用于测试 pthread_attr_t attr; const int loopNum = 2; - g_testCount = 0; - pthread_mutex_init(&g_pthreadMuxTest1, NULL); - pthread_cond_init(&g_pthdCondTest1, NULL); + g_testCount = 0; // 初始化测试计数器 + pthread_mutex_init(&g_pthreadMuxTest1, NULL); // 初始化互斥锁 + pthread_cond_init(&g_pthdCondTest1, NULL); // 初始化条件变量 + // 创建线程 rc = pthread_create(&threads[0], NULL, PthreadF01, (void *)t1); ICUNIT_ASSERT_EQUAL(rc, 0, rc); rc = pthread_create(&threads[1], NULL, PthreadF02, (void *)t2); ICUNIT_ASSERT_EQUAL(rc, 0, rc); + // 等待线程结束 for (i = 0; i < loopNum; i++) { rc = pthread_join(threads[i], NULL); ICUNIT_ASSERT_EQUAL(rc, 0, rc); } + // 销毁线程属性对象 rc = pthread_attr_destroy(&attr); ICUNIT_ASSERT_EQUAL(rc, 0, rc); + // 销毁互斥锁和条件变量 rc = pthread_mutex_destroy(&g_pthreadMuxTest1); ICUNIT_ASSERT_EQUAL(rc, 0, rc); rc = pthread_cond_destroy(&g_pthdCondTest1); @@ -118,7 +132,8 @@ 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); -} +} \ No newline at end of file diff --git a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_002.cpp b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_002.cpp index 70a2f02..e656537 100644 --- a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_002.cpp +++ b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_002.cpp @@ -1,3 +1,4 @@ +// 版权声明 /* * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved. * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved. @@ -28,83 +29,102 @@ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "it_pthread_test.h" +#include "it_pthread_test.h" // 包含测试框架头文件 -static pthread_mutex_t g_pthreadMuxTest1; -static pthread_cond_t g_pthrdCondTest1; -static unsigned int g_pthreadExit = 0; +// 声明全局变量 +static pthread_mutex_t g_pthreadMuxTest1; // 全局互斥锁 +static pthread_cond_t g_pthrdCondTest1; // 全局条件变量 +static unsigned int g_pthreadExit = 0; // 用于控制线程退出的全局标志 +// 线程函数PthreadF01 static void *PthreadF01(void *t) { - int rc; - unsigned int count = 0; - const int testLoop = 2000; + int rc; // 用于存储函数返回值 + unsigned int count = 0; // 计数器 + const int testLoop = 2000; // 循环次数 + + // 循环2000次 while (count < testLoop) { + // 加锁 rc = pthread_mutex_lock(&g_pthreadMuxTest1); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); + // 等待条件变量 rc = pthread_cond_wait(&g_pthrdCondTest1, &g_pthreadMuxTest1); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); + // 解锁 rc = pthread_mutex_unlock(&g_pthreadMuxTest1); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); count++; } + // 设置退出标志 g_pthreadExit = 1; EXIT: return NULL; } +// 线程函数PthreadF02 static void *PthreadF02(void *t) { int i; int rc; + // 循环直到PthreadF01线程设置退出标志 while (g_pthreadExit != 1) { + // 加锁 rc = pthread_mutex_lock(&g_pthreadMuxTest1); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); + // 发送条件变量信号 rc = pthread_cond_signal(&g_pthrdCondTest1); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); + // 解锁 rc = pthread_mutex_unlock(&g_pthreadMuxTest1); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); } EXIT: - pthread_exit(NULL); + pthread_exit(NULL); // 退出线程 + return NULL; } +// 测试用例函数 static unsigned int TestCase(void) { int i; long t1 = 1; long t2 = 2; int rc; - pthread_t threads[3]; + pthread_t threads[3]; // 创建3个线程用于测试 pthread_attr_t attr; const int loopNum = 2; - g_pthreadExit = 0; - g_testCount = 0; - pthread_mutex_init(&g_pthreadMuxTest1, NULL); - pthread_cond_init(&g_pthrdCondTest1, NULL); + g_pthreadExit = 0; // 初始化退出标志 + g_testCount = 0; // 初始化测试计数器 + pthread_mutex_init(&g_pthreadMuxTest1, NULL); // 初始化互斥锁 + pthread_cond_init(&g_pthrdCondTest1, NULL); // 初始化条件变量 + // 创建线程 rc = pthread_create(&threads[0], NULL, PthreadF01, (void *)t1); ICUNIT_ASSERT_EQUAL(rc, 0, rc); rc = pthread_create(&threads[1], NULL, PthreadF02, (void *)t2); ICUNIT_ASSERT_EQUAL(rc, 0, rc); + // 等待线程结束 for (i = 0; i < loopNum; i++) { rc = pthread_join(threads[i], NULL); ICUNIT_ASSERT_EQUAL(rc, 0, rc); } + // 销毁线程属性对象 rc = pthread_attr_destroy(&attr); ICUNIT_ASSERT_EQUAL(rc, 0, rc); + // 销毁互斥锁和条件变量 rc = pthread_mutex_destroy(&g_pthreadMuxTest1); ICUNIT_ASSERT_EQUAL(rc, 0, rc); rc = pthread_cond_destroy(&g_pthrdCondTest1); @@ -113,7 +133,8 @@ static unsigned int TestCase(void) return 0; } +// 测试函数注册 void ItTestPthreadCond002(void) { TEST_ADD_CASE("IT_POSIX_PTHREAD_COND_002", TestCase, TEST_POSIX, TEST_PTHREAD, TEST_LEVEL2, TEST_FUNCTION); -} +} \ No newline at end of file diff --git a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_003.cpp b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_003.cpp index 736d7d5..a8fbe2e 100644 --- a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_003.cpp +++ b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_003.cpp @@ -1,3 +1,4 @@ +// 版权声明 /* * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved. * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved. @@ -28,124 +29,153 @@ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "it_pthread_test.h" +#include "it_pthread_test.h" // 包含测试框架头文件 -static pthread_cond_t g_pthread_cond; -static pthread_mutex_t g_pthread_mutex; -#define TEST_THREAD_COUNT 5 +// 声明全局变量 +static pthread_cond_t g_pthread_cond; // 全局条件变量 +static pthread_mutex_t g_pthread_mutex; // 全局互斥锁 +#define TEST_THREAD_COUNT 5 // 测试线程数量 + +// 线程函数pthread_cond_func001 static void *pthread_cond_func001(void *arg) { - int ret; - struct timespec ts; + int ret; // 用于存储函数返回值 + struct timespec ts; // 时间结构体 - g_testCount++; + g_testCount++; // 增加测试计数器 + // 加锁 ret = pthread_mutex_lock(&g_pthread_mutex); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); + // 获取当前时间并设置超时时间为1分钟 clock_gettime(CLOCK_REALTIME, &ts); ts.tv_sec += 60; /* 60: wait 1 minute */ + // 等待条件变量，超时时间为1分钟 ret = pthread_cond_timedwait(&g_pthread_cond, &g_pthread_mutex, &ts); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); + // 解锁 ret = pthread_mutex_unlock(&g_pthread_mutex); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); - g_testCount++; + g_testCount++; // 增加测试计数器 EXIT: return NULL; } +// 线程函数pthread_f06 static VOID *pthread_f06(void *argument) { - int policy; - int ret; - int i; - pthread_attr_t attr; - struct sched_param schedParam = { 0 }; - pthread_t thread[TEST_THREAD_COUNT]; + int policy; // 调度策略 + int ret; // 用于存储函数返回值 + int i; // 循环变量 + pthread_attr_t attr; // 线程属性 + struct sched_param schedParam = { 0 }; // 调度参数 + pthread_t thread[TEST_THREAD_COUNT]; // 线程数组 - g_testCount = 0; + g_testCount = 0; // 初始化测试计数器 + // 初始化线程属性 ret = pthread_attr_init(&attr); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); + // 获取当前线程的调度参数 ret = pthread_getschedparam(pthread_self(), &policy, &schedParam); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); + // 设置新线程的优先级 schedParam.sched_priority -= 1; ret = pthread_attr_setschedparam(&attr, &schedParam); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); + // 设置线程的调度策略 ret = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); + // 创建测试线程 for (i = 0; i < TEST_THREAD_COUNT; i++) { ret = pthread_create(&thread[i], &attr, pthread_cond_func001, NULL); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); } - sleep(1); + sleep(1); // 等待1秒 + // 检查测试计数器是否为5（5个线程） ICUNIT_GOTO_EQUAL(g_testCount, 5, g_testCount, EXIT); /* 5: Five threads */ + // 加锁 ret = pthread_mutex_lock(&g_pthread_mutex); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); + // 发送条件变量广播信号 ret = pthread_cond_broadcast(&g_pthread_cond); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); + // 解锁 ret = pthread_mutex_unlock(&g_pthread_mutex); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); + // 等待测试线程结束 for (i = 0; i < TEST_THREAD_COUNT; i++) { ret = pthread_join(thread[i], NULL); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); } + // 检查测试计数器是否为10（每个线程两次） ICUNIT_GOTO_EQUAL(g_testCount, 10, g_testCount, EXIT); /* 10: Twice per thread */ EXIT: return NULL; } +// 测试用例函数 static int TestCase(void) { - int policy; - pthread_attr_t attr; - pthread_t newTh; - struct sched_param schedParam = { 0 }; - int ret; + int policy; // 调度策略 + pthread_attr_t attr; // 线程属性 + pthread_t newTh; // 新线程 + struct sched_param schedParam = { 0 }; // 调度参数 + int ret; // 用于存储函数返回值 + // 初始化互斥锁 ret = pthread_mutex_init(&g_pthread_mutex, NULL); ICUNIT_ASSERT_EQUAL(ret, 0, ret); + // 初始化条件变量 ret = pthread_cond_init(&g_pthread_cond, NULL); ICUNIT_ASSERT_EQUAL(ret, 0, ret); + // 初始化线程属性 ret = pthread_attr_init(&attr); ICUNIT_ASSERT_EQUAL(ret, 0, ret); + // 获取当前线程的调度参数 ret = pthread_getschedparam(pthread_self(), &policy, &schedParam); ICUNIT_ASSERT_EQUAL(ret, 0, ret); + // 设置新线程的优先级 schedParam.sched_priority -= 1; ret = pthread_attr_setschedparam(&attr, &schedParam); ICUNIT_ASSERT_EQUAL(ret, 0, ret); + // 设置线程的调度策略 ret = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); ICUNIT_ASSERT_EQUAL(ret, 0, ret); + // 创建新线程 ret = pthread_create(&newTh, &attr, pthread_f06, NULL); ICUNIT_ASSERT_EQUAL(ret, 0, ret); + // 等待新线程结束 ret = pthread_join(newTh, NULL); ICUNIT_ASSERT_EQUAL(ret, 0, ret); return 0; } +// 测试函数注册 void ItTestPthreadCond003(void) { TEST_ADD_CASE("IT_POSIX_PTHREAD_COND_003", TestCase, TEST_POSIX, TEST_PTHREAD, TEST_LEVEL2, TEST_FUNCTION); -} +} \ No newline at end of file diff --git a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_004.cpp b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_004.cpp index 6548031..608584e 100644 --- a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_004.cpp +++ b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_cond_test_004.cpp @@ -1,3 +1,4 @@ +// 版权声明 /* * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved. * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved. @@ -28,116 +29,142 @@ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "it_pthread_test.h" -static pthread_cond_t g_pthread_cond; -static pthread_mutex_t g_pthread_mutex; -#define TEST_THREAD_COUNT 5 +#include "it_pthread_test.h" // 包含测试框架头文件 +// 声明全局变量 +static pthread_cond_t g_pthread_cond; // 全局条件变量 +static pthread_mutex_t g_pthread_mutex; // 全局互斥锁 +#define TEST_THREAD_COUNT 5 // 测试线程数量 + +// 线程函数pthread_cond_func002 static void *pthread_cond_func002(void *arg) { - int ret; - struct timespec ts; + int ret; // 用于存储函数返回值 + struct timespec ts; // 时间结构体 - g_testCount++; + g_testCount++; // 增加测试计数器 + // 加锁 ret = pthread_mutex_lock(&g_pthread_mutex); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); + // 获取当前时间并设置超时时间为2秒 clock_gettime(CLOCK_REALTIME, &ts); ts.tv_sec += 2; /* 2: wait 2 seconds */ + // 等待条件变量，超时时间为2秒 ret = pthread_cond_timedwait(&g_pthread_cond, &g_pthread_mutex, &ts); - ICUNIT_GOTO_EQUAL(ret, ETIMEDOUT, ret, EXIT); + ICUNIT_GOTO_EQUAL(ret, ETIMEDOUT, ret, EXIT); // 期望超时返回ETIMEDOUT + // 解锁 ret = pthread_mutex_unlock(&g_pthread_mutex); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); - g_testCount++; + g_testCount++; // 增加测试计数器 EXIT: return NULL; } +// 线程函数pthread_f07 static VOID *pthread_f07(void *argument) { - int policy; - int ret; - int i; - pthread_attr_t attr; - struct sched_param schedParam = { 0 }; - pthread_t thread[TEST_THREAD_COUNT]; + int policy; // 调度策略 + int ret; // 用于存储函数返回值 + int i; // 循环变量 + pthread_attr_t attr; // 线程属性 + struct sched_param schedParam = { 0 }; // 调度参数 + pthread_t thread[TEST_THREAD_COUNT]; // 线程数组 - g_testCount = 0; + g_testCount = 0; // 初始化测试计数器 + // 初始化线程属性 ret = pthread_attr_init(&attr); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); + // 获取当前线程的调度参数 ret = pthread_getschedparam(pthread_self(), &policy, &schedParam); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); + // 设置新线程的优先级 schedParam.sched_priority -= 1; ret = pthread_attr_setschedparam(&attr, &schedParam); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); + // 设置线程的调度策略 ret = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); + // 创建测试线程 for (i = 0; i < TEST_THREAD_COUNT; i++) { ret = pthread_create(&thread[i], &attr, pthread_cond_func002, NULL); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); } - sleep(1); + sleep(1); // 等待1秒，确保所有线程都有机会执行并超时 + // 检查测试计数器是否为5（5个线程） ICUNIT_GOTO_EQUAL(g_testCount, 5, g_testCount, EXIT); /* 5: Five threads */ + // 等待测试线程结束 for (i = 0; i < TEST_THREAD_COUNT; i++) { ret = pthread_join(thread[i], NULL); ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); } + // 检查测试计数器是否为10（每个线程两次） ICUNIT_GOTO_EQUAL(g_testCount, 10, g_testCount, EXIT); /* 10: Twice per thread */ EXIT: return NULL; } +// 测试用例函数 static int TestCase(void) { - int policy; - pthread_attr_t attr; - pthread_t newTh; - struct sched_param schedParam = { 0 }; - int ret; + int policy; // 调度策略 + pthread_attr_t attr; // 线程属性 + pthread_t newTh; // 新线程 + struct sched_param schedParam = { 0 }; // 调度参数 + int ret; // 用于存储函数返回值 + // 初始化互斥锁 ret = pthread_mutex_init(&g_pthread_mutex, NULL); ICUNIT_ASSERT_EQUAL(ret, 0, ret); + // 初始化条件变量 ret = pthread_cond_init(&g_pthread_cond, NULL); ICUNIT_ASSERT_EQUAL(ret, 0, ret); + // 初始化线程属性 ret = pthread_attr_init(&attr); ICUNIT_ASSERT_EQUAL(ret, 0, ret); + // 获取当前线程的调度参数 ret = pthread_getschedparam(pthread_self(), &policy, &schedParam); ICUNIT_ASSERT_EQUAL(ret, 0, ret); + // 设置新线程的优先级 schedParam.sched_priority -= 1; ret = pthread_attr_setschedparam(&attr, &schedParam); ICUNIT_ASSERT_EQUAL(ret, 0, ret); + // 设置线程的调度策略 ret = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); ICUNIT_ASSERT_EQUAL(ret, 0, ret); + // 创建新线程 ret = pthread_create(&newTh, &attr, pthread_f07, NULL); ICUNIT_ASSERT_EQUAL(ret, 0, ret); + // 等待新线程结束 ret = pthread_join(newTh, NULL); ICUNIT_ASSERT_EQUAL(ret, 0, ret); return 0; } +// 测试函数注册 void ItTestPthreadCond004(void) { TEST_ADD_CASE("IT_POSIX_PTHREAD_COND_004", TestCase, TEST_POSIX, TEST_PTHREAD, TEST_LEVEL2, TEST_FUNCTION); -} +} \ No newline at end of file diff --git a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_once_test_001.cpp b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_once_test_001.cpp index a779ba3..231c7ed 100644 --- a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_once_test_001.cpp +++ b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_once_test_001.cpp @@ -1,3 +1,4 @@ +// 版权声明 /* * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved. * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved. @@ -28,83 +29,94 @@ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "it_pthread_test.h" +#include "it_pthread_test.h" // 包含测试框架头文件 -static int g_number = 0; -static int g_okStatus = 777; // 777, a special number indicate the status is ok. -static pthread_once_t g_onceCtrl = PTHREAD_ONCE_INIT; +// 定义全局变量 +static int g_number = 0; // 用于计数的全局变量 +static int g_okStatus = 777; // 777, 一个特殊的数字，表示状态正常 +static pthread_once_t g_onceCtrl = PTHREAD_ONCE_INIT; // 用于控制只执行一次的初始化 +// 初始化例程，只执行一次的函数 static void InitRoutine(void) { - g_number++; + g_number++; // 每次调用时增加计数器 } +// 线程函数Threadfunc static void *Threadfunc(void *parm) { - int err; - err = pthread_once(&g_onceCtrl, InitRoutine); - ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); - return reinterpret_cast(g_okStatus); + int err; // 用于存储函数返回值 + err = pthread_once(&g_onceCtrl, InitRoutine); // 确保InitRoutine只执行一次 + ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 断言返回值为0 + return reinterpret_cast(g_okStatus); // 返回状态值 EXIT: - return NULL; + return NULL; // 出错时返回NULL } +// 线程函数ThreadFuncTest static void *ThreadFuncTest(void *arg) { - pthread_t thread[3]; - int rc = 0; - int i = 3; - void *status; - const int threadsNum = 3; + pthread_t thread[3]; // 线程数组 + int rc = 0; // 返回码 + int i = 3; // 循环变量 + void *status; // 线程返回状态 + const int threadsNum = 3; // 线程数量 - g_number = 0; + g_number = 0; // 初始化计数器 + // 创建3个线程 for (i = 0; i < threadsNum; ++i) { rc = pthread_create(&thread[i], NULL, Threadfunc, NULL); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); } + // 等待3个线程结束，并检查返回状态 for (i = 0; i < threadsNum; ++i) { rc = pthread_join(thread[i], &status); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); ICUNIT_GOTO_EQUAL((unsigned int)status, (unsigned int)g_okStatus, status, EXIT); } + // 断言InitRoutine只执行了一次 ICUNIT_GOTO_EQUAL(g_number, 1, g_number, EXIT); EXIT: - return NULL; + return NULL; // 出错时返回NULL } +// 测试用例函数 static int Testcase(void) { - int ret; - pthread_t newPthread; - int curThreadPri, curThreadPolicy; - pthread_attr_t a = { 0 }; - struct sched_param param = { 0 }; + int ret; // 返回码 + pthread_t newPthread; // 新线程 + int curThreadPri, curThreadPolicy; // 当前线程的优先级和策略 + pthread_attr_t a = { 0 }; // 线程属性 + struct sched_param param = { 0 }; // 调度参数 - g_onceCtrl = PTHREAD_ONCE_INIT; + g_onceCtrl = PTHREAD_ONCE_INIT; // 重置控制变量 + // 获取当前线程的调度参数 ret = pthread_getschedparam(pthread_self(), &curThreadPolicy, ¶m); ICUNIT_ASSERT_EQUAL(ret, 0, -ret); - curThreadPri = param.sched_priority; + curThreadPri = param.sched_priority; // 获取当前优先级 + // 初始化线程属性 ret = pthread_attr_init(&a); - pthread_attr_setinheritsched(&a, PTHREAD_EXPLICIT_SCHED); - param.sched_priority = curThreadPri + 2; // 2, adjust the priority. - pthread_attr_setschedparam(&a, ¶m); - ret = pthread_create(&newPthread, &a, ThreadFuncTest, 0); + pthread_attr_setinheritsched(&a, PTHREAD_EXPLICIT_SCHED); // 设置继承调度策略 + param.sched_priority = curThreadPri + 2; // 调整优先级 + pthread_attr_setschedparam(&a, ¶m); // 设置调度参数 + ret = pthread_create(&newPthread, &a, ThreadFuncTest, 0); // 创建新线程 ICUNIT_ASSERT_EQUAL(ret, 0, ret); - ret = pthread_join(newPthread, NULL); + ret = pthread_join(newPthread, NULL); // 等待新线程结束 ICUNIT_ASSERT_EQUAL(ret, 0, ret); - return 0; + return 0; // 返回成功 } +// 测试函数注册 void ItTestPthreadOnce001(void) { TEST_ADD_CASE("IT_PTHREAD_ONCE_001", Testcase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION); -} +} \ No newline at end of file