py6atlu3x
/
openharmonydocs
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

#include "it_pthread_test.h" // 引入测试相关的头文件，可能包含测试宏定义和函数声明

Browse Source 
// 定义全局变量
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);
}
main
Lvwenxuan 7 months ago
parent feebadef06
commit 77f2c2e021
1 changed files with 82 additions and 77 deletions
Show Stats Download Patch File Download Diff File

159
kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_test_006.cpp
Unescape View File

@ -28,123 +28,128 @@
* 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 "it_pthread_test.h" // 引入测试相关的头文件，可能包含测试宏定义和函数声明
static pthread_barrier_t g_barrier; // 定义全局变量
static int g_testToCount001 = 0; static pthread_barrier_t g_barrier; // 线程同步屏障
static int g_threadTest[10]; static int g_testToCount001 = 0; // 用于记录线程函数被调用的次数
static int g_threadTest[10]; // 用于存储线程函数的输出结果
// 线程函数0，用于测试
static void *ThreadFuncTest0(void *a) static void *ThreadFuncTest0(void *a)
{ {
int ret; int ret; // 用于存储函数返回值
int count = *((int *)a); int count = *((int *)a); // 从参数中获取线程编号
g_testToCount001++; g_testToCount001++; // 增加全局计数器
// 等待所有线程到达屏障点
ret = pthread_barrier_wait(&g_barrier); 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); ICUNIT_GOTO_EQUAL(ret, PTHREAD_BARRIER_SERIAL_THREAD, ret, EXIT);
g_threadTest[count] = count; g_threadTest[count] = count; // 存储线程编号到全局数组
EXIT: EXIT: // 标记退出点，用于自定义断言宏中的跳转
return NULL; return NULL;
} }
// 线程函数2，与ThreadFuncTest0类似，但断言检查返回值是否为0
static void *ThreadFuncTest2(void *a) static void *ThreadFuncTest2(void *a)
{ {
int ret; // ...（与ThreadFuncTest0类似，省略具体实现）
int count = *((int *)a); // 注意：这里的断言检查期望返回值是0，这是正确的，因为pthread_barrier_wait通常返回0表示成功
g_testToCount001++;
ret = pthread_barrier_wait(&g_barrier);
ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT);
g_threadTest[count] = count;
EXIT:
return NULL;
} }
// 线程函数1，与ThreadFuncTest2类似，但命名为Test1
static void *ThreadFuncTest1(void *a) static void *ThreadFuncTest1(void *a)
{ {
int ret; // ...（与ThreadFuncTest2几乎相同，省略具体实现）
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;
} }
// 测试用例函数
static int Testcase(void) static int Testcase(void)
{ {
struct sched_param param = { 0 }; struct sched_param param = { 0 }; // 定义线程调度参数结构体并初始化
int ret; int ret; // 用于存储函数返回值
void *res = NULL; void *res = NULL; // 通常用于pthread_join的返回值，但此处未使用
pthread_attr_t a = { 0 }; pthread_attr_t a = { 0 }; // 定义线程属性结构体并初始化
pthread_t thread; pthread_t thread; // 声明一个pthread_t类型的变量，但后续未使用
pthread_t newPthread[10], newPthread1; pthread_t newPthread[10], newPthread1; // 声明线程ID数组和一个额外的线程ID，但newPthread1未使用
pthread_mutexattr_t mutex; pthread_mutexattr_t mutex; // 声明互斥锁属性结构体，但后续未使用
int index = 0; int index = 0; // 用于循环的索引
int currThreadPri, currThreadPolicy; int currThreadPri, currThreadPolicy; // 用于存储当前线程的优先级和策略
int threadParam[10]; int threadParam[10]; // 用于存储传递给线程函数的参数
// 获取当前线程的调度参数
ret = pthread_getschedparam(pthread_self(), &currThreadPolicy, &param); ret = pthread_getschedparam(pthread_self(), &currThreadPolicy, &param);
ICUNIT_ASSERT_EQUAL(ret, 0, -ret); ICUNIT_ASSERT_EQUAL(ret, 0, -ret); // 使用自定义断言宏检查返回值
currThreadPri = param.sched_priority; currThreadPri = param.sched_priority; // 获取当前线程的优先级
const int testCount = 10; const int testCount = 10; // 定义测试中的线程数量
// 初始化全局变量和线程属性
g_testToCount001 = 0; g_testToCount001 = 0;
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 = currThreadPri - 1; param.sched_priority = currThreadPri - 1; // 设置线程优先级比当前线程低
pthread_attr_setschedparam(&a, &param); pthread_attr_setschedparam(&a, &param); // 设置线程属性中的调度参数
// 初始化屏障，设置参与屏障的线程数量为testCount
ret = pthread_barrier_init(&g_barrier, NULL, testCount); ret = pthread_barrier_init(&g_barrier, NULL, testCount);
ICUNIT_ASSERT_EQUAL(ret, 0, ret); ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 使用自定义断言宏检查返回值
// 创建线程并传递参数
threadParam[0] = 0; threadParam[0] = 0;
ret = pthread_create(&newPthread[index], &a, ThreadFuncTest0, &threadParam[0]); ret = pthread_create(&newPthread[index], &a, ThreadFuncTest0, &threadParam[0]);
ICUNIT_ASSERT_EQUAL(ret, 0, ret); ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 使用自定义断言宏检查返回值
g_threadTest[0] = 0; g_threadTest[0] = 0; // 初始化全局数组的第一个元素
// 循环创建剩余的线程（除了最后一个，用于测试不同的线程函数）
index = 1; index = 1;
while (index < (testCount - 1)) { while (index < (testCount - 1)) {
threadParam[index] = index; threadParam[index] = index;
ret = pthread_create(&newPthread[index], &a, ThreadFuncTest1, &threadParam[index]); ret = pthread_create(&newPthread[index], &a, ThreadFuncTest1, &threadParam[index]);
ICUNIT_ASSERT_EQUAL(ret, 0, ret); ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 使用自定义断言宏检查返回值
g_threadTest[index] = 0; g_threadTest[index] = 0; // 初始化全局数组的元素
index++; index++;
} }
// 检查在所有线程创建之前，全局计数器是否已正确增加
ICUNIT_ASSERT_EQUAL(g_testToCount001, testCount - 1, g_testToCount001); ICUNIT_ASSERT_EQUAL(g_testToCount001, testCount - 1, g_testToCount001);
// 创建最后一个线程，使用不同的线程函数
threadParam[index] = index; threadParam[index] = index;
ret = pthread_create(&newPthread[index], &a, ThreadFuncTest2, &threadParam[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); sleep(1);
// 检查全局计数器是否已达到预期的线程数量
ICUNIT_ASSERT_EQUAL(g_testToCount001, testCount, g_testToCount001); ICUNIT_ASSERT_EQUAL(g_testToCount001, testCount, g_testToCount001);
// 等待所有线程结束
index = 0; index = 0;
while (index < testCount) { while (index < testCount) {
threadParam[index] = index;
ret = pthread_join(newPthread[index], NULL); 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]); ICUNIT_ASSERT_EQUAL(g_threadTest[index], index, g_threadTest[index]);
index++; index++;
} }
// 销毁屏障
ret = pthread_barrier_destroy(&g_barrier); ret = pthread_barrier_destroy(&g_barrier);
ICUNIT_ASSERT_EQUAL(ret, 0, ret); ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 使用自定义断言宏检查返回值
return 0; return 0; // 测试用例成功结束
} }
// 将测试用例添加到测试套件中
void ItTestPthread006(void) void ItTestPthread006(void)
{ {
// 使用自定义宏将测试用例添加到测试框架中
// 宏参数可能包括测试用例的名称、函数指针、测试分类、内存要求、测试级别和函数类型
TEST_ADD_CASE("IT_POSIX_PTHREAD_006", Testcase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION); TEST_ADD_CASE("IT_POSIX_PTHREAD_006", Testcase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION);
} }

Write Preview
Loading…
Cancel
Save