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.
*/
#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;
static int g_testAtforkParent = 0;
static int g_testAtforkChild = 0;
static const int SLEEP_TIME = 2;
// 全局变量
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);
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);
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);
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;
while (g_count < 5) { // 5, wait until g_count == 5.
err = pthread_mutex_lock(&g_lock);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT);
g_count++;
SLEEP_AND_YIELD(SLEEP_TIME);
err = pthread_mutex_unlock(&g_lock);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT);
SLEEP_AND_YIELD(SLEEP_TIME);
// 当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的函数
static void *PthreadAtforkTest(void *arg)
{
int err;
@ -92,57 +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);
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);
SLEEP_AND_YIELD(SLEEP_TIME); // 睡眠并让出CPU
// 创建子进程
pid = fork();
ICUNIT_GOTO_WITHIN_EQUAL(pid, 0, 100000, pid, EXIT); // 100000, The pid will never exceed 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);
int status;
while (g_count < 5) { // 5, wait until g_count == 5.
err = pthread_mutex_lock(&g_lock);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT);
g_count++;
SLEEP_AND_YIELD(SLEEP_TIME);
err = pthread_mutex_unlock(&g_lock);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT);
SLEEP_AND_YIELD(SLEEP_TIME);
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, set exit status
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);
ICUNIT_GOTO_EQUAL(status, 15, status, EXIT); // 15, get exit status.
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;
@ -151,24 +161,28 @@ 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; // 2, adjust the priority.
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);

149
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
* 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 <sched.h>
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);
static void Parent(void);
static void *PthreadAtforkTest(void *arg);
static int Testcase(void);
void ItTestPthreadAtfork002(void);
// Doit 函数（线程 1）
static void *Doit(void *arg)
{
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);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT);
if (err != 0) return NULL;
(void)nanosleep(&ts, NULL);
err = pthread_mutex_unlock(&g_mux);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT);
(void)nanosleep(&ts, NULL); // 睡眠 2 秒
err = pthread_mutex_unlock(&g_mux); // 解锁互斥锁
if (err != 0) return NULL;
EXIT:
return NULL;
}
// Doit1 函数（线程 2 - 子进程）
static void *Doit1(void *arg)
{
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);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT);
if (err != 0) return NULL;
(void)nanosleep(&ts, NULL);
err = pthread_mutex_unlock(&g_mux);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT);
(void)nanosleep(&ts, NULL); // 睡眠 2 秒
err = pthread_mutex_unlock(&g_mux); // 解锁互斥锁
if (err != 0) return NULL;
EXIT:
return NULL;
}
// Prepare 函数（在 fork 前调用）
static void Prepare(void)
{
int err;
err = pthread_mutex_unlock(&g_mux);
ICUNIT_ASSERT_EQUAL_VOID(err, 0, err);
g_testAtforkPrepare++;
err = pthread_mutex_unlock(&g_mux); // 在 fork 前解锁互斥锁
if (err != 0) return;
g_testAtforkPrepare++; // 增加 prepare 计数
}
// Parent 函数（在 fork 后父进程中调用）
static void Parent(void)
{
int err = pthread_mutex_lock(&g_mux);
ICUNIT_ASSERT_EQUAL_VOID(err, 0, err);
g_testAtforkParent++;
int err = pthread_mutex_lock(&g_mux); // 在父进程中锁住互斥锁
if (err != 0) return;
g_testAtforkParent++; // 增加父进程计数
}
// PthreadAtforkTest 函数（主测试函数）
static void *PthreadAtforkTest(void *arg)
{
int err, ret;
@ -102,40 +128,53 @@ static void *PthreadAtforkTest(void *arg)
g_testAtforkPrepare = 0;
g_testAtforkParent = 0;
err = pthread_atfork(Prepare, Parent, NULL);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT);
g_testAtforkCount++;
err = pthread_create(&tid, NULL, Doit, NULL);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT);
// 注册 pthread_atfork 的回调函数
err = pthread_atfork(Prepare, Parent, NULL);
if (err != 0) return NULL;
nanosleep(&ts, NULL);
pid = fork();
ICUNIT_GOTO_EQUAL(g_testAtforkPrepare, 1, g_testAtforkPrepare, EXIT);
if (pid == 0) {
Doit1(NULL);
exit(10); // 10, set exit status.
g_testAtforkCount++; // 增加计数用于测试
// 创建一个线程执行 Doit 函数
err = pthread_create(&tid, NULL, Doit, NULL);
if (err != 0) return NULL;
nanosleep(&ts, NULL); // 睡眠 1 秒
pid = fork(); // 创建子进程
// 检查 Prepare 函数是否被调用
if (g_testAtforkPrepare != 1) {
return NULL;
}
ICUNIT_GOTO_WITHIN_EQUAL(pid, 0, 100000, pid, EXIT_WAIT); // 100000, The pid will never exceed 100000.
ICUNIT_GOTO_EQUAL(g_testAtforkParent, 1, g_testAtforkParent, EXIT_WAIT);
if (pid == 0) {
Doit1(NULL); // 在子进程中执行 Doit1 函数
exit(10); // 子进程退出，返回状态 10
}
err = pthread_join(tid, NULL);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT_WAIT);
if (pid <= 0) {
return NULL;
}
// 检查 Parent 函数是否被调用
if (g_testAtforkParent != 1) {
return NULL;
}
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.
// 等待线程执行完毕
err = pthread_join(tid, NULL);
if (err != 0) return NULL;
EXIT:
return NULL;
// 等待子进程结束
err = waitpid(pid, &status, 0);
status = WEXITSTATUS(status); // 获取子进程退出状态
if (err != pid || status != 10) {
return NULL;
}
EXIT_WAIT:
(void)waitpid(pid, 0, 0);
return NULL;
}
// Testcase 函数（初始化线程调度参数并执行测试）
static int Testcase(void)
{
int ret;
@ -144,24 +183,32 @@ static int Testcase(void)
pthread_attr_t a = { 0 };
struct sched_param param = { 0 };
// 获取当前线程的调度参数
ret = pthread_getschedparam(pthread_self(), &curThreadPolicy, &param);
ICUNIT_ASSERT_EQUAL(ret, 0, -ret);
if (ret != 0) return ret;
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);
param.sched_priority = curThreadPri + 2; // 2, adjust the priority.
param.sched_priority = curThreadPri + 2; // 设置线程优先级为当前优先级 + 2
pthread_attr_setschedparam(&a, &param);
ret = pthread_create(&newPthread, &a, PthreadAtforkTest, 0);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ret = pthread_join(newPthread, NULL);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
// 创建新线程执行 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 函数（测试用例入口）
void ItTestPthreadAtfork002(void)
{
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
* 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_cond_t g_pthdCondTest1;
static pthread_mutex_t g_pthreadMuxTest1; // 定义互斥锁
static pthread_cond_t g_pthdCondTest1; // 定义条件变量
// 线程1的函数
static void *PthreadF01(void *t)
{
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++;
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); // 5, here assert the result.
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的函数
static void *PthreadF02(void *t)
{
int i;
int rc;
ICUNIT_GOTO_EQUAL(g_testCount, 1, g_testCount, EXIT);
g_testCount++;
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); // 3, here assert the result.
g_testCount++;
ICUNIT_GOTO_EQUAL(g_testCount, 3, g_testCount, EXIT); // 断言g_testCount应为3
g_testCount++; // g_testCount再加1
// 发送信号，唤醒线程1
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.
g_testCount++;
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); // 2, delay for Timing control.
LosTaskDelay(2); // 延时2ms，控制时序
EXIT:
pthread_exit(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_attr_t attr;
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); // 初始化条件变量
rc = pthread_create(&threads[0], NULL, PthreadF01, (void *)t1);
// 创建线程1
rc = pthread_create(&threads[0], NULL, PthreadF01, NULL);
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);
for (i = 0; i < loopNum; i++) {
// 等待线程结束
for (int i = 0; i < loopNum; i++) {
rc = pthread_join(threads[i], NULL);
ICUNIT_ASSERT_EQUAL(rc, 0, rc);
}
rc = pthread_attr_destroy(&attr);
// 销毁线程属性
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);
@ -118,6 +130,7 @@ 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