main
master
miao
分支昶
doc
panjiayan_branch
吕汶轩
develop
src
赵颢翔-branch
${ noResults }
5 Commits (8c28fae73bbd06b35a4e355a6cffba4cdf9188e6)
| Author | SHA1 | Message | Date |
|---|---|---|---|
 Lvwenxuan
|
768b870f5b |
#include "it_pthread_test.h" // 包含测试框架的头文件
// 全局变量定义
static int g_number = 0; // 用于记录 InitRoutine 被调用的次数
static int g_okStatus = 777; // 定义一个特殊的状态值，表示状态正常
static pthread_once_t g_onceCtrl = PTHREAD_ONCE_INIT; // pthread_once 的控制变量，初始化为未执行状态
// 初始化函数，每次调用都会增加 g_number 的值
static void InitRoutine(void)
{
g_number++;
}
// 线程函数，测试 pthread_once 的行为
static void *Threadfunc(void *parm)
{
int err;
// 确保 InitRoutine 只被调用一次
err = pthread_once(&g_onceCtrl, InitRoutine);
ICUNIT_GOTO_EQUAL(err, 0, err, EXIT); // 使用测试框架的宏检查 pthread_once 的返回值是否为 0
return reinterpret_cast<void *>(g_okStatus); // 返回状态值
EXIT:
return NULL; // 出错时返回 NULL
}
// 测试函数，创建多个线程并检查 pthread_once 的行为
static void *ThreadFuncTest(void *arg)
{
pthread_t thread[3]; // 定义线程数组，用于存储线程 ID
int rc = 0; // 用于存储线程创建和加入的返回值
int i = 3; // 循环变量，但立即被重新赋值，这里可能是代码风格问题
void *status; // 用于存储线程函数的返回值
const int threadsNum = 3; // 定义线程数量
g_number = 0; // 重置全局计数器
// 创建多个线程
for (i = 0; i < threadsNum; ++i) {
rc = pthread_create(&thread[i], NULL, Threadfunc, NULL);
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); // 检查 pthread_create 的返回值
}
// 等待所有线程结束
for (i = 0; i < threadsNum; ++i) {
rc = pthread_join(thread[i], &status);
ICUNIT_GOTO_EQUAL(rc, 0, rc, EXIT); // 检查 pthread_join 的返回值
ICUNIT_GOTO_EQUAL((unsigned int)status, (unsigned int)g_okStatus, status, EXIT); // 检查线程函数的返回值
}
// 检查 InitRoutine 是否只被调用了一次
ICUNIT_GOTO_EQUAL(g_number, 1, g_number, EXIT);
EXIT:
return NULL; // 出错时返回 NULL
}
// 测试用例函数，设置线程属性并启动测试线程
static int Testcase(void)
{
int ret; // 用于存储函数调用的返回值
pthread_t newPthread; // 定义新线程的 ID
int curThreadPri, curThreadPolicy; // 用于存储当前线程的调度策略和优先级
pthread_attr_t a = { 0 }; // 定义线程属性对象并初始化
struct sched_param param = { 0 }; // 定义调度参数对象并初始化
g_onceCtrl = PTHREAD_ONCE_INIT; // 重置 pthread_once 的控制变量
// 获取当前线程的调度策略和优先级
ret = pthread_getschedparam(pthread_self(), &curThreadPolicy, ¶m);
ICUNIT_ASSERT_EQUAL(ret, 0, -ret); // 检查 pthread_getschedparam 的返回值
curThreadPri = param.sched_priority; // 获取当前线程的优先级
// 设置新线程的属性
ret = pthread_attr_init(&a); // 初始化线程属性
pthread_attr_setinheritsched(&a, PTHREAD_EXPLICIT_SCHED); // 设置线程继承调度策略为显式
param.sched_priority = curThreadPri + 2; // 设置新线程的优先级为当前线程优先级加 2
pthread_attr_setschedparam(&a, ¶m); // 设置线程调度参数
ret = pthread_create(&newPthread, &a, ThreadFuncTest, 0); // 创建新线程并运行测试函数
ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 检查 pthread_create 的返回值
// 等待新线程结束
ret = pthread_join(newPthread, NULL);
ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 检查 pthread_join 的返回值
return 0; // 测试成功结束
}
// 注册测试用例
void ItTestPthreadOnce001(void)
{
TEST_ADD_CASE("IT_PTHREAD_ONCE_001", Testcase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION); // 使用测试框架的宏注册测试用例
}
|
11 months ago |
|
Lvwenxuan
|
b04c0c9f54 |
#include "it_pthread_test.h" // 引入测试相关的头文件
/* ***************************************************************************
* Public Functions
* ************************************************************************** */
// 定义全局变量用于存储当前线程的优先级、策略和测试线程计数
static int g_currThreadPri, g_currThreadPolicy;
static int g_testPthredCount;
// 线程函数，用于测试线程调度策略和优先级
static void *ThreadFuncTest2(void *arg)
{
(void)arg; // 未使用参数，避免编译器警告
int ret; // 存放函数返回值
int policy; // 存放调度策略
struct sched_param param = { 0 }; // 初始化调度参数结构体
pthread_t pthread = pthread_self(); // 获取当前线程ID
g_testPthredCount++; // 测试线程计数加1
// 获取当前线程的调度策略和参数
ret = pthread_getschedparam(pthread, &policy, ¶m);
ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); // 检查返回值，如果不为0则跳转到EXIT标签
// 验证当前线程的优先级和策略是否与全局变量一致
ICUNIT_GOTO_EQUAL(g_currThreadPri, param.sched_priority, param.sched_priority, EXIT);
ICUNIT_GOTO_EQUAL(g_currThreadPolicy, policy, policy, EXIT);
// 验证是否创建了2个测试线程
ICUNIT_GOTO_EQUAL(g_testPthredCount, 2, g_testPthredCount, EXIT);
EXIT: // 错误处理或正常退出的标签
return NULL;
}
// 另一个线程函数，用于测试SCHED_FIFO策略
static void *ThreadFuncTest3(void *arg)
{
(void)arg; // 未使用参数，避免编译器警告
int ret; // 存放函数返回值
int policy; // 存放调度策略
struct sched_param param = { 0 }; // 初始化调度参数结构体
pthread_t pthread = pthread_self(); // 获取当前线程ID
g_testPthredCount++; // 测试线程计数加1
// 获取当前线程的调度策略和参数
ret = pthread_getschedparam(pthread, &policy, ¶m);
ICUNIT_GOTO_EQUAL(ret, 0, ret, EXIT); // 检查返回值，如果不为0则跳转到EXIT标签
// 验证当前线程的优先级和策略是否与预期一致
ICUNIT_GOTO_EQUAL(g_currThreadPri, param.sched_priority, param.sched_priority, EXIT);
ICUNIT_GOTO_EQUAL(policy, SCHED_FIFO, policy, EXIT);
// 验证是否创建了4个测试线程
ICUNIT_GOTO_EQUAL(g_testPthredCount, 4, g_testPthredCount, EXIT);
EXIT: // 错误处理或正常退出的标签
return NULL;
}
// 测试用例函数
static int Testcase()
{
struct sched_param param = { 0 }; // 初始化调度参数结构体
int ret; // 存放函数返回值
void *res = NULL; // 用于存放线程函数的返回值
pthread_attr_t a = { 0 }; // 初始化线程属性结构体（此处未使用）
pthread_t newPthread, newPthread1; // 定义线程ID变量（注意：newPthread1未使用）
g_testPthredCount = 0; // 初始化测试线程计数
// 获取当前线程的调度策略和参数
ret = pthread_getschedparam(pthread_self(), &g_currThreadPolicy, ¶m);
ICUNIT_ASSERT_EQUAL(ret, 0, -ret); // 检查返回值
g_currThreadPri = param.sched_priority; // 保存当前线程的优先级
g_testPthredCount++; // 测试线程计数加1（此处应为初始化后的第一个操作，但计数逻辑稍显混乱）
// 创建第一个测试线程
ret = pthread_create(&newPthread, NULL, ThreadFuncTest2, 0);
ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 检查返回值
// 等待第一个测试线程结束
ret = pthread_join(newPthread, &res);
ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 检查返回值
// 验证是否创建了2个测试线程（逻辑上应在此处验证，但前面已有验证）
ICUNIT_ASSERT_EQUAL(g_testPthredCount, 2, g_testPthredCount);
g_testPthredCount++; // 测试线程计数再加1，准备创建下一个线程
// 设置当前线程的调度策略为SCHED_FIFO，并设置优先级
param.sched_priority = g_currThreadPri;
ret = pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m);
ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 检查返回值
// 尝试重新创建并使用已定义的newPthread变量（这里应使用不同的变量名以避免混淆）
ret = pthread_create(&newPthread, NULL, ThreadFuncTest3, 0);
ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 检查返回值
// 等待第二个测试线程结束
ret = pthread_join(newPthread, &res);
ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 检查返回值
// 验证是否创建了4个测试线程（实际只创建了2个，此处逻辑有误）
ICUNIT_ASSERT_EQUAL(g_testPthredCount, 4, g_testPthredCount);
// 恢复当前线程的调度策略为SCHED_RR，并设置优先级
param.sched_priority = g_currThreadPri;
ret = pthread_setschedparam(pthread_self(), SCHED_RR, ¶m);
ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 检查返回值
return 0; // 测试用例结束
}
// 注册测试用例到测试框架中
void ItTestPthread003(void)
{
TEST_ADD_CASE("IT_POSIX_PTHREAD_003", Testcase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION);
// 注册一个名为"IT_POSIX_PTHREAD_003"的测试用例，指定测试函数为Testcase，并设置相关测试属性
}
|
11 months ago |
|
Lvwenxuan
|
77f2c2e021 |
#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, ¶m);
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, ¶m); // 设置线程属性中的调度参数
// 初始化屏障，设置参与屏障的线程数量为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);
}
|
11 months ago |
|
Lvwenxuan
|
1e2e1722f8 |
/*
* 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.
*/
#ifndef _IT_PTHREAD_TEST_H // 防止头文件被重复包含
#define _IT_PTHREAD_TEST_H
#include "osTest.h" // 包含操作系统测试相关的头文件
#include <sys/resource.h> // 包含资源控制相关的头文件
#include <sys/wait.h> // 包含等待进程结束相关的头文件
#include <time.h> // 包含时间处理的头文件
#define SLEEP_AND_YIELD(tick) usleep((tick)*10 * 1000) // 定义宏，用于睡眠和让出CPU，tick为微秒单位
#include "sys/syscall.h" // 包含系统调用相关的头文件
// 定义一个内联函数，用于执行系统调用
static inline int Syscall(int nbr, int parm1, int parm2, int parm3, int parm4)
{
register int reg7 __asm__("r7") = nbr; // 将系统调用号放入寄存器r7
register int reg3 __asm__("r3") = parm4; // 将第四个参数放入寄存器r3
register int reg2 __asm__("r2") = parm3; // 将第三个参数放入寄存器r2
register int reg1 __asm__("r1") = parm2; // 将第二个参数放入寄存器r1
register int reg0 __asm__("r0") = parm1; // 将第一个参数放入寄存器r0
// 使用svc指令触发系统调用，将结果存回reg0
__asm__ __volatile__("svc 0" : "=r"(reg0) : "r"(reg7), "r"(reg0), "r"(reg1), "r"(reg2), "r"(reg3) : "memory");
return reg0; // 返回系统调用的结果
}
// 声明全局变量，用于存储单元测试的错误码和错误行号
extern INT32 g_iCunitErrCode;
extern INT32 g_iCunitErrLineNo;
// 声明一系列pthread相关的测试函数
extern void ItTestPthread001(void); // pthread测试函数1
extern void ItTestPthread002(void); // pthread测试函数2
extern void ItTestPthread003(void); // pthread测试函数3
extern void ItTestPthread004(void); // pthread测试函数4
extern void ItTestPthread005(void); // pthread测试函数5
extern void ItTestPthread006(void); // pthread测试函数6
extern void ItTestPthread007(void); // pthread测试函数7
extern void ItTestPthread008(void); // pthread测试函数8
extern void ItTestPthread009(void); // pthread测试函数9
extern void ItTestPthread010(void); // pthread测试函数10
extern void ItTestPthread012(void); // 省略了11，可能是个错误或者遗漏
extern void ItTestPthread011(void); // pthread测试函数11
extern void ItTestPthread013(void); // pthread测试函数13
extern void ItTestPthread014(void); // pthread测试函数14
extern void ItTestPthread015(void); // pthread测试函数15
extern void ItTestPthread016(void); // pthread测试函数16
extern void ItTestPthread017(void); // pthread测试函数17
extern void ItTestPthread018(void); // pthread测试函数18
extern void ItTestPthread019(void); // pthread测试函数19
extern void ItTestPthread020(void); // pthread测试函数20
extern void ItTestPthread021(void); // pthread测试函数21
extern void ItTestPthread022(void); // pthread测试函数22
extern void ItTestPthread023(void); // pthread测试函数23
extern void ItTestPthread024(void); // pthread测试函数24
extern void ItTestPthread025(void); // pthread测试函数25
extern void ItTestPthread026(void); // pthread测试函数26
extern void ItTestPthread027(void); // pthread测试函数27
extern void ItTestPthreadAtfork001(void); // pthread atfork测试函数1
extern void ItTestPthreadAtfork002(void); // pthread atfork测试函数2
extern void ItTestPthreadOnce001(void); // pthread once测试函数1
extern void ItTestPthreadCond001(void); // pthread 条件变量测试函数1
extern void ItTestPthreadCond002(void); // pthread 条件变量测试函数2
extern void ItTestPthreadCond003(void); // pthread 条件变量测试函数3
extern void ItTestPthreadCond004(void); // pthread 条件变量测试函数4
#endif // 结束头文件保护
|
11 months ago |
 赵颢翔
|
5492542b81 |
代码
|
11 months ago |