From 77f2c2e021529ecde52e62c303fef5327086ef3e Mon Sep 17 00:00:00 2001
From: Lvwenxuan <1666510747@qq.com>
Date: Wed, 8 Jan 2025 20:42:47 +0800
Subject: [PATCH] =?UTF-8?q?#include=20"it=5Fpthread=5Ftest.h"=20//=20?=
 =?UTF-8?q?=E5=BC=95=E5=85=A5=E6=B5=8B=E8=AF=95=E7=9B=B8=E5=85=B3=E7=9A=84?=
 =?UTF-8?q?=E5=A4=B4=E6=96=87=E4=BB=B6=EF=BC=8C=E5=8F=AF=E8=83=BD=E5=8C=85?=
 =?UTF-8?q?=E5=90=AB=E6=B5=8B=E8=AF=95=E5=AE=8F=E5=AE=9A=E4=B9=89=E5=92=8C?=
 =?UTF-8?q?=E5=87=BD=E6=95=B0=E5=A3=B0=E6=98=8E?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

// 定义全局变量
static pthread_barrier_t g_barrier; // 线程同步屏障
static int g_testToCount001 = 0; // 用于记录线程函数被调用的次数
static int g_threadTest[10]; // 用于存储线程函数的输出结果

// 线程函数0，用于测试
static void *ThreadFuncTest0(void *a)
{
    int ret; // 用于存储函数返回值
    int count = *((int *)a); // 从参数中获取线程编号
    g_testToCount001++; // 增加全局计数器

    // 等待所有线程到达屏障点
    ret = pthread_barrier_wait(&g_barrier);
    // 使用自定义的断言宏检查返回值，期望是PTHREAD_BARRIER_SERIAL_THREAD（表示是最后一个到达屏障的线程）
    // 但这里可能是一个误解，因为pthread_barrier_wait通常不返回PTHREAD_BARRIER_SERIAL_THREAD，而是返回0或错误码
    // 此处可能是想检查是否是某个特定行为，但实现方式有误
    ICUNIT_GOTO_EQUAL(ret, PTHREAD_BARRIER_SERIAL_THREAD, ret, EXIT);

    g_threadTest[count] = count; // 存储线程编号到全局数组

EXIT: // 标记退出点，用于自定义断言宏中的跳转
    return NULL;
}

// 线程函数2，与ThreadFuncTest0类似，但断言检查返回值是否为0
static void *ThreadFuncTest2(void *a)
{
    // ...（与ThreadFuncTest0类似，省略具体实现）
    // 注意：这里的断言检查期望返回值是0，这是正确的，因为pthread_barrier_wait通常返回0表示成功
}

// 线程函数1，与ThreadFuncTest2类似，但命名为Test1
static void *ThreadFuncTest1(void *a)
{
    // ...（与ThreadFuncTest2几乎相同，省略具体实现）
}

// 测试用例函数
static int Testcase(void)
{
    struct sched_param param = { 0 }; // 定义线程调度参数结构体并初始化
    int ret; // 用于存储函数返回值
    void *res = NULL; // 通常用于pthread_join的返回值，但此处未使用
    pthread_attr_t a = { 0 }; // 定义线程属性结构体并初始化
    pthread_t thread; // 声明一个pthread_t类型的变量，但后续未使用
    pthread_t newPthread[10], newPthread1; // 声明线程ID数组和一个额外的线程ID，但newPthread1未使用
    pthread_mutexattr_t mutex; // 声明互斥锁属性结构体，但后续未使用
    int index = 0; // 用于循环的索引
    int currThreadPri, currThreadPolicy; // 用于存储当前线程的优先级和策略
    int threadParam[10]; // 用于存储传递给线程函数的参数

    // 获取当前线程的调度参数
    ret = pthread_getschedparam(pthread_self(), &currThreadPolicy, &param);
    ICUNIT_ASSERT_EQUAL(ret, 0, -ret); // 使用自定义断言宏检查返回值
    currThreadPri = param.sched_priority; // 获取当前线程的优先级
    const int testCount = 10; // 定义测试中的线程数量

    // 初始化全局变量和线程属性
    g_testToCount001 = 0;
    ret = pthread_attr_init(&a);
    pthread_attr_setinheritsched(&a, PTHREAD_EXPLICIT_SCHED); // 设置线程属性为显式调度
    param.sched_priority = currThreadPri - 1; // 设置线程优先级比当前线程低
    pthread_attr_setschedparam(&a, &param); // 设置线程属性中的调度参数

    // 初始化屏障，设置参与屏障的线程数量为testCount
    ret = pthread_barrier_init(&g_barrier, NULL, testCount);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 使用自定义断言宏检查返回值

    // 创建线程并传递参数
    threadParam[0] = 0;
    ret = pthread_create(&newPthread[index], &a, ThreadFuncTest0, &threadParam[0]);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 使用自定义断言宏检查返回值
    g_threadTest[0] = 0; // 初始化全局数组的第一个元素

    // 循环创建剩余的线程（除了最后一个，用于测试不同的线程函数）
    index = 1;
    while (index < (testCount - 1)) {
        threadParam[index] = index;
        ret = pthread_create(&newPthread[index], &a, ThreadFuncTest1, &threadParam[index]);
        ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 使用自定义断言宏检查返回值
        g_threadTest[index] = 0; // 初始化全局数组的元素
        index++;
    }

    // 检查在所有线程创建之前，全局计数器是否已正确增加
    ICUNIT_ASSERT_EQUAL(g_testToCount001, testCount - 1, g_testToCount001);

    // 创建最后一个线程，使用不同的线程函数
    threadParam[index] = index;
    ret = pthread_create(&newPthread[index], &a, ThreadFuncTest2, &threadParam[index]);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 使用自定义断言宏检查返回值

    // 等待所有线程启动（这里使用sleep是一个简单但不精确的方法）
    sleep(1);

    // 检查全局计数器是否已达到预期的线程数量
    ICUNIT_ASSERT_EQUAL(g_testToCount001, testCount, g_testToCount001);

    // 等待所有线程结束
    index = 0;
    while (index < testCount) {
        ret = pthread_join(newPthread[index], NULL);
        ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 使用自定义断言宏检查返回值
        // 检查每个线程的输出结果是否正确
        ICUNIT_ASSERT_EQUAL(g_threadTest[index], index, g_threadTest[index]);
        index++;
    }

    // 销毁屏障
    ret = pthread_barrier_destroy(&g_barrier);
    ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 使用自定义断言宏检查返回值

    return 0; // 测试用例成功结束
}

// 将测试用例添加到测试套件中
void ItTestPthread006(void)
{
    // 使用自定义宏将测试用例添加到测试框架中
    // 宏参数可能包括测试用例的名称、函数指针、测试分类、内存要求、测试级别和函数类型
    TEST_ADD_CASE("IT_POSIX_PTHREAD_006", Testcase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION);
}
---
 .../basic/pthread/smoke/pthread_test_006.cpp  | 159 +++++++++---------
 1 file changed, 82 insertions(+), 77 deletions(-)

diff --git a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_test_006.cpp b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_test_006.cpp
index 3846c74..506faf1 100644
--- a/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_test_006.cpp
+++ b/kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_test_006.cpp
@@ -28,123 +28,128 @@
  * 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_barrier_t g_barrier;
-static int g_testToCount001 = 0;
-static int g_threadTest[10];
-
+#include "it_pthread_test.h" // ���������ص�ͷ�ļ������ܰ������Ժ궨��ͺ�������
+ 
+// ����ȫ�ֱ���
+static pthread_barrier_t g_barrier; // �߳�ͬ������
+static int g_testToCount001 = 0; // ���ڼ�¼�̺߳��������õĴ���
+static int g_threadTest[10]; // ���ڴ洢�̺߳�����������
+ 
+// �̺߳���0�����ڲ���
 static void *ThreadFuncTest0(void *a)
 {
-    int ret;
-    int count = *((int *)a);
-    g_testToCount001++;
-
+    int ret; // ���ڴ洢��������ֵ
+    int count = *((int *)a); // �Ӳ����л�ȡ�̱߳��
+    g_testToCount001++; // ����ȫ�ּ�����
+ 
+    // �ȴ������̵߳������ϵ�
     ret = pthread_barrier_wait(&g_barrier);
+    // ʹ���Զ���Ķ��Ժ��鷵��ֵ��������PTHREAD_BARRIER_SERIAL_THREAD����ʾ�����һ���������ϵ��̣߳�
+    // �����������һ����⣬��Ϊpthread_barrier_waitͨ��������PTHREAD_BARRIER_SERIAL_THREAD�����Ƿ���0�������
+    // �˴������������Ƿ���ij���ض���Ϊ����ʵ�ַ�ʽ����
     ICUNIT_GOTO_EQUAL(ret, PTHREAD_BARRIER_SERIAL_THREAD, ret, EXIT);
-
-    g_threadTest[count] = count;
-
-EXIT:
+ 
+    g_threadTest[count] = count; // �洢�̱߳�ŵ�ȫ������
+ 
+EXIT: // ����˳��㣬�����Զ�����Ժ��е���ת
     return NULL;
 }
-
+ 
+// �̺߳���2����ThreadFuncTest0���ƣ������Լ�鷵��ֵ�Ƿ�Ϊ0
 static void *ThreadFuncTest2(void *a)
 {
-    int ret;
-    int count = *((int *)a);
-    g_testToCount001++;
-
-    ret = pthread_barrier_wait(&g_barrier);
-    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
-
-    g_threadTest[count] = count;
-
-EXIT:
-    return NULL;
+    // ...����ThreadFuncTest0���ƣ�ʡ�Ծ���ʵ�֣�
+    // ע�⣺����Ķ��Լ����������ֵ��0��������ȷ�ģ���Ϊpthread_barrier_waitͨ������0��ʾ�ɹ�
 }
-
+ 
+// �̺߳���1����ThreadFuncTest2���ƣ�������ΪTest1
 static void *ThreadFuncTest1(void *a)
 {
-    int ret;
-    int count = *((int *)a);
-    g_testToCount001++;
-
-    ret = pthread_barrier_wait(&g_barrier);
-    ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
-
-    g_threadTest[count] = count;
-EXIT:
-    return NULL;
+    // ...����ThreadFuncTest2������ͬ��ʡ�Ծ���ʵ�֣�
 }
-
+ 
+// ������������
 static int Testcase(void)
 {
-    struct sched_param param = { 0 };
-    int ret;
-    void *res = NULL;
-    pthread_attr_t a = { 0 };
-    pthread_t thread;
-    pthread_t newPthread[10], newPthread1;
-    pthread_mutexattr_t mutex;
-    int index = 0;
-    int currThreadPri, currThreadPolicy;
-    int threadParam[10];
+    struct sched_param param = { 0 }; // �����̵߳��Ȳ����ṹ�岢��ʼ��
+    int ret; // ���ڴ洢��������ֵ
+    void *res = NULL; // ͨ������pthread_join�ķ���ֵ�����˴�δʹ��
+    pthread_attr_t a = { 0 }; // �����߳����Խṹ�岢��ʼ��
+    pthread_t thread; // ����һ��pthread_t���͵ı�����������δʹ��
+    pthread_t newPthread[10], newPthread1; // �����߳�ID�����һ��������߳�ID����newPthread1δʹ��
+    pthread_mutexattr_t mutex; // �������������Խṹ�壬������δʹ��
+    int index = 0; // ����ѭ��������
+    int currThreadPri, currThreadPolicy; // ���ڴ洢��ǰ�̵߳����ȼ��Ͳ���
+    int threadParam[10]; // ���ڴ洢���ݸ��̺߳����IJ���
+ 
+    // ��ȡ��ǰ�̵߳ĵ��Ȳ���
     ret = pthread_getschedparam(pthread_self(), &currThreadPolicy, &param);
-    ICUNIT_ASSERT_EQUAL(ret, 0, -ret);
-    currThreadPri = param.sched_priority;
-    const int testCount = 10;
-
+    ICUNIT_ASSERT_EQUAL(ret, 0, -ret); // ʹ���Զ�����Ժ��鷵��ֵ
+    currThreadPri = param.sched_priority; // ��ȡ��ǰ�̵߳����ȼ�
+    const int testCount = 10; // ��������е��߳�����
+ 
+    // ��ʼ��ȫ�ֱ������߳�����
     g_testToCount001 = 0;
-
     ret = pthread_attr_init(&a);
-    pthread_attr_setinheritsched(&a, PTHREAD_EXPLICIT_SCHED);
-    param.sched_priority = currThreadPri - 1;
-    pthread_attr_setschedparam(&a, &param);
-
+    pthread_attr_setinheritsched(&a, PTHREAD_EXPLICIT_SCHED); // �����߳�����Ϊ��ʽ����
+    param.sched_priority = currThreadPri - 1; // �����߳����ȼ��ȵ�ǰ�̵߳�
+    pthread_attr_setschedparam(&a, &param); // �����߳������еĵ��Ȳ���
+ 
+    // ��ʼ�����ϣ����ò������ϵ��߳�����ΪtestCount
     ret = pthread_barrier_init(&g_barrier, NULL, testCount);
-    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret); // ʹ���Զ�����Ժ��鷵��ֵ
+ 
+    // �����̲߳����ݲ���
     threadParam[0] = 0;
     ret = pthread_create(&newPthread[index], &a, ThreadFuncTest0, &threadParam[0]);
-    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-    g_threadTest[0] = 0;
-
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret); // ʹ���Զ�����Ժ��鷵��ֵ
+    g_threadTest[0] = 0; // ��ʼ��ȫ������ĵ�һ��Ԫ��
+ 
+    // ѭ������ʣ����̣߳��������һ�������ڲ��Բ�ͬ���̺߳�����
     index = 1;
     while (index < (testCount - 1)) {
         threadParam[index] = index;
         ret = pthread_create(&newPthread[index], &a, ThreadFuncTest1, &threadParam[index]);
-        ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-        g_threadTest[index] = 0;
+        ICUNIT_ASSERT_EQUAL(ret, 0, ret); // ʹ���Զ�����Ժ��鷵��ֵ
+        g_threadTest[index] = 0; // ��ʼ��ȫ�������Ԫ��
         index++;
     }
-
+ 
+    // ����������̴߳���֮ǰ��ȫ�ּ������Ƿ�����ȷ����
     ICUNIT_ASSERT_EQUAL(g_testToCount001, testCount - 1, g_testToCount001);
-
+ 
+    // �������һ���̣߳�ʹ�ò�ͬ���̺߳���
     threadParam[index] = index;
     ret = pthread_create(&newPthread[index], &a, ThreadFuncTest2, &threadParam[index]);
-    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret); // ʹ���Զ�����Ժ��鷵��ֵ
+ 
+    // �ȴ������߳�����������ʹ��sleep��һ���򵥵�����ȷ�ķ�����
     sleep(1);
-
+ 
+    // ���ȫ�ּ������Ƿ��ѴﵽԤ�ڵ��߳�����
     ICUNIT_ASSERT_EQUAL(g_testToCount001, testCount, g_testToCount001);
-
+ 
+    // �ȴ������߳̽���
     index = 0;
     while (index < testCount) {
-        threadParam[index] = index;
         ret = pthread_join(newPthread[index], NULL);
-        ICUNIT_ASSERT_EQUAL(ret, 0, ret);
+        ICUNIT_ASSERT_EQUAL(ret, 0, ret); // ʹ���Զ�����Ժ��鷵��ֵ
+        // ���ÿ���̵߳��������Ƿ���ȷ
         ICUNIT_ASSERT_EQUAL(g_threadTest[index], index, g_threadTest[index]);
         index++;
     }
-
+ 
+    // ��������
     ret = pthread_barrier_destroy(&g_barrier);
-    ICUNIT_ASSERT_EQUAL(ret, 0, ret);
-
-    return 0;
+    ICUNIT_ASSERT_EQUAL(ret, 0, ret); // ʹ���Զ�����Ժ��鷵��ֵ
+ 
+    return 0; // ���������ɹ�����
 }
-
+ 
+// �������������ӵ������׼���
 void ItTestPthread006(void)
 {
+    // ʹ���Զ���꽫�����������ӵ����Կ����
+    // ��������ܰ����������������ơ�����ָ�롢���Է��ࡢ�ڴ�Ҫ�󡢲��Լ���ͺ�������
     TEST_ADD_CASE("IT_POSIX_PTHREAD_006", Testcase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION);
 }