diff --git a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_atfork_test_001.cpp b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_atfork_test_001.cpp
index 41037f2..0f4a4d8 100644
--- a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_atfork_test_001.cpp
+++ b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_atfork_test_001.cpp
@@ -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; // ���ڱ�Ǹ�����ִ�еIJ���
+static int g_testAtforkChild = 0; // ���ڱ���ӽ���ִ�еIJ���
+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);
 }
+
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 0f61ac4..68c18f5 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
@@ -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);
 }
+
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 ccbb5bb..d13644c 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
@@ -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);
 }
+