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
熊卓孜 7 months ago
parent 40412da54b dde2f171f7
commit 796b79839f
3 changed files with 209 additions and 135 deletions
Show Stats Download Patch File Download Diff File

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

@ -29,62 +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; 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之前执行
static void Prepare() static void Prepare()
{ {
int err; int err;
ICUNIT_ASSERT_EQUAL_VOID(g_testAtforkCount, 1, g_testAtforkCount); 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); 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); 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;
while (g_count < 5) { // 5, wait until g_count == 5. // 当g_count小于5时，线程继续执行
err = pthread_mutex_lock(&g_lock); while (g_count < 5) { // 5, 等待直到g_count == 5
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); err = pthread_mutex_lock(&g_lock); // 加锁
g_count++; ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保加锁成功
SLEEP_AND_YIELD(SLEEP_TIME); g_count++; // 增加计数
err = pthread_mutex_unlock(&g_lock); SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); err = pthread_mutex_unlock(&g_lock); // 解锁
SLEEP_AND_YIELD(SLEEP_TIME); ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 确保解锁成功
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
} }
EXIT: EXIT:
return NULL; return NULL;
} }
// 测试pthread_atfork的函数
static void *PthreadAtforkTest(void *arg) static void *PthreadAtforkTest(void *arg)
{ {
int err; int err;
@ -92,57 +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); 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); SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
// 创建子进程
pid = fork(); pid = fork();
ICUNIT_GOTO_WITHIN_EQUAL(pid, 0, 100000, pid, EXIT); // 100000, The pid will never exceed 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); // 确保子进程阶段已执行
int status; while (g_count < 5) { // 等待直到g_count == 5
while (g_count < 5) { // 5, wait until 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); 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);
} }
exit(15); // 15, set exit status 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); ICUNIT_GOTO_EQUAL(err, pid, err, EXIT); // 确保waitpid成功
ICUNIT_GOTO_EQUAL(status, 15, status, EXIT); // 15, get exit status. 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;
@ -151,24 +161,28 @@ 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; // 2, adjust the priority. 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);

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

@ -28,68 +28,94 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "it_pthread_test.h" #include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <time.h> #include <time.h>
#include <sched.h>
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 *Doit1(void *arg);
static void Prepare(void);
static void Parent(void);
static void *PthreadAtforkTest(void *arg);
static int Testcase(void);
void ItTestPthreadAtfork002(void);
// Doit 函数（线程 1）
static void *Doit(void *arg) static void *Doit(void *arg)
{ {
int err; int err;
struct timespec ts = { 2, 0 }; // 2, set time 2s. struct timespec ts = { 2, 0 }; // 睡眠 2 秒
ICUNIT_GOTO_EQUAL(g_testAtforkCount, 1, g_testAtforkCount, EXIT); // 确保全局变量 g_testAtforkCount 为 1
if (g_testAtforkCount != 1) {
return NULL;
}
// 锁住互斥锁
err = pthread_mutex_lock(&g_mux); err = pthread_mutex_lock(&g_mux);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); if (err != 0) return NULL;
(void)nanosleep(&ts, NULL); (void)nanosleep(&ts, NULL); // 睡眠 2 秒
err = pthread_mutex_unlock(&g_mux); err = pthread_mutex_unlock(&g_mux); // 解锁互斥锁
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); if (err != 0) return NULL;
EXIT:
return NULL; return NULL;
} }
// Doit1 函数（线程 2 - 子进程）
static void *Doit1(void *arg) static void *Doit1(void *arg)
{ {
int err; int err;
struct timespec ts = { 2, 0 }; // 2, set time 2s. struct timespec ts = { 2, 0 }; // 睡眠 2 秒
ICUNIT_GOTO_EQUAL(g_testAtforkCount, 1, g_testAtforkCount, EXIT); // 确保全局变量 g_testAtforkCount 为 1
if (g_testAtforkCount != 1) {
return NULL;
}
// 锁住互斥锁
err = pthread_mutex_lock(&g_mux); err = pthread_mutex_lock(&g_mux);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); if (err != 0) return NULL;
(void)nanosleep(&ts, NULL); (void)nanosleep(&ts, NULL); // 睡眠 2 秒
err = pthread_mutex_unlock(&g_mux); err = pthread_mutex_unlock(&g_mux); // 解锁互斥锁
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); if (err != 0) return NULL;
EXIT:
return NULL; return NULL;
} }
// Prepare 函数（在 fork 前调用）
static void Prepare(void) static void Prepare(void)
{ {
int err; int err;
err = pthread_mutex_unlock(&g_mux); err = pthread_mutex_unlock(&g_mux); // 在 fork 前解锁互斥锁
ICUNIT_ASSERT_EQUAL_VOID(err, 0, err); if (err != 0) return;
g_testAtforkPrepare++; g_testAtforkPrepare++; // 增加 prepare 计数
} }
// Parent 函数（在 fork 后父进程中调用）
static void Parent(void) static void Parent(void)
{ {
int err = pthread_mutex_lock(&g_mux); int err = pthread_mutex_lock(&g_mux); // 在父进程中锁住互斥锁
ICUNIT_ASSERT_EQUAL_VOID(err, 0, err); if (err != 0) return;
g_testAtforkParent++; g_testAtforkParent++; // 增加父进程计数
} }
// PthreadAtforkTest 函数（主测试函数）
static void *PthreadAtforkTest(void *arg) static void *PthreadAtforkTest(void *arg)
{ {
int err, ret; int err, ret;
@ -102,40 +128,53 @@ static void *PthreadAtforkTest(void *arg)
g_testAtforkPrepare = 0; g_testAtforkPrepare = 0;
g_testAtforkParent = 0; g_testAtforkParent = 0;
// 注册 pthread_atfork 的回调函数
err = pthread_atfork(Prepare, Parent, NULL); err = pthread_atfork(Prepare, Parent, NULL);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); if (err != 0) return NULL;
g_testAtforkCount++;
g_testAtforkCount++; // 增加计数用于测试
// 创建一个线程执行 Doit 函数
err = pthread_create(&tid, NULL, Doit, NULL); err = pthread_create(&tid, NULL, Doit, NULL);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); if (err != 0) return NULL;
nanosleep(&ts, NULL); // 睡眠 1 秒
pid = fork(); // 创建子进程
// 检查 Prepare 函数是否被调用
if (g_testAtforkPrepare != 1) {
return NULL;
}
nanosleep(&ts, NULL);
pid = fork();
ICUNIT_GOTO_EQUAL(g_testAtforkPrepare, 1, g_testAtforkPrepare, EXIT);
if (pid == 0) { if (pid == 0) {
Doit1(NULL); Doit1(NULL); // 在子进程中执行 Doit1 函数
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. if (pid <= 0) {
ICUNIT_GOTO_EQUAL(g_testAtforkParent, 1, g_testAtforkParent, EXIT_WAIT); return NULL;
}
err = pthread_join(tid, NULL); // 检查 Parent 函数是否被调用
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT_WAIT); if (g_testAtforkParent != 1) {
return NULL;
}
// 等待线程执行完毕
err = pthread_join(tid, NULL);
if (err != 0) return NULL;
// 等待子进程结束
err = waitpid(pid, &status, 0); err = waitpid(pid, &status, 0);
status = WEXITSTATUS(status); status = WEXITSTATUS(status); // 获取子进程退出状态
ICUNIT_GOTO_EQUAL(err, pid, err, EXIT); if (err != pid || status != 10) {
ICUNIT_GOTO_EQUAL(status, 10, status, EXIT); // 10, get exit status. return NULL;
}
EXIT:
return NULL;
EXIT_WAIT:
(void)waitpid(pid, 0, 0);
return NULL; return NULL;
} }
// Testcase 函数（初始化线程调度参数并执行测试）
static int Testcase(void) static int Testcase(void)
{ {
int ret; int ret;
@ -144,24 +183,32 @@ 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);
ICUNIT_ASSERT_EQUAL(ret, 0, -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;
pthread_attr_setinheritsched(&a, PTHREAD_EXPLICIT_SCHED); pthread_attr_setinheritsched(&a, PTHREAD_EXPLICIT_SCHED);
param.sched_priority = curThreadPri + 2; // 2, adjust the priority. param.sched_priority = curThreadPri + 2; // 设置线程优先级为当前优先级 + 2
pthread_attr_setschedparam(&a, &param); pthread_attr_setschedparam(&a, &param);
// 创建新线程执行 PthreadAtforkTest 函数
ret = pthread_create(&newPthread, &a, PthreadAtforkTest, 0); ret = pthread_create(&newPthread, &a, PthreadAtforkTest, 0);
ICUNIT_ASSERT_EQUAL(ret, 0, ret); if (ret != 0) return ret;
// 等待新线程执行完毕
ret = pthread_join(newPthread, NULL); ret = pthread_join(newPthread, NULL);
ICUNIT_ASSERT_EQUAL(ret, 0, ret); if (ret != 0) return ret;
return 0; return 0;
} }
// 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);

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

@ -28,88 +28,100 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "it_pthread_test.h" #include <pthread.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的函数
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++; // g_testCount加1
LosTaskDelay(100); LosTaskDelay(100); // 延时100ms
ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT); // 2, here assert the result. ICUNIT_GOTO_EQUAL(g_testCount, 2, g_testCount, EXIT); // 断言g_testCount应为2
g_testCount++; 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); // 5, here assert the result. 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的函数
static void *PthreadF02(void *t) static void *PthreadF02(void *t)
{ {
int i;
int rc; int rc;
ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT); ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT); // 断言g_testCount应为1
g_testCount++; 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); // 3, here assert the result. ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT); // 断言g_testCount应为3
g_testCount++; g_testCount++; // g_testCount再加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); // 4, here assert the result. ICUNIT_GOTO_EQUAL(g_testCount, 4, g_testCount, EXIT); // 断言g_testCount应为4
g_testCount++; 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); // 2, delay for Timing control.
LosTaskDelay(2); // 延时2ms，控制时序
EXIT: EXIT:
pthread_exit(NULL); pthread_exit(NULL);
} }
// 测试用例
static unsigned int TestCase(void) static unsigned int TestCase(void)
{ {
int i;
long t1 = 1;
long t2 = 2;
int rc; int rc;
pthread_t threads[3]; // 3, need 3 pthread for test. pthread_t threads[2]; // 需要2个线程来进行测试
pthread_attr_t attr; 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); // 初始化条件变量
rc = pthread_create(&threads[0], NULL, PthreadF01, (void *)t1); // 创建线程1
rc = pthread_create(&threads[0], NULL, PthreadF01, NULL);
ICUNIT_ASSERT_EQUAL(rc, 0, rc); ICUNIT_ASSERT_EQUAL(rc, 0, rc);
rc = pthread_create(&threads[1], NULL, PthreadF02, (void *)t2); // 创建线程2
rc = pthread_create(&threads[1], NULL, PthreadF02, NULL);
ICUNIT_ASSERT_EQUAL(rc, 0, rc); ICUNIT_ASSERT_EQUAL(rc, 0, rc);
for (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(&attr); // 销毁线程属性
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);
@ -118,6 +130,7 @@ 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