/*
 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
 * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this list of
 * conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
 * of conditions and the following disclaimer in the documentation and/or other materials
 * provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
 * to endorse or promote products derived from this software without specific prior written
 * permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * 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]; // 用于存储线程函数的输出结果
 
// 线程函数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);
}
