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. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "it_pthread_test.h" #include "it_pthread_test.h"
// 全局变量 // 全局变量
static volatile int g_count = 0; // 计数器，控制线程的执行 static volatile int g_count = 0; // 计数器，控制线程的执行
static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER; // 互斥锁，用于同步 static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER; // 互斥锁，用于同步
static int g_testAtforkCount = 0; // 测试计数器，用于检查不同阶段 static int g_testAtforkCount = 0; // 测试计数器，用于检查不同阶段
static int g_testAtforkPrepare = 0; // 用于检查fork前的准备阶段 static int g_testAtforkPrepare = 0; // 用于检查fork前的准备阶段
static int g_testAtforkParent = 0; // 用于标记父进程执行的步骤 static int g_testAtforkParent = 0; // 用于标记父进程执行的步骤
static int g_testAtforkChild = 0; // 用于标记子进程执行的步骤 static int g_testAtforkChild = 0; // 用于标记子进程执行的步骤
static const int SLEEP_TIME = 2; // 睡眠时间，单位秒 static const int SLEEP_TIME = 2; // 睡眠时间，单位秒
// 准备函数，fork之前执行 // 准备函数，fork之前执行
static void Prepare() static void Prepare()
{ {
int err; int err;
ICUNIT_ASSERT_EQUAL_VOID(g_testAtforkCount, 1, g_testAtforkCount); // 确保g_testAtforkCount为1 ICUNIT_ASSERT_EQUAL_VOID(g_testAtforkCount, 1, g_testAtforkCount); // 确保g_testAtforkCount为1
err = pthread_mutex_lock(&g_lock); // 加锁 err = pthread_mutex_lock(&g_lock); // 加锁
ICUNIT_ASSERT_EQUAL_VOID(err, 0, err); // 确保加锁成功 ICUNIT_ASSERT_EQUAL_VOID(err, 0, err); // 确保加锁成功
g_testAtforkPrepare++; // 标记准备阶段已执行 g_testAtforkPrepare++; // 标记准备阶段已执行
} }
// 父进程执行的函数 // 父进程执行的函数
static void Parent() static void Parent()
{ {
int err; int err;
ICUNIT_ASSERT_EQUAL_VOID(g_testAtforkCount, 1, g_testAtforkCount); // 确保g_testAtforkCount为1 ICUNIT_ASSERT_EQUAL_VOID(g_testAtforkCount, 1, g_testAtforkCount); // 确保g_testAtforkCount为1
err = pthread_mutex_unlock(&g_lock); // 解锁 err = pthread_mutex_unlock(&g_lock); // 解锁
ICUNIT_ASSERT_EQUAL_VOID(err, 0, err); // 确保解锁成功 ICUNIT_ASSERT_EQUAL_VOID(err, 0, err); // 确保解锁成功
g_testAtforkParent++; // 标记父进程阶段已执行 g_testAtforkParent++; // 标记父进程阶段已执行
} }
// 子进程执行的函数 // 子进程执行的函数
static void child() static void child()
{ {
int err; int err;
ICUNIT_ASSERT_EQUAL_VOID(g_testAtforkCount, 1, g_testAtforkCount); // 确保g_testAtforkCount为1 ICUNIT_ASSERT_EQUAL_VOID(g_testAtforkCount, 1, g_testAtforkCount); // 确保g_testAtforkCount为1
err = pthread_mutex_unlock(&g_lock); // 解锁 err = pthread_mutex_unlock(&g_lock); // 解锁
ICUNIT_ASSERT_EQUAL_VOID(err, 0, err); // 确保解锁成功 ICUNIT_ASSERT_EQUAL_VOID(err, 0, err); // 确保解锁成功
g_testAtforkChild++; // 标记子进程阶段已执行 g_testAtforkChild++; // 标记子进程阶段已执行
} }
// 线程执行的函数 // 线程执行的函数
static void *ThreadProc(void *arg) static void *ThreadProc(void *arg)
{ {
int err; int err;
// 当g_count小于5时，线程继续执行 // 当g_count小于5时，线程继续执行
while (g_count < 5) { // 5, 等待直到g_count == 5 while (g_count < 5) { // 5, 等待直到g_count == 5
err = pthread_mutex_lock(&g_lock); // 加锁 err = pthread_mutex_lock(&g_lock); // 加锁
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保加锁成功 ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保加锁成功
g_count++; // 增加计数 g_count++; // 增加计数
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
err = pthread_mutex_unlock(&g_lock); // 解锁 err = pthread_mutex_unlock(&g_lock); // 解锁
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保解锁成功 ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保解锁成功
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
} }
EXIT: EXIT:
return NULL; return NULL;
} }
// 测试pthread_atfork的函数 // 测试pthread_atfork的函数
static void *PthreadAtforkTest(void *arg) static void *PthreadAtforkTest(void *arg)
{ {
int err; int err;
@ -96,63 +96,63 @@ static void *PthreadAtforkTest(void *arg)
pthread_t tid; pthread_t tid;
int status = 0; int status = 0;
// 初始化全局变量 // 初始化全局变量
g_count = 0; g_count = 0;
g_testAtforkCount = 0; g_testAtforkCount = 0;
g_testAtforkPrepare = 0; g_testAtforkPrepare = 0;
g_testAtforkParent = 0; g_testAtforkParent = 0;
g_testAtforkChild = 0; g_testAtforkChild = 0;
// 创建新线程 // 创建新线程
err = pthread_create(&tid, NULL, ThreadProc, NULL); err = pthread_create(&tid, NULL, ThreadProc, NULL);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保线程创建成功 ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保线程创建成功
err = pthread_atfork(Prepare, Parent, child); // 注册fork前后要执行的函数 err = pthread_atfork(Prepare, Parent, child); // 注册fork前后要执行的函数
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保注册成功 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(); pid = fork();
ICUNIT_GOTO_WITHIN_EQUAL(pid, 0, 100000, pid, EXIT); // 确保pid合理，子进程的pid不会超过100000 ICUNIT_GOTO_WITHIN_EQUAL(pid, 0, 100000, pid, EXIT); // 确保pid合理，子进程的pid不会超过100000
ICUNIT_GOTO_EQUAL(g_testAtforkPrepare, 1, g_testAtforkPrepare, EXIT); // 确保准备阶段已执行 ICUNIT_GOTO_EQUAL(g_testAtforkPrepare, 1, g_testAtforkPrepare, EXIT); // 确保准备阶段已执行
// 子进程执行的代码 // 子进程执行的代码
if (pid == 0) { if (pid == 0) {
ICUNIT_GOTO_EQUAL(g_testAtforkChild, 1, g_testAtforkChild, EXIT); // 确保子进程阶段已执行 ICUNIT_GOTO_EQUAL(g_testAtforkChild, 1, g_testAtforkChild, EXIT); // 确保子进程阶段已执行
while (g_count < 5) { // 等待直到g_count == 5 while (g_count < 5) { // 等待直到g_count == 5
err = pthread_mutex_lock(&g_lock); // 加锁 err = pthread_mutex_lock(&g_lock); // 加锁
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保加锁成功 ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保加锁成功
g_count++; // 增加计数 g_count++; // 增加计数
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
err = pthread_mutex_unlock(&g_lock); // 解锁 err = pthread_mutex_unlock(&g_lock); // 解锁
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保解锁成功 ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保解锁成功
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
} }
exit(15); // 退出并设置状态为15 exit(15); // 退出并设置状态为15
} }
// 父进程的验证 // 父进程的验证
ICUNIT_GOTO_EQUAL(g_testAtforkParent, 1, g_testAtforkParent, EXIT_WAIT); 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); ICUNIT_GOTO_EQUAL(err, 0, err, EXIT_WAIT);
// 父进程等待子进程结束并验证退出状态 // 父进程等待子进程结束并验证退出状态
err = waitpid(pid, &status, 0); err = waitpid(pid, &status, 0);
status = WEXITSTATUS(status); status = WEXITSTATUS(status);
ICUNIT_GOTO_EQUAL(err, pid, err, EXIT); // 确保waitpid成功 ICUNIT_GOTO_EQUAL(err, pid, err, EXIT); // 确保waitpid成功
ICUNIT_GOTO_EQUAL(status, 15, status, EXIT); // 确保子进程的退出状态为15 ICUNIT_GOTO_EQUAL(status, 15, status, EXIT); // 确保子进程的退出状态为15
EXIT: EXIT:
return NULL; return NULL;
EXIT_WAIT: EXIT_WAIT:
(void)waitpid(pid, &status, 0); // 等待子进程结束 (void)waitpid(pid, &status, 0); // 等待子进程结束
return NULL; return NULL;
} }
// 测试主程序 // 测试主程序
static int Testcase() static int Testcase()
{ {
int ret; int ret;
@ -161,29 +161,30 @@ static int Testcase()
pthread_attr_t a = { 0 }; pthread_attr_t a = { 0 };
struct sched_param param = { 0 }; struct sched_param param = { 0 };
// 获取当前线程的调度参数 // 获取当前线程的调度参数
ret = pthread_getschedparam(pthread_self(), &curThreadPolicy, &param); ret = pthread_getschedparam(pthread_self(), &curThreadPolicy, &param);
ICUNIT_ASSERT_EQUAL(ret, 0, -ret); ICUNIT_ASSERT_EQUAL(ret, 0, -ret);
curThreadPri = param.sched_priority; curThreadPri = param.sched_priority;
// 设置新的线程属性并创建新线程 // 设置新的线程属性并创建新线程
ret = pthread_attr_init(&a); ret = pthread_attr_init(&a);
pthread_attr_setinheritsched(&a, PTHREAD_EXPLICIT_SCHED); pthread_attr_setinheritsched(&a, PTHREAD_EXPLICIT_SCHED);
param.sched_priority = curThreadPri + 2; // 提高线程优先级 param.sched_priority = curThreadPri + 2; // 提高线程优先级
pthread_attr_setschedparam(&a, &param); 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); ICUNIT_ASSERT_EQUAL(ret, 0, ret);
// 等待新线程结束 // 等待新线程结束
ret = pthread_join(newPthread, NULL); ret = pthread_join(newPthread, NULL);
ICUNIT_ASSERT_EQUAL(ret, 0, ret); ICUNIT_ASSERT_EQUAL(ret, 0, ret);
return 0; return 0;
} }
// 测试用例的入口函数 // 测试用例的入口函数
void ItTestPthreadAtfork001(void) void ItTestPthreadAtfork001(void)
{ {
TEST_ADD_CASE("IT_PTHREAD_ATFORK_001", Testcase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION); 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); extern int nanosleep(const struct timespec *req, struct timespec *rem);
// 全局变量 // 全局变量
static pthread_mutex_t g_mux = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t g_mux = PTHREAD_MUTEX_INITIALIZER;
static volatile int g_testAtforkCount = 0; static volatile int g_testAtforkCount = 0;
static int g_testAtforkPrepare = 0; static int g_testAtforkPrepare = 0;
static int g_testAtforkParent = 0; static int g_testAtforkParent = 0;
// 函数原型 // 函数原型
static void *Doit(void *arg); static void *Doit(void *arg);
static void *Doit1(void *arg); static void *Doit1(void *arg);
static void Prepare(void); static void Prepare(void);
@ -53,69 +53,69 @@ static void *PthreadAtforkTest(void *arg);
static int Testcase(void); static int Testcase(void);
void ItTestPthreadAtfork002(void); void ItTestPthreadAtfork002(void);
// Doit 函数（线程 1） // Doit 函数（线程 1）
static void *Doit(void *arg) static void *Doit(void *arg)
{ {
int err; int err;
struct timespec ts = { 2, 0 }; // 睡眠 2 秒 struct timespec ts = { 2, 0 }; // 睡眠 2 秒
// 确保全局变量 g_testAtforkCount 为 1 // 确保全局变量 g_testAtforkCount 为 1
if (g_testAtforkCount != 1) { if (g_testAtforkCount != 1) {
return NULL; return NULL;
} }
// 锁住互斥锁 // 锁住互斥锁
err = pthread_mutex_lock(&g_mux); err = pthread_mutex_lock(&g_mux);
if (err != 0) return NULL; if (err != 0) return NULL;
(void)nanosleep(&ts, NULL); // 睡眠 2 秒 (void)nanosleep(&ts, NULL); // 睡眠 2 秒
err = pthread_mutex_unlock(&g_mux); // 解锁互斥锁 err = pthread_mutex_unlock(&g_mux); // 解锁互斥锁
if (err != 0) return NULL; if (err != 0) return NULL;
return NULL; return NULL;
} }
// Doit1 函数（线程 2 - 子进程） // Doit1 函数（线程 2 - 子进程）
static void *Doit1(void *arg) static void *Doit1(void *arg)
{ {
int err; int err;
struct timespec ts = { 2, 0 }; // 睡眠 2 秒 struct timespec ts = { 2, 0 }; // 睡眠 2 秒
// 确保全局变量 g_testAtforkCount 为 1 // 确保全局变量 g_testAtforkCount 为 1
if (g_testAtforkCount != 1) { if (g_testAtforkCount != 1) {
return NULL; return NULL;
} }
// 锁住互斥锁 // 锁住互斥锁
err = pthread_mutex_lock(&g_mux); err = pthread_mutex_lock(&g_mux);
if (err != 0) return NULL; if (err != 0) return NULL;
(void)nanosleep(&ts, NULL); // 睡眠 2 秒 (void)nanosleep(&ts, NULL); // 睡眠 2 秒
err = pthread_mutex_unlock(&g_mux); // 解锁互斥锁 err = pthread_mutex_unlock(&g_mux); // 解锁互斥锁
if (err != 0) return NULL; if (err != 0) return NULL;
return NULL; return NULL;
} }
// Prepare 函数（在 fork 前调用） // Prepare 函数（在 fork 前调用）
static void Prepare(void) static void Prepare(void)
{ {
int err; int err;
err = pthread_mutex_unlock(&g_mux); // 在 fork 前解锁互斥锁 err = pthread_mutex_unlock(&g_mux); // 在 fork 前解锁互斥锁
if (err != 0) return; if (err != 0) return;
g_testAtforkPrepare++; // 增加 prepare 计数 g_testAtforkPrepare++; // 增加 prepare 计数
} }
// Parent 函数（在 fork 后父进程中调用） // Parent 函数（在 fork 后父进程中调用）
static void Parent(void) static void Parent(void)
{ {
int err = pthread_mutex_lock(&g_mux); // 在父进程中锁住互斥锁 int err = pthread_mutex_lock(&g_mux); // 在父进程中锁住互斥锁
if (err != 0) return; if (err != 0) return;
g_testAtforkParent++; // 增加父进程计数 g_testAtforkParent++; // 增加父进程计数
} }
// PthreadAtforkTest 函数（主测试函数） // PthreadAtforkTest 函数（主测试函数）
static void *PthreadAtforkTest(void *arg) static void *PthreadAtforkTest(void *arg)
{ {
int err, ret; int err, ret;
@ -128,45 +128,45 @@ static void *PthreadAtforkTest(void *arg)
g_testAtforkPrepare = 0; g_testAtforkPrepare = 0;
g_testAtforkParent = 0; g_testAtforkParent = 0;
// 注册 pthread_atfork 的回调函数 // 注册 pthread_atfork 的回调函数
err = pthread_atfork(Prepare, Parent, NULL); err = pthread_atfork(Prepare, Parent, NULL);
if (err != 0) return NULL; if (err != 0) return NULL;
g_testAtforkCount++; // 增加计数用于测试 g_testAtforkCount++; // 增加计数用于测试
// 创建一个线程执行 Doit 函数 // 创建一个线程执行 Doit 函数
err = pthread_create(&tid, NULL, Doit, NULL); err = pthread_create(&tid, NULL, Doit, NULL);
if (err != 0) return NULL; if (err != 0) return NULL;
nanosleep(&ts, NULL); // 睡眠 1 秒 nanosleep(&ts, NULL); // 睡眠 1 秒
pid = fork(); // 创建子进程 pid = fork(); // 创建子进程
// 检查 Prepare 函数是否被调用 // 检查 Prepare 函数是否被调用
if (g_testAtforkPrepare != 1) { if (g_testAtforkPrepare != 1) {
return NULL; return NULL;
} }
if (pid == 0) { if (pid == 0) {
Doit1(NULL); // 在子进程中执行 Doit1 函数 Doit1(NULL); // 在子进程中执行 Doit1 函数
exit(10); // 子进程退出，返回状态 10 exit(10); // 子进程退出，返回状态 10
} }
if (pid <= 0) { if (pid <= 0) {
return NULL; return NULL;
} }
// 检查 Parent 函数是否被调用 // 检查 Parent 函数是否被调用
if (g_testAtforkParent != 1) { if (g_testAtforkParent != 1) {
return NULL; return NULL;
} }
// 等待线程执行完毕 // 等待线程执行完毕
err = pthread_join(tid, NULL); err = pthread_join(tid, NULL);
if (err != 0) return NULL; if (err != 0) return NULL;
// 等待子进程结束 // 等待子进程结束
err = waitpid(pid, &status, 0); err = waitpid(pid, &status, 0);
status = WEXITSTATUS(status); // 获取子进程退出状态 status = WEXITSTATUS(status); // 获取子进程退出状态
if (err != pid || status != 10) { if (err != pid || status != 10) {
return NULL; return NULL;
} }
@ -174,7 +174,7 @@ static void *PthreadAtforkTest(void *arg)
return NULL; return NULL;
} }
// Testcase 函数（初始化线程调度参数并执行测试） // Testcase 函数（初始化线程调度参数并执行测试）
static int Testcase(void) static int Testcase(void)
{ {
int ret; int ret;
@ -183,33 +183,34 @@ static int Testcase(void)
pthread_attr_t a = { 0 }; pthread_attr_t a = { 0 };
struct sched_param param = { 0 }; struct sched_param param = { 0 };
// 获取当前线程的调度参数 // 获取当前线程的调度参数
ret = pthread_getschedparam(pthread_self(), &curThreadPolicy, &param); ret = pthread_getschedparam(pthread_self(), &curThreadPolicy, &param);
if (ret != 0) return ret; if (ret != 0) return ret;
curThreadPri = param.sched_priority; curThreadPri = param.sched_priority;
// 初始化线程属性 // 初始化线程属性
ret = pthread_attr_init(&a); ret = pthread_attr_init(&a);
if (ret != 0) return ret; if (ret != 0) return ret;
pthread_attr_setinheritsched(&a, PTHREAD_EXPLICIT_SCHED); pthread_attr_setinheritsched(&a, PTHREAD_EXPLICIT_SCHED);
param.sched_priority = curThreadPri + 2; // 设置线程优先级为当前优先级 + 2 param.sched_priority = curThreadPri + 2; // 设置线程优先级为当前优先级 + 2
pthread_attr_setschedparam(&a, &param); pthread_attr_setschedparam(&a, &param);
// 创建新线程执行 PthreadAtforkTest 函数 // 创建新线程执行 PthreadAtforkTest 函数
ret = pthread_create(&newPthread, &a, PthreadAtforkTest, 0); ret = pthread_create(&newPthread, &a, PthreadAtforkTest, 0);
if (ret != 0) return ret; if (ret != 0) return ret;
// 等待新线程执行完毕 // 等待新线程执行完毕
ret = pthread_join(newPthread, NULL); ret = pthread_join(newPthread, NULL);
if (ret != 0) return ret; if (ret != 0) return ret;
return 0; return 0;
} }
// ItTestPthreadAtfork002 函数（测试用例入口） // ItTestPthreadAtfork002 函数（测试用例入口）
void ItTestPthreadAtfork002(void) void ItTestPthreadAtfork002(void)
{ {
TEST_ADD_CASE("IT_PTHREAD_ATFORK_002", Testcase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION); 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. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <pthread.h> #include <pthread.h>
#include "ICUnit.h" // 假设你有这个头文件来处理测试相关的宏 #include "ICUnit.h" // 假设你有这个头文件来处理测试相关的宏
static pthread_mutex_t g_pthreadMuxTest1; // 定义互斥锁 static pthread_mutex_t g_pthreadMuxTest1; // 定义互斥锁
static pthread_cond_t g_pthdCondTest1; // 定义条件变量 static pthread_cond_t g_pthdCondTest1; // 定义条件变量
// 线程1的函数 // 线程1的函数
static void *PthreadF01(void *t) static void *PthreadF01(void *t)
{ {
int rc; int rc;
// 锁住互斥锁 // 锁住互斥锁
rc = pthread_mutex_lock(&g_pthreadMuxTest1); rc = pthread_mutex_lock(&g_pthreadMuxTest1);
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
g_testCount++; // g_testCount加1 g_testCount++; // g_testCount加1
LosTaskDelay(100); // 延时100ms LosTaskDelay(100); // 延时100ms
ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT); // 断言g_testCount应为2 ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT); // 断言g_testCount应为2
g_testCount++; // g_testCount再加1 g_testCount++; // g_testCount再加1
// 等待条件变量，释放互斥锁 // 等待条件变量，释放互斥锁
rc = pthread_cond_wait(&g_pthdCondTest1, &g_pthreadMuxTest1); rc = pthread_cond_wait(&g_pthdCondTest1, &g_pthreadMuxTest1);
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
ICUNIT_GOTO_EQUAL(g_testCount, 5, g_testCount, EXIT); // 断言g_testCount应为5 ICUNIT_GOTO_EQUAL(g_testCount, 5, g_testCount, EXIT); // 断言g_testCount应为5
rc = pthread_mutex_unlock(&g_pthreadMuxTest1); // 解锁互斥锁 rc = pthread_mutex_unlock(&g_pthreadMuxTest1); // 解锁互斥锁
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
EXIT: EXIT:
return NULL; return NULL;
} }
// 线程2的函数 // 线程2的函数
static void *PthreadF02(void *t) static void *PthreadF02(void *t)
{ {
int rc; int rc;
ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT); // 断言g_testCount应为1 ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT); // 断言g_testCount应为1
g_testCount++; // g_testCount加1 g_testCount++; // g_testCount加1
// 锁住互斥锁 // 锁住互斥锁
rc = pthread_mutex_lock(&g_pthreadMuxTest1); rc = pthread_mutex_lock(&g_pthreadMuxTest1);
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT); // 断言g_testCount应为3 ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT); // 断言g_testCount应为3
g_testCount++; // g_testCount再加1 g_testCount++; // g_testCount再加1
// 发送信号，唤醒线程1 // 发送信号，唤醒线程1
rc = pthread_cond_signal(&g_pthdCondTest1); rc = pthread_cond_signal(&g_pthdCondTest1);
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
ICUNIT_GOTO_EQUAL(g_testCount, 4, g_testCount, EXIT); // 断言g_testCount应为4 ICUNIT_GOTO_EQUAL(g_testCount, 4, g_testCount, EXIT); // 断言g_testCount应为4
g_testCount++; // g_testCount再加1 g_testCount++; // g_testCount再加1
// 解锁互斥锁 // 解锁互斥锁
rc = pthread_mutex_unlock(&g_pthreadMuxTest1); rc = pthread_mutex_unlock(&g_pthreadMuxTest1);
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT);
LosTaskDelay(2); // 延时2ms，控制时序 LosTaskDelay(2); // 延时2ms，控制时序
EXIT: EXIT:
pthread_exit(NULL); pthread_exit(NULL);
} }
// 测试用例 // 测试用例
static unsigned int TestCase(void) static unsigned int TestCase(void)
{ {
int rc; int rc;
pthread_t threads[2]; // 需要2个线程来进行测试 pthread_t threads[2]; // 需要2个线程来进行测试
const int loopNum = 2; // 循环次数 const int loopNum = 2; // 循环次数
g_testCount = 0; g_testCount = 0;
pthread_mutex_init(&g_pthreadMuxTest1, NULL); // 初始化互斥锁 pthread_mutex_init(&g_pthreadMuxTest1, NULL); // 初始化互斥锁
pthread_cond_init(&g_pthdCondTest1, NULL); // 初始化条件变量 pthread_cond_init(&g_pthdCondTest1, NULL); // 初始化条件变量
// 创建线程1 // 创建线程1
rc = pthread_create(&threads[0], NULL, PthreadF01, NULL); rc = pthread_create(&threads[0], NULL, PthreadF01, NULL);
ICUNIT_ASSERT_EQUAL(rc, 0, rc); ICUNIT_ASSERT_EQUAL(rc, 0, rc);
// 创建线程2 // 创建线程2
rc = pthread_create(&threads[1], NULL, PthreadF02, NULL); rc = pthread_create(&threads[1], NULL, PthreadF02, NULL);
ICUNIT_ASSERT_EQUAL(rc, 0, rc); ICUNIT_ASSERT_EQUAL(rc, 0, rc);
// 等待线程结束 // 等待线程结束
for (int i = 0; i < loopNum; i++) { for (int i = 0; i < loopNum; i++) {
rc = pthread_join(threads[i], NULL); rc = pthread_join(threads[i], NULL);
ICUNIT_ASSERT_EQUAL(rc, 0, rc); ICUNIT_ASSERT_EQUAL(rc, 0, rc);
} }
// 销毁线程属性 // 销毁线程属性
rc = pthread_attr_destroy(NULL); rc = pthread_attr_destroy(NULL);
ICUNIT_ASSERT_EQUAL(rc, 0, rc); ICUNIT_ASSERT_EQUAL(rc, 0, rc);
// 销毁互斥锁和条件变量 // 销毁互斥锁和条件变量
rc = pthread_mutex_destroy(&g_pthreadMuxTest1); rc = pthread_mutex_destroy(&g_pthreadMuxTest1);
ICUNIT_ASSERT_EQUAL(rc, 0, rc); ICUNIT_ASSERT_EQUAL(rc, 0, rc);
rc = pthread_cond_destroy(&g_pthdCondTest1); rc = pthread_cond_destroy(&g_pthdCondTest1);
@ -130,8 +130,9 @@ static unsigned int TestCase(void)
return 0; return 0;
} }
// 测试用例入口函数 // 测试用例入口函数
void ItTestPthreadCond001(void) void ItTestPthreadCond001(void)
{ {
TEST_ADD_CASE("IT_POSIX_PTHREAD_COND_001", TestCase, TEST_POSIX, TEST_PTHREAD, TEST_LEVEL2, TEST_FUNCTION); TEST_ADD_CASE("IT_POSIX_PTHREAD_COND_001", TestCase, TEST_POSIX, TEST_PTHREAD, TEST_LEVEL2, TEST_FUNCTION);
} }

Write Preview
Loading…
Cancel
Save