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

Merge branch 'main' of https://bdgit.educoder.net/py6atlu3x/openharmonydocs

Browse Source 
# Conflicts:
#	kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_020.cpp
#	kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_022.cpp
#	kernel_liteos_a-master/testsuites/unittest/net/netdb/smoke/net_netdb_test_001.cpp
#	kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/process_pthread_test.cpp
main
wcr 7 months ago
parent ba78f4af13 1e2e1722f8
commit 2b84597fad
9 changed files with 891 additions and 237 deletions
Show Stats Download Patch File Download Diff File

175
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_020.cpp
Unescape View File

@ -29,7 +29,7 @@
*/
#include "lt_net_netdb.h"
// 引入头文件，包含了网络数据库相关的函数声明和宏定义。
// 引入头文件，包含了网络数据库相关的函数声明和宏定义。
static int GetNetEntTest(void)
{
@ -37,98 +37,193 @@ static int GetNetEntTest(void)
"link-local 169.254.0.0\n"
"example 192.168.1.0 network example-network\n"
"test1";
// 定义一个模拟的networks文件内容，包含网络名称和对应的地址。
// 定义一个模拟的networks文件内容，包含网络名称和对应的地址。
char *pathList[] = {"/etc/networks"};
// 定义networks文件的路径列表，这里只有一个路径指向系统的networks文件。
// 定义networks文件的路径列表，这里只有一个路径指向系统的networks文件。
char *streamList[] = {static_cast<char *>(network_file)};
// 定义模拟的networks文件流列表，这里将模拟的networks文件内容转换为char*类型。
// 定义模拟的networks文件流列表，这里将模拟的networks文件内容转换为char*类型。
int streamLen[] = {sizeof(network_file)};
// 定义模拟的networks文件流长度列表。
// 定义模拟的networks文件流长度列表。
const int file_number = 1;
// 定义文件数量。
// 定义文件数量。
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
// 调用PrepareFileEnv函数准备文件环境，模拟networks文件。
// 调用PrepareFileEnv函数准备文件环境，模拟networks文件。
if (flag != 0) {
RecoveryFileEnv(pathList, file_number);
return -1;
}
// 如果准备文件环境失败，则恢复原始文件环境并返回错误码。
// 如果准备文件环境失败，则恢复原始文件环境并返回错误码。
struct netent *se1 = nullptr;
struct netent *se2 = nullptr;
struct netent *se3 = nullptr;
se1 = getnetent();
// 调用getnetent函数获取networks数据库中的第一个网络条目。
// 调用getnetent函数获取networks数据库中的第一个网络条目。
ICUNIT_ASSERT_NOT_EQUAL(se1, nullptr, -1);
// 断言se1不为空，即getnetent成功。
// 断言se1不为空，即getnetent成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->n_name, "link-local", -1);
// 断言返回的网络名称与"link-local"相同。
// 断言返回的网络名称与"link-local"相同。
ICUNIT_ASSERT_EQUAL(se1->n_addrtype, AF_INET, -1);
// 断言返回的地址类型为AF_INET（IPv4）。
// 断言返回的地址类型为AF_INET（IPv4）。
ICUNIT_ASSERT_EQUAL(se1->n_net, inet_network("169.254.0.0"), -1);
// 断言返回的网络地址与"169.254.0.0"相同。
// 断言返回的网络地址与"169.254.0.0"相同。
ICUNIT_ASSERT_EQUAL(se1->n_aliases[0], nullptr, -1);
// 断言别名列表中的第一个别名为nullptr，表示别名列表结束。
// 断言别名列表中的第一个别名为nullptr，表示别名列表结束。
endnetent();
// 调用endnetent函数结束网络数据库的搜索。
// 调用endnetent函数结束网络数据库的搜索。
se2 = getnetent();
// 再次调用getnetent函数获取networks数据库中的第一个网络条目。
// 再次调用getnetent函数获取networks数据库中的第一个网络条目。
ICUNIT_ASSERT_NOT_EQUAL(se2, nullptr, -1);
// 断言se2不为空，即getnetent成功。
// 断言se2不为空，即getnetent成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->n_name, se2->n_name, -1);
// 断言返回的网络名称与之前相同。
// 断言返回的网络名称与之前相同。
ICUNIT_ASSERT_EQUAL(se1->n_addrtype, se2->n_addrtype, -1);
// 断言返回的地址类型与之前相同。
// 断言返回的地址类型与之前相同。
ICUNIT_ASSERT_EQUAL(se1->n_net, se2->n_net, -1);
// 断言返回的网络地址与之前相同。
// 断言返回的网络地址与之前相同。
setnetent(0);
// 调用setnetent函数设置网络数据库的搜索位置到开始。
// 调用setnetent函数设置网络数据库的搜索位置到开始。
se3 = getnetent();
// 调用getnetent函数获取networks数据库中的第一个网络条目。
// 调用getnetent函数获取networks数据库中的第一个网络条目。
ICUNIT_ASSERT_NOT_EQUAL(se3, nullptr, -1);
// 断言se3不为空，即getnetent成功。
// 断言se3不为空，即getnetent成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->n_name, se3->n_name, -1);
// 断言返回的网络名称与之前相同。
// 断言返回的网络名称与之前相同。
ICUNIT_ASSERT_EQUAL(se1->n_addrtype, se3->n_addrtype, -1);
// 断言返回的地址类型与之前相同。
// 断言返回的地址类型与之前相同。
ICUNIT_ASSERT_EQUAL(se1->n_net, se3->n_net, -1);
// 断言返回的网络地址与之前相同。
// 断言返回的网络地址与之前相同。
se1 = getnetent();
// 获取下一个网络条目。
// 获取下一个网络条目。
ICUNIT_ASSERT_NOT_EQUAL(se1, nullptr, -1);
// 断言se1不为空，即getnetent成功。
// 断言se1不为空，即getnetent成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->n_name, "example", -1);
// 断言返回的网络名称与"example"相同。
// 断言返回的网络名称与"example"相同。
ICUNIT_ASSERT_EQUAL(se1->n_addrtype, AF_INET, -1);
// 断言返回的地址类型为AF_INET（IPv4）。
// 断言返回的地址类型为AF_INET（IPv4）。
ICUNIT_ASSERT_EQUAL(se1->n_net, inet_network("192.168.1.0"), -1);
// 断言返回的网络地址与"192.168.1.0"相同。
// 断言返回的网络地址与"192.168.1.0"相同。
ICUNIT_ASSERT_STRING_EQUAL(se1->n_aliases[0], "network", -1);
// 断言别名列表中的第一个别名为"network"。
// 断言别名列表中的第一个别名为"network"。
ICUNIT_ASSERT_STRING_EQUAL(se1->n_aliases[1], "example-network", -1);
// 断言别名列表中的第二个别名为"example-network"。
// 断言别名列表中的第二个别名为"example-network"。
ICUNIT_ASSERT_EQUAL(se1->n_aliases[2], nullptr, -1);
// 断言别名列表中的第三个别名为nullptr，表示别名列表结束。
// 断言别名列表中的第三个别名为nullptr，表示别名列表结束。
se1 = getnetent();
// 获取下一个网络条目。
// 获取下一个网络条目。
ICUNIT_ASSERT_EQUAL(se1, nullptr, -1);
// 断言se1为空，即已经到达networks数据库的末尾。
// 断言se1为空，即已经到达networks数据库的末尾。
endnetent();
// 调用endnetent函数结束网络数据库的搜索。
// 调用endnetent函数结束网络数据库的搜索。
RecoveryFileEnv(pathList, file_number);
// 恢复原始文件环境。
// 恢复原始文件环境。
return ICUNIT_SUCCESS;
// 返回测试成功。
// 返回测试成功。
}
void NetNetDbTest020(void)
{
TEST_ADD_CASE(__FUNCTION__, GetNetEntTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
// 定义测试用例，将GetNetEntTest函数注册为一个测试案例。
以下是对这段代码的注释：
```cpp
/*
* opyright (c) 2021 - 2021, Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2020 - 2021 Huawei Device Co., Ltd. All rights reserved.
*
* 这部分是版权声明，指出代码的版权归属华为技术有限公司和华为设备有限公司，并且说明了代码在满足一定条件下的分发和使用权限。
*/
#include "lt_net_netdb.h"
// 引入 "lt_net_netdb.h" 头文件，可能包含了网络数据库相关的函数声明、结构体定义等。
static int GetNetEntTest(void)
{
char network_file[] = "# symbolic names for networks, see networks(5) for more information\n"
"link - local 169.254.0.0\n"
"example 192.168.1.0 network example - network\n"
"test1";
// 定义一个字符数组network_file，其中包含了一些网络相关的信息，看起来像是网络配置信息的示例内容。
char *pathList[] = {"/etc/networks"};
char *streamList[] = {static_cast<char *>(network_file)};
int streamLen[] = {sizeof(network_file)};
const int file_number = 1;
// 定义了一些与文件操作相关的数组和变量。
// pathList是一个字符串指针数组，包含要操作的文件路径。
// streamList是一个字符指针数组，这里将network_file转换为字符指针后放入其中。
// streamLen是一个整数数组，记录每个流（这里对应network_file）的长度。
// file_number表示文件的数量。
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
if (flag!= 0) {
RecoveryFileEnv(pathList, file_number);
return -1;
}
// 调用PrepareFileEnv函数来准备文件环境，如果返回值不为0（表示有错误），则调用RecoveryFileEnv进行文件环境的恢复，并返回 -1表示失败。
struct netent *se1 = nullptr;
struct netent *se2 = nullptr;
struct netent *se3 = nullptr;
// 定义三个指向netent结构体的指针，并初始化为nullptr，netent结构体可能用于存储网络相关的信息（例如网络名称、地址类型、网络地址等）。
se1 = getnetent();
ICUNIT_ASSERT_NOT_EQUAL(se1, nullptr, -1);
ICUNIT_ASSERT_STRING_EQUAL(se1->n_name, "link - local", -1);
ICUNIT_ASSERT_EQUAL(se1->n_addrtype, AF_INET, -1);
ICUNIT_ASSERT_EQUAL(se1->n_net, inet_network("169.254.0.0"), -1);
ICUNIT_ASSERT_EQUAL(se1->n_aliases[0], nullptr, -1);
// 调用getnetent函数获取网络相关信息，然后使用ICUNIT_ASSERT相关的宏进行断言。
// 确保se1不为nullptr，并且其名称为 "link - local"，地址类型为AF_INET，网络地址为 "169.254.0.0"，并且第一个别名（n_aliases[0]）为nullptr。
endnetent();
se2 = getnetent();
ICUNIT_ASSERT_NOT_EQUAL(se2, nullptr, -1);
ICUNIT_ASSERT_STRING_EQUAL(se1->n_name, se2->n_name, -1);
ICUNIT_ASSERT_EQUAL(se1->n_addrtype, se2->n_addrtype, -1);
ICUNIT_ASSERT_EQUAL(se1->n_net, se2->n_net, -1);
// 先调用endnetent函数，然后再次调用getnetent获取网络信息，然后进行断言，确保两次获取的网络信息在名称、地址类型和网络地址上相同。
setnetent(0);
se3 = getnetent();
ICUNIT_ASSERT_NOT_EQUAL(se3, nullptr, -1);
ICUNIT_ASSERT_STRING_EQUAL(se1->n_name, se3->n_name, -1);
ICUNIT_ASSERT_EQUAL(se1->n_addrtype, se3->n_addrtype, -1);
ICUNIT_ASSERT_EQUAL(se1->n_net, se3->n_net, -1);
// 调用setnetent函数设置网络数据库的读取位置（这里参数为0可能有特殊含义），然后获取网络信息并进行断言，确保与之前获取的信息在名称、地址类型和网络地址上相同。
se1 = getnetent();
ICUNIT_ASSERT_NOT_EQUAL(se1, nullptr, -1);
ICUNIT_ASSERT_STRING_EQUAL(se1->n_name, "example", -1);
ICUNIT_ASSERT_EQUAL(se1->n_addrtype, AF_INET, -1);
ICUNIT_ASSERT_EQUAL(se1->n_net, inet_network("192.168.1.0"), -1);
ICUNIT_ASSERT_STRING_EQUAL(se1->n_aliases[0], "network", -1);
ICUNIT_ASSERT_STRING_EQUAL(se1->n_aliases[1], "example - network", -1);
ICUNIT_ASSERT_EQUAL(se1->n_aliases[2], nullptr, -1);
// 再次调用getnetent获取网络信息，并进行一系列断言，确保获取到的网络信息的名称、地址类型、网络地址以及别名等信息符合预期。
se1 = getnetent();
ICUNIT_ASSERT_EQUAL(se1, nullptr, -1);
endnetent();
// 再次调用getnetent，期望获取到nullptr（表示已经到达网络信息的末尾），然后调用endnetent结束网络信息的读取。
RecoveryFileEnv(pathList, file_number);
return ICUNIT_SUCCESS;
// 调用RecoveryFileEnv进行文件环境的恢复操作，并返回ICUNIT_SUCCESS表示函数执行成功。
}
void NetNetDbTest020(void)
{
TEST_ADD_CASE(__FUNCTION__, GetNetEntTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
// 在NetNetDbTest020函数中，调用TEST_ADD_CASE宏，将当前函数名、GetNetEntTest函数以及一些测试相关的标记（如测试类型、协议类型、测试级别等）添加到测试用例中。
}
```
请注意，这里的ICUNIT_ASSERT相关的宏以及其他一些函数（如PrepareFileEnv、RecoveryFileEnv、inet_network等）的具体功能需要根据代码所在的更大的项目上下文来确定，如果有更多的头文件或者相关库的信息，能做出更精确的注释。

115
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_022.cpp
Unescape View File

@ -29,60 +29,139 @@
*/
#include "lt_net_netdb.h"
// 引入头文件，包含了网络数据库相关的函数声明和宏定义。
// 引入头文件，包含了网络数据库相关的函数声明和宏定义。
static int GetNetByAddrtTest(void)
{
char network_file[] = "# symbolic names for networks, see networks(5) for more information\n"
"link-local 169.254.0.0\n";
// 定义一个模拟的networks文件内容，包含网络名称和对应的地址。
// 定义一个模拟的networks文件内容，包含网络名称和对应的地址。
char *pathList[] = {"/etc/networks"};
// 定义networks文件的路径列表，这里只有一个路径指向系统的networks文件。
// 定义networks文件的路径列表，这里只有一个路径指向系统的networks文件。
char *streamList[] = {static_cast<char *>(network_file)};
// 定义模拟的networks文件流列表，这里将模拟的networks文件内容转换为char*类型。
// 定义模拟的networks文件流列表，这里将模拟的networks文件内容转换为char*类型。
int streamLen[] = {sizeof(network_file)};
// 定义模拟的networks文件流长度列表。
// 定义模拟的networks文件流长度列表。
const int file_number = 1;
// 定义文件数量。
// 定义文件数量。
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
// 调用PrepareFileEnv函数准备文件环境，模拟networks文件。
// 调用PrepareFileEnv函数准备文件环境，模拟networks文件。
if (flag != 0) {
RecoveryFileEnv(pathList, file_number);
return -1;
}
// 如果准备文件环境失败，则恢复原始文件环境并返回错误码。
// 如果准备文件环境失败，则恢复原始文件环境并返回错误码。
struct netent *se1 = nullptr;
struct netent *se2 = nullptr;
struct netent *se3 = nullptr;
se1 = getnetbyaddr(inet_network("169.254.0.0"), AF_INET);
// 使用getnetbyaddr函数根据网络地址"169.254.0.0"和地址族AF_INET获取netent结构体指针。
// 使用getnetbyaddr函数根据网络地址"169.254.0.0"和地址族AF_INET获取netent结构体指针。
ICUNIT_ASSERT_NOT_EQUAL(se1, nullptr, -1);
// 断言se1不为空，即getnetbyaddr成功。
// 断言se1不为空，即getnetbyaddr成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->n_name, "link-local", -1);
// 断言返回的网络名称与"link-local"相同。
// 断言返回的网络名称与"link-local"相同。
ICUNIT_ASSERT_EQUAL(se1->n_addrtype, AF_INET, -1);
// 断言返回的地址类型为AF_INET（IPv4）。
// 断言返回的地址类型为AF_INET（IPv4）。
ICUNIT_ASSERT_EQUAL(se1->n_net, inet_network("169.254.0.0"), -1);
// 断言返回的网络地址与"169.254.0.0"相同。
// 断言返回的网络地址与"169.254.0.0"相同。
se2 = getnetbyaddr(inet_network("169.254.0.1"), AF_INET);
// 尝试使用getnetbyaddr函数根据网络地址"169.254.0.1"和地址族AF_INET获取netent结构体指针，预期失败。
// 尝试使用getnetbyaddr函数根据网络地址"169.254.0.1"和地址族AF_INET获取netent结构体指针，预期失败。
ICUNIT_ASSERT_EQUAL(se2, nullptr, -1);
se3 = getnetbyaddr(inet_network("169.254.0.1"), AF_INET6);
// 尝试使用getnetbyaddr函数根据网络地址"169.254.0.1"和地址族AF_INET6获取netent结构体指针，预期失败。
// 尝试使用getnetbyaddr函数根据网络地址"169.254.0.1"和地址族AF_INET6获取netent结构体指针，预期失败。
ICUNIT_ASSERT_EQUAL(se3, nullptr, -1);
RecoveryFileEnv(pathList, file_number);
// 恢复原始文件环境。
// 恢复原始文件环境。
return ICUNIT_SUCCESS;
// 返回测试成功。
// 返回测试成功。
}
void NetNetDbTest022(void)
{
TEST_ADD_CASE(__FUNCTION__, GetNetByAddrtTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
// 定义测试用例，将GetNetByAddrtTest函数注册为一个测试案例。
以下是对这段代码的批注：
**一、头文件包含部分**
```cpp
include "lt_net_netdb.h"
```
- 这里存在语法错误，在C/C++ 中正确的头文件包含语法是`#include <lt_net_netdb.h>`（如果是系统头文件）或者`#include "lt_net_netdb.h"`（如果是自定义头文件），这里缺少`#`。
**二、函数`GetNetByAddrtTest`部分**
1. **变量定义部分**
- ```cpp
char network_file[] = "# symbolic names for networks, see networks(5) for more information\n"
"link - local 169.254.0.0";
```
- 这是定义一个字符数组`network_file`，用于存储网络相关的配置信息。这里看起来是在模拟一个网络配置文件中的部分内容。
- ```cpp
char *pathList[] = {"/etc/networks"};
char *streamList[] = {static_cast<char *>(network_file)};
int streamLen[] = {sizeof(network_file)};
const int file_number = 1;
```
- `pathList`是一个字符指针数组，只包含一个元素，指向网络配置文件的路径（这里是模拟的路径）。
- `streamList`是一个字符指针数组，将`network_file`转换为`char*`类型后存储，这可能是用于模拟从文件读取到的数据。
- `streamLen`是一个整数数组，存储`streamList`中对应元素的长度，这里只存储了`network_file`的长度。
- `file_number`定义了文件的数量，这里设置为1。
2. **文件环境准备部分**
- ```cpp
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
if (flag!= 0) {
RecoveryFileEnv(pathList, file_number);
return - 1;
}
```
- 调用`PrepareFileEnv`函数来准备文件环境，根据函数名推测可能是进行一些文件相关的初始化或者数据准备工作。如果这个函数返回非零值，表示出现错误，那么调用`RecoveryFileEnv`函数进行文件环境的恢复操作，并返回 -1，表示函数执行失败。但是代码中没有给出`PrepareFileEnv`和`RecoveryFileEnv`函数的定义，不清楚具体的功能实现。
3. **网络查询部分**
- ```cpp
struct netent *se1 = nullptr;
struct netent *se2 = nullptr;
struct netent *se3 = nullptr;
```
- 定义了三个`netent`结构的指针，用于存储网络相关的查询结果。`netent`结构通常用于存储网络相关的信息，如网络名称、网络地址类型等。
- ```cpp
se1 = getnetbyaddr(inet_network("169.254.0.0"), AF_INET);
ICUNIT_ASSERT_NOT_EQUAL(se1, nullptr, -1);
ICUNIT_ASSERT_STRING_EQUAL(se1->n_name, "link - local", -1);
ICUNIT_ASSERT_EQUAL(se1->n_addrtype, AF_INET, -1);
ICUNIT_ASSERT_EQUAL(se1->n_net, inet_network("169.254.0.0"), -1);
```
- 调用`getnetbyaddr`函数根据给定的网络地址（这里先将字符串形式的地址`169.254.0.0`通过`inet_network`函数转换为网络地址格式）查询网络信息，并将结果存储在`se1`中。然后使用`ICUNIT_ASSERT_*`系列的宏进行断言操作。
- 如果`se1`为`nullptr`，则表示查询失败，会根据`ICUNIT_ASSERT_NOT_EQUAL`宏的逻辑进行处理（这里不清楚`ICUNIT_ASSERT_NOT_EQUAL`宏的具体实现，但从名字看是判断两个值不相等）。
- 接着通过`ICUNIT_ASSERT_STRING_EQUAL`判断查询到的网络名称是否为`link - local`，通过`ICUNIT_ASSERT_EQUAL`判断地址类型和网络地址是否符合预期。
- ```cpp
se2 = getnetbyaddr(inet_network("169.254.0.1"), AF_INET);
ICUNIT_ASSERT_EQUAL(se2, nullptr, -1);
```
- 类似地，查询地址`169.254.0.1`的网络信息，由于这个地址可能不存在或者不符合查询条件（根据代码逻辑推测），所以这里断言查询结果应该为`nullptr`。
- ```cpp
se3 = getnetbyaddr(inet_network("169.254.0.1"), AF_INET6);
ICUNIT_ASSERT_EQUAL(se3, nullptr, -1);
```
- 这里查询`169.254.0.1`的网络信息，但是使用`AF_INET6`（IPv6地址类型），同样根据代码逻辑推测这个查询应该返回`nullptr`，并使用断言进行验证。
4. **文件环境恢复部分**
- ```cpp
RecoveryFileEnv(pathList, file_number);
return ICUNIT_SUCCESS;
```
- 在完成网络查询操作后，调用`RecoveryFileEnv`函数恢复文件环境，最后返回`ICUNIT_SUCCESS`（不清楚`ICUNIT_SUCCESS`的具体定义，但从名字看是表示函数执行成功）。
**三、函数`NetNetDbTest022`部分**
```cpp
void NetNetDbTest022(void)
{
TEST_ADD_CASE(__FUNCTION__, GetNetByAddrtTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
```
- 这个函数看起来是一个测试用例注册函数，将`GetNetByAddrtTest`函数注册为一个测试用例，并且指定了一些测试相关的属性，如`TEST_POSIX`、`TEST_TCP`、`TEST_LEVEL0`、`TEST_FUNCTION`（这里不清楚这些属性的具体含义，需要根据测试框架的定义来确定）。

66
kernel_liteos_a-master/testsuites/unittest/net/netdb/smoke/net_netdb_test_001.cpp
Unescape View File

@ -2,45 +2,73 @@
* Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
*
* 这部分版权信息说明了华为技术有限公司（或其子公司）是这段代码的版权持有者，
* 并规定了代码的重新分发和使用条件。
* 这部分版权信息说明了华为技术有限公司（或其子公司）是这段代码的版权持有者，
* 并规定了代码的重新分发和使用条件。
*/
#include "lt_net_netdb.h" // 包含测试所需的网络数据库头文件
#include "lt_net_netdb.h" // 包含测试所需的网络数据库头文件
// 定义一个测试函数，用于测试协议数据库的功能
// 定义一个测试函数，用于测试协议数据库的功能
static int ProtoentTest(void)
{
setprotoent(1); // 打开协议数据库文件，参数1表示重置文件指针到文件开始
setprotoent(1); // 打开协议数据库文件，参数1表示重置文件指针到文件开始
// 引用/etc/protocols文件，获取名为"icmp"的协议条目
// 引用/etc/protocols文件，获取名为"icmp"的协议条目
struct protoent *prot = getprotobyname("icmp");
// 断言：确保获取到的协议条目不为空
// 断言：确保获取到的协议条目不为空
ICUNIT_ASSERT_NOT_EQUAL(prot, NULL, -1);
// 断言：确保获取到的协议编号是1（ICMP协议的编号）
// 断言：确保获取到的协议编号是1（ICMP协议的编号）
ICUNIT_ASSERT_EQUAL(prot->p_proto, 1, prot->p_proto);
// 获取编号为1的协议条目（也是ICMP协议）
// 获取编号为1的协议条目（也是ICMP协议）
prot = getprotobynumber(1);
// 断言：确保获取到的协议条目不为空
// 断言：确保获取到的协议条目不为空
ICUNIT_ASSERT_NOT_EQUAL(prot, NULL, -1);
// 断言：确保获取到的协议名称是"icmp"
ICUNIT_ASSERT_EQUAL(strcmp(prot->p_name, "icmp"), 0, -1); // strcmp返回0表示字符串相等
// 断言：确保获取到的协议名称是"icmp"
ICUNIT_ASSERT_EQUAL(strcmp(prot->p_name, "icmp"), 0, -1); // strcmp返回0表示字符串相等
// 获取协议数据库中的下一个协议条目
// 获取协议数据库中的下一个协议条目
prot = getprotoent();
// 断言：确保获取到的协议条目不为空
// 断言：确保获取到的协议条目不为空
ICUNIT_ASSERT_NOT_EQUAL(prot, NULL, -1);
// 关闭协议数据库文件
// 关闭协议数据库文件
endprotoent();
// 返回测试成功标志
// 返回测试成功标志
return ICUNIT_SUCCESS;
}
// 定义一个测试注册函数，用于将ProtoentTest测试添加到测试套件中
// 定义一个测试注册函数，用于将ProtoentTest测试添加到测试套件中
void NetNetDbTest001(void)
{
// 添加测试用例到测试框架中，包括测试用例名称、测试函数、测试类别、测试协议、测试级别和测试类型
// 添加测试用例到测试框架中，包括测试用例名称、测试函数、测试类别、测试协议、测试级别和测试类型
TEST_ADD_CASE(__FUNCTION__, ProtoentTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
}
以下是对这段代码的批注：
一、整体功能概述 这段代码看起来是一个测试相关的代码片段，
主要是针对网络数据库（netdb）中的协议相关操作进行测试。
二、函数ProtoentTest 头文件包含 #include "ltnetnetdb.h"：
引入了一个自定义的头文件，可能包含与网络数据库操作相关的结构体定义、函数声明等内容。
函数定义与作用 static int ProtoentTest(void)：这是一个静态函数，可能意味着这个函数仅在当前源文件内可见。
它的目的是测试与协议相关的网络数据库操作。 协议相关操作 setprotoent(1)：
这个函数调用可能是用来设置协议数据库（protocols）的读取位置或者打开协议数据库。
参数1可能有特定的含义，也许表示某种读取模式或者重置操作。
struct protoent *prot = getprotobyname("icmp");
尝试根据协议名称（这里是icmp）从协议数据库中获取对应的协议信息结构体指针。
后续的ICUNITASSERTNOT_EQUAL(prot, NULL, -1);是一个断言操作，用于检查是否成功获取到协议信息。
如果prot为NULL，则表示获取失败，可能会触发相应的错误处理（这里通过断言的方式）。
ICUNITASSERTEQUAL(prot->pproto, 1, prot->pproto);：
这个断言可能是检查获取到的协议信息中的协议号是否符合预期（这里预期是1）。
prot = getprotobynumber(1); 根据协议号（这里是1）从协议数据库中获取协议信息结构体指针。
同样有后续的断言操作ICUNITASSERTNOTEQUAL(prot, NULL, -1);
和ICUNITASSERTEQUAL(strcmp(prot->pname, "icmp"), 0, -1);，
前者检查是否成功获取，后者检查获取到的协议名称是否为icmp。
prot = getprotoent(); 再次从协议数据库中获取下一个协议信息结构体指针。
并进行ICUNITASSERTNOT_EQUAL(prot, NULL, -1);断言检查是否获取成功。
endprotoent();：这个函数调用可能是用于关闭协议数据库或者释放相关资源。
return ICUNITSUCCESS;：函数最终返回一个表示成功的常量（这里ICUNITSUCCESS可能是自定义的表示成功的标志）。
三、函数NetNetDbTest001
void NetNetDbTest001(void)：这个函数看起来是一个测试用例的组织函数。
TESTADDCASE(FUNCTION, ProtoentTest, TESTPOSIX, TESTTCP, TESTLEVEL0, TESTFUNCTION);：
这行代码可能是将ProtoentTest函数添加到一个测试框架中的操作。FUNCTION可能是当前函数名（NetNetDbTest001），
后面的参数TESTPOSIX、TESTTCP、TESTLEVEL0、TESTFUNCTION可能是与测试用例的属性、类型、级别等相关的标记。

115
kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/it_pthread_test.h
Unescape View File

@ -28,65 +28,70 @@
* 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
#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)
#include "sys/syscall.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;
register int reg3 __asm__("r3") = parm4;
register int reg2 __asm__("r2") = parm3;
register int reg1 __asm__("r1") = parm2;
register int reg0 __asm__("r0") = parm1;
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;
return reg0; // 返回系统调用的结果
}
// 声明全局变量，用于存储单元测试的错误码和错误行号
extern INT32 g_iCunitErrCode;
extern INT32 g_iCunitErrLineNo;
extern void ItTestPthread001(void);
extern void ItTestPthread002(void);
extern void ItTestPthread003(void);
extern void ItTestPthread004(void);
extern void ItTestPthread005(void);
extern void ItTestPthread006(void);
extern void ItTestPthread007(void);
extern void ItTestPthread008(void);
extern void ItTestPthread009(void);
extern void ItTestPthread010(void);
extern void ItTestPthread012(void);
extern void ItTestPthread011(void);
extern void ItTestPthread013(void);
extern void ItTestPthread014(void);
extern void ItTestPthread015(void);
extern void ItTestPthread016(void);
extern void ItTestPthread017(void);
extern void ItTestPthread018(void);
extern void ItTestPthread019(void);
extern void ItTestPthread020(void);
extern void ItTestPthread021(void);
extern void ItTestPthread022(void);
extern void ItTestPthread023(void);
extern void ItTestPthread024(void);
extern void ItTestPthread025(void);
extern void ItTestPthread026(void);
extern void ItTestPthread027(void);
extern void ItTestPthreadAtfork001(void);
extern void ItTestPthreadAtfork002(void);
extern void ItTestPthreadOnce001(void);
extern void ItTestPthreadCond001(void);
extern void ItTestPthreadCond002(void);
extern void ItTestPthreadCond003(void);
extern void ItTestPthreadCond004(void);
#endif
// 声明一系列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 // 结束头文件保护

471
kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/process_pthread_test.cpp
Unescape View File

@ -28,71 +28,71 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// 包含标准输入输出头文件
// 包含标准输入输出头文件
#include "stdio.h"
// 包含C标准库中的极限定义
// 包含C标准库中的极限定义
#include <climits>
// 包含Google Test测试框架头文件
// 包含Google Test测试框架头文件
#include <gtest/gtest.h>
// 包含自定义的pthread测试头文件
// 包含自定义的pthread测试头文件
#include "it_pthread_test.h"
// 包含系统资源库头文件
// 包含系统资源库头文件
#include <sys/resource.h>
// 使用Google Test框架的扩展命名空间
// 使用Google Test框架的扩展命名空间
using namespace testing::ext;
// 定义一个名为OHOS的命名空间，用于封装测试代码
// 定义一个名为OHOS的命名空间，用于封装测试代码
namespace OHOS {
// 定义一个测试类ProcessPthreadTest，它继承自Google Test框架的Test类
// 定义一个测试类ProcessPthreadTest，它继承自Google Test框架的Test类
class ProcessPthreadTest : public testing::Test {
public:
// 测试套件开始前调用的静态成员函数，用于设置测试环境
// 测试套件开始前调用的静态成员函数，用于设置测试环境
static void SetUpTestCase(void) {
struct sched_param param = { 0 }; // 定义调度参数结构体
int currThreadPolicy, ret; // 定义当前线程策略和返回值变量
// 获取当前线程的调度参数
struct sched_param param = { 0 }; // 定义调度参数结构体
int currThreadPolicy, ret; // 定义当前线程策略和返回值变量
// 获取当前线程的调度参数
ret = pthread_getschedparam(pthread_self(), &currThreadPolicy, &param);
// 断言返回值为0，如果不为0则用-ret作为错误码
// 断言返回值为0，如果不为0则用-ret作为错误码
ICUNIT_ASSERT_EQUAL_VOID(ret, 0, -ret);
// 设置线程的调度优先级
// 设置线程的调度优先级
param.sched_priority = TASK_PRIO_TEST;
// 设置当前线程的调度参数
// 设置当前线程的调度参数
ret = pthread_setschedparam(pthread_self(), SCHED_RR, &param);
// 断言返回值为0，如果不为0则用-ret作为错误码
// 断言返回值为0，如果不为0则用-ret作为错误码
ICUNIT_ASSERT_EQUAL_VOID(ret, 0, -ret);
}
// 测试套件结束后调用的静态成员函数，用于清理测试环境（这里为空实现）
// 测试套件结束后调用的静态成员函数，用于清理测试环境（这里为空实现）
static void TearDownTestCase(void) {}
};
#if defined(LOSCFG_USER_TEST_SMOKE)
// 如果定义了LOSCFG_USER_TEST_SMOKE，则编译并执行以下测试用例
// 如果定义了LOSCFG_USER_TEST_SMOKE，则编译并执行以下测试用例
/* *
* @tc.name: it_test_pthread_003
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
// 定义测试用例ItTestPthread003
// 定义测试用例ItTestPthread003
HWTEST_F(ProcessPthreadTest, ItTestPthread003, TestSize.Level0) {
ItTestPthread003();
}
#endif
#ifndef LOSCFG_USER_TEST_SMP
// 如果未定义LOSCFG_USER_TEST_SMP，则编译并执行以下测试用例
// 如果未定义LOSCFG_USER_TEST_SMP，则编译并执行以下测试用例
/* *
* @tc.name: it_test_pthread_006
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
// 定义测试用例ItTestPthread006
// 定义测试用例ItTestPthread006
HWTEST_F(ProcessPthreadTest, ItTestPthread006, TestSize.Level0) {
ItTestPthread006();
}
#endif
// 以下是其他测试用例的定义，每个测试用例都有相应的注释说明其功能和类型
// 以下是其他测试用例的定义，每个测试用例都有相应的注释说明其功能和类型
/* *
* @tc.name: it_test_pthread_007
* @tc.desc: function for ProcessPthreadTest
@ -234,4 +234,429 @@ HWTEST_F(ProcessPthreadTest, ItTestPthread022, TestSize.Level0) {
* @tc.require: issueI6T3P3
* @tc.author:
*/
HWTEST_F(ProcessPthreadTest, ItTestP
HWTEST_F(ProcessPthreadTest, ItTestP/*
* 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 "stdio.h" // 引入标准输入输出头文件
#include <climits> // 引入字符类型限制头文件
#include <gtest/gtest.h> // 引入google测试框架头文件
#include "it_pthread_test.h" // 引入自定义的pthread测试头文件
#include <sys/resource.h> // 引入系统资源头文件
using namespace testing::ext; // 使用google测试框架的扩展命名空间
namespace OHOS { // 定义OHOS命名空间
class ProcessPthreadTest : public testing::Test { // 定义一个继承自testing::Test的测试类
public:
static void SetUpTestCase(void) // 静态成员函数，用于在所有测试开始前执行
{
struct sched_param param = { 0 }; // 定义一个sched_param结构体并初始化为0
int currThreadPolicy, ret; // 定义当前线程策略和返回值变量
ret = pthread_getschedparam(pthread_self(), &currThreadPolicy, &param); // 获取当前线程的调度参数
ICUNIT_ASSERT_EQUAL_VOID(ret, 0, -ret); // 使用自定义宏断言返回值是否为0
param.sched_priority = TASK_PRIO_TEST; // 设置调度优先级为TASK_PRIO_TEST（未在代码中定义）
ret = pthread_setschedparam(pthread_self(), SCHED_RR, &param); // 设置当前线程的调度策略和参数
ICUNIT_ASSERT_EQUAL_VOID(ret, 0, -ret); // 使用自定义宏断言返回值是否为0
}
static void TearDownTestCase(void) {} // 静态成员函数，用于在所有测试结束后执行，此处为空实现
};
#if defined(LOSCFG_USER_TEST_SMOKE) // 如果定义了LOSCFG_USER_TEST_SMOKE宏
/* *
* @tc.name: it_test_pthread_003
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread003, TestSize.Level0) // 定义一个测试用例
{
ItTestPthread003(); // 调用ItTestPthread003函数（未在代码中定义）
}
#ifndef LOSCFG_USER_TEST_SMP // 如果没有定义LOSCFG_USER_TEST_SMP宏
/* *
* @tc.name: it_test_pthread_006
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread006, TestSize.Level0) // 定义一个测试用例
{
ItTestPthread006(); // 调用ItTestPthread006函数（未在代码中定义）
}
#endif
/* *
* @tc.name: it_test_pthread_007
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread007, TestSize.Level0) // 定义一个测试用例
{
ItTestPthread007(); // 调用ItTestPthread007函数（未在代码中定义）
}
/* *
* @tc.name: it_test_pthread_008
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread008, TestSize.Level0) // 定义一个测试用例
{
ItTestPthread008(); // 调用ItTestPthread008函数（未在代码中定义）
}
/* *
* @tc.name: it_test_pthread_009
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread009, TestSize.Level0) // 定义一个测试用例
{
ItTestPthread009(); // 调用ItTestPthread009函数（未在代码中定义）
}
#ifndef LOSCFG_USER_TEST_SMP // 如果没有定义LOSCFG_USER_TEST_SMP宏
/* *
* @tc.name: it_test_pthread_010
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread010, TestSize.Level0) // 定义一个测试用例
{
ItTestPthread010(); // 调用ItTestPthread010函数（未在代码中定义）
}
#endif
/* *
* @tc.name: it_test_pthread_011
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread011, TestSize.Level0) // 定义一个测试用例
{
ItTestPthread011(); // 调用ItTestPthread011函数（未在代码中定义）
}
/* *
* @tc.name: it_test_pthread_012
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread012, TestSize.Level0) // 定义一个测试用例
{
ItTestPthread012(); // 调用ItTestPthread012函数（未在代码中定义）
}
/* *
* @tc.name: it_test_pthread_013
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread013, TestSize.Level0) // 定义一个测试用例
{
ItTestPthread013(); // 调用ItTestPthread013函数（未在代码中定义）
}
/* *
* @tc.name: it_test_pthread_015
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread015, TestSize.Level0) // 定义一个测试用例
{
ItTestPthread015(); // 调用ItTestPthread015函数（未在代码中定义）
}
/* *
* @tc.name: it_test_pthread_016
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread016, TestSize.Level0) // 定义一个测试用例
{
ItTestPthread016(); // 调用ItTestPthread016函数（未在代码中定义）
}
/* *
* @tc.name: it_test_pthread_018
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread018, TestSize.Level0) // 定义一个测试用例
{
ItTestPthread018(); // 调用ItTestPthread018函数（未在代码中定义）
}
/* *
* @tc.name: it_test_pthread_019
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread019, TestSize.Level0) // 定义一个测试用例
{
ItTestPthread019(); // 调用ItTestPthread019函数（未在代码中定义）
}
/* *
* @tc.name: it_test_pthread_020
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
* @tc.require: issueI6T3P3
* @tc.author:
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread020, TestSize.Level0) // 定义一个测试用例
{
ItTestPthread020(); // 调用ItTestPthread020函数（未在代码中定义）
}
/* *
* @tc.name: it_test_pthread_021
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
* @tc.require: issueI6T3P3
* @tc.author:
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread021, TestSize.Level0)
{
ItTestPthread021();
}
/* *
* @tc.name: it_test_pthread_022
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
* @tc.require: issueI6T3P3
* @tc.author:
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread022, TestSize.Level0)
{
ItTestPthread022();
}
/* *
* @tc.name: it_test_pthread_024
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
* @tc.require: issueI6T3P3
* @tc.author:
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread024, TestSize.Level0)
{
ItTestPthread024();
}
/* *
* @tc.name: it_test_pthread_026
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
* @tc.require: issueI6T3P3
* @tc.author:
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread026, TestSize.Level0)
{
ItTestPthread026();
}
/* *
* @tc.name: it_test_pthread_027
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
* @tc.require: issueI6T3P3
* @tc.author:
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread027, TestSize.Level0)
{
ItTestPthread027();
}
/* *
* @tc.name: it_test_pthread_023
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
* @tc.require: issueI6T3P3
* @tc.author:
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread023, TestSize.Level0)
{
ItTestPthread023();
}
/* *
* @tc.name: it_test_pthread_025
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
* @tc.require: issueI6T3P3
* @tc.author:
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread025, TestSize.Level0)
{
ItTestPthread025();
}
/* *
* @tc.name: it_test_pthread_017
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread017, TestSize.Level0)
{
ItTestPthread017();
}
/* *
* @tc.name: it_test_pthread_once_001
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthreadOnce001, TestSize.Level0)
{
ItTestPthreadOnce001();
}
/* *
* @tc.name: it_test_pthread_atfork_001
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthreadAtfork001, TestSize.Level0)
{
ItTestPthreadAtfork001();
}
/* *
* @tc.name: it_test_pthread_atfork_002
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthreadAtfork002, TestSize.Level0)
{
ItTestPthreadAtfork002();
}
/* *
* @tc.name: it_test_pthread_cond_001
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthreadCond001, TestSize.Level0)
{
ItTestPthreadCond001();
}
/* *
* @tc.name: it_test_pthread_cond_002
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthreadCond002, TestSize.Level0)
{
ItTestPthreadCond002();
}
/* *
* @tc.name: it_test_pthread_cond_003
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthreadCond003, TestSize.Level0)
{
ItTestPthreadCond003();
}
/* *
* @tc.name: it_test_pthread_cond_004
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthreadCond004, TestSize.Level0)
{
ItTestPthreadCond004();
}
#endif
#if defined(LOSCFG_USER_TEST_FULL)
/* *
* @tc.name: it_test_pthread_001
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread001, TestSize.Level0)
{
ItTestPthread001();
}
#ifndef LOSCFG_USER_TEST_SMP
/* *
* @tc.name: it_test_pthread_002
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread002, TestSize.Level0)
{
ItTestPthread002();
}
#endif
/* *
* @tc.name: it_test_pthread_004
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread004, TestSize.Level0)
{
ItTestPthread004();
}
/* *
* @tc.name: it_test_pthread_005
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread005, TestSize.Level0)
{
ItTestPthread005();
}
#ifndef LOSCFG_USER_TEST_SMP
/* *
* @tc.name: it_test_pthread_014
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread014, TestSize.Level0)
{
ItTestPthread014();
}
#endif
#endif
} // namespace OHOS

2
kernel_liteos_a-master/testsuites/unittest/process/basic/pthread/smoke/pthread_atfork_test_001.cpp
Unescape View File

@ -28,7 +28,7 @@
* 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"
#include "it_pthread_test.h"
static volatile int g_count = 0;
static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;

14
kernel_liteos_a-master/testsuites/unittest/process/plimits/smoke/It_process_plimits_008.cpp
Unescape View File

@ -38,13 +38,14 @@
#include <cstring>
#include "It_process_plimits.h"
//write function to get process file mode
static std::string GetFileMode(const char* filePath)
{
const int MODE_COUNT = 11;
char fileProperty[MODE_COUNT] = "----------";
char fileMode[MODE_COUNT] = "-rwxrwxrwx";
struct stat buf;
stat(filePath, &buf);
stat(filePath, &buf);//get state of the file
unsigned int off = 256;
const int LOOP_VARY = 10;
for (int i = 1; i < LOOP_VARY; i++) {
@ -55,6 +56,7 @@ static std::string GetFileMode(const char* filePath)
return fileProperty;
}
//check the Property
static int IsFilePropertyR1(const char* filePath)
{
std::string fileOrg = "-r--r--r--";
@ -64,6 +66,7 @@ static int IsFilePropertyR1(const char* filePath)
void ItProcessPlimits008(void)
{
//define process function ID
std::string filePath = "/proc/plimits/";
std::vector<std::string> fileName;
fileName.push_back("plimits.procs");
@ -86,3 +89,12 @@ void ItProcessPlimits008(void)
return;
}
/*It is used primarily to verify access to specific files in
the /proc/plimit/directory, ensuring that these files are read-only
*/

170
kernel_liteos_a-master/testsuites/unittest/security/capability/smoke/cap_test_001.cpp
Unescape View File

@ -28,68 +28,74 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "pthread.h"
#include "linux/capability.h"
#include <sys/capability.h>
#include "it_test_capability.h"
#include <signal.h>
#include <sys/types.h>
#include <time.h>
#define CAP_NUM 2
#define INVAILD_PID 65535
#define CHANGE_CHILD_UID 1000
#include "pthread.h" // 引入POSIX线程库，用于多线程编程
#include "linux/capability.h" // 引入Linux能力（capabilities）定义，用于权限控制
#include <sys/capability.h> // 引入系统能力接口
#include "it_test_capability.h" // 假设是测试框架或测试相关的头文件
#include <signal.h> // 引入信号处理函数
#include <sys/types.h> // 引入基本数据类型
#include <time.h> // 引入时间处理函数
#define CAP_NUM 2 // 定义能力数组的大小
#define INVAILD_PID 65535 // 定义一个无效的进程ID
#define CHANGE_CHILD_UID 1000 // 定义子进程要更改的用户ID
// 信号处理函数，当前为空实现
static void Sigac(int param)
{
return;
}
// 子进程函数
static void Child()
{
int i = 10;
signal(25, Sigac);
while (i--) {
int i = 10; // 循环计数器
signal(25, Sigac); // 设置信号25的处理函数为Sigac
while (i--) { // 循环10次，每次睡眠1秒
sleep(1);
}
// 睡眠10秒后退出
exit(0);
}
// 测试子进程的函数
static int TestChild(VOID)
{
struct __user_cap_header_struct capheader;
struct __user_cap_data_struct capdata[CAP_NUM];
struct __user_cap_data_struct capdatac[CAP_NUM];
struct timespec tp;
int ret;
(void)memset_s(&capheader, sizeof(struct __user_cap_header_struct), 0, sizeof(struct __user_cap_header_struct));
(void)memset_s(capdata, CAP_NUM * sizeof(struct __user_cap_data_struct), 0,
CAP_NUM * sizeof(struct __user_cap_data_struct));
capdata[0].permitted = 0xffffffff;
capdata[1].permitted = 0xffffffff;
capheader.version = _LINUX_CAPABILITY_VERSION_3;
capdata[CAP_TO_INDEX(CAP_SYS_NICE)].effective |= CAP_TO_MASK(CAP_SETPCAP);
capdata[CAP_TO_INDEX(CAP_SYS_NICE)].effective |= CAP_TO_MASK(CAP_SETUID);
capdata[CAP_TO_INDEX(CAP_SYS_NICE)].effective |= CAP_TO_MASK(CAP_KILL);
capdata[CAP_TO_INDEX(CAP_SYS_NICE)].effective |= CAP_TO_MASK(CAP_SYS_TIME);
capdata[CAP_TO_INDEX(CAP_SYS_NICE)].effective |= CAP_TO_MASK(CAP_SYS_NICE);
ret = capset(&capheader, &capdata[0]);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ret = capget(&capheader, &capdatac[0]);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
capheader.pid = INVAILD_PID;
ret = capget(&capheader, &capdatac[0]);
ICUNIT_ASSERT_EQUAL(ret, -1, ret);
errno = 0;
capheader.pid = 3;
kill(capheader.pid, 0);
if (errno != ESRCH) {
ret = capget(&capheader, &capdatac[0]);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
printf("e %d,p %d\n", capdatac[0].effective, capdatac[0].permitted);
struct __user_cap_header_struct capheader; // 定义能力头部结构体
struct __user_cap_data_struct capdata[CAP_NUM]; // 定义能力数据结构体数组
struct __user_cap_data_struct capdatac[CAP_NUM]; // 定义另一个能力数据结构体数组，用于获取当前能力
struct timespec tp; // 定义时间结构体
int ret; // 定义返回值变量，此处漏写了初始化
// 初始化结构体
(void)memset_s(&capheader, sizeof(struct __user_cap_header_struct), 0, sizeof(struct __user_cap_header_struct)); // 清零能力头部结构体
(void)memset_s(capdata, CAP_NUM * sizeof(struct __user_cap_data_struct), 0, CAP_NUM * sizeof(struct __user_cap_data_struct)); // 清零能力数据结构体数组
capdata[0].permitted = 0xffffffff; // 设置允许的所有能力为全开
capdata[1].permitted = 0xffffffff; // 同上，第二个数据结构体也全开（虽然只用一个）
capheader.version = _LINUX_CAPABILITY_VERSION_3; // 设置能力版本
// 设置能力的有效位
capdata[CAP_TO_INDEX(CAP_SYS_NICE)].effective |= CAP_TO_MASK(CAP_SETPCAP); // 允许修改进程能力
capdata[CAP_TO_INDEX(CAP_SYS_NICE)].effective |= CAP_TO_MASK(CAP_SETUID); // 允许改变用户ID
capdata[CAP_TO_INDEX(CAP_SYS_NICE)].effective |= CAP_TO_MASK(CAP_KILL); // 允许发送信号
capdata[CAP_TO_INDEX(CAP_SYS_NICE)].effective |= CAP_TO_MASK(CAP_SYS_TIME); // 允许改变系统时间
capdata[CAP_TO_INDEX(CAP_SYS_NICE)].effective |= CAP_TO_MASK(CAP_SYS_NICE); // 允许改变调度优先级
// 使用capset设置能力并检查返回值
ret = capset(&capheader, &capdata[0]);
ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 断言capset返回0，表示成功
ret = capget(&capheader, &capdatac[0]); // 获取当前能力
ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 断言capget返回0，表示成功
capheader.pid = INVAILD_PID; // 设置一个无效的PID
ret = capget(&capheader, &capdatac[0]); // 尝试获取无效PID的能力
ICUNIT_ASSERT_EQUAL(ret, -1, ret); // 断言返回-1，表示失败
errno = 0; // 重置errno
capheader.pid = 3; // 设置PID为3
kill(capheader.pid, 0); // 检查PID是否存在
if (errno != ESRCH) { // 如果PID存在
ret = capget(&capheader, &capdatac[0]); // 获取能力
ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 断言成功
printf("e %d,p %d\n", capdatac[0].effective, capdatac[0].permitted); // 打印有效和允许的能力
}
// 类似地，检查PID 4, 5, 6
errno = 0;
capheader.pid = 4;
kill(capheader.pid, 0);
@ -114,39 +120,42 @@ static int TestChild(VOID)
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
printf("e %d,p %d\n", capdatac[0].effective, capdatac[0].permitted);
}
capheader.pid = 0;
int pid = fork();
if (pid == 0) {
ret = setuid(CHANGE_CHILD_UID);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
Child();
capheader.pid = 0; // 重置PID为0（当前进程）
// 尝试重置子进程的UID
int pid = fork(); // 创建子进程
if (pid == 0) { // 如果是子进程
ret = setuid(CHANGE_CHILD_UID); // 尝试改变用户ID
ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 断言成功
Child(); // 执行子进程函数
}
sleep(1);
ret = kill(pid, SIGXFSZ);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
sleep(1); // 父进程等待1秒
ret = kill(pid, SIGXFSZ); // 尝试发送SIGXFSZ信号给子进程
ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 断言成功
// 移除KILL能力并再次尝试发送信号，应该失败
capdata[CAP_TO_INDEX(CAP_SYS_NICE)].effective &= ~CAP_TO_MASK(CAP_KILL);
ret = capset(&capheader, &capdata[0]);
ret = kill(pid, SIGXFSZ);
ICUNIT_ASSERT_EQUAL(ret, -1, ret);
tp.tv_sec = 0;
tp.tv_nsec = 0;
ret = clock_settime(CLOCK_REALTIME, &tp);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
capdata[CAP_TO_INDEX(CAP_SYS_NICE)].effective &= ~CAP_TO_MASK(CAP_SYS_TIME);
ret = capset(&capheader, &capdata[0]);
ret = clock_settime(CLOCK_REALTIME, &tp);
ICUNIT_ASSERT_EQUAL(ret, -1, ret);
struct sched_param param = { 0 };
ret = sched_getparam(pid, &param);
param.sched_priority--;
ret = sched_setparam(pid, &param);
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
capdata[CAP_TO_INDEX(CAP_SYS_NICE)].effective &= ~CAP_TO_MASK(CAP_SYS_NICE);
ret = capset(&capheader, &capdata[0]);
ret = sched_setparam(pid, &param);
ret = capset(&capheader, &capdata[0]); // 更新能力
ret = kill(pid, SIGXFSZ); // 再次尝试发送信号
ICUNIT_ASSERT_EQUAL(ret, -1, ret); // 断言失败
// 尝试设置系统时间，应该成功然后失败（移除SYS_TIME能力）
tp.tv_sec = 0; // 设置时间为0
tp.tv_nsec = 0; // 纳秒部分也设置为0
ret = clock_settime(CLOCK_REALTIME, &tp); // 尝试设置时间
ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 断言成功
capdata[CAP_TO_INDEX(CAP_SYS_NICE)].effective &= ~CAP_TO_MASK(CAP_SYS_TIME); // 移除SYS_TIME能力
ret = capset(&capheader, &capdata[0]); // 更新能力
ret = clock_settime(CLOCK_REALTIME, &tp); // 再次尝试设置时间
ICUNIT_ASSERT_EQUAL(ret, -1, ret); // 断言失败
// 尝试改变子进程的调度优先级，应该成功然后失败（移除SYS_NICE能力）
struct sched_param param = { 0 }; // 定义调度参数结构体
ret = sched_getparam(pid, &param); // 获取当前调度参数
param.sched_priority--; // 降低优先级
ret = sched_setparam(pid, &param); // 尝试设置新的调度参数
ICUNIT_ASSERT_EQUAL(ret, 0, ret); // 断言成功
capdata[CAP_TO_INDEX(CAP_SYS_NICE)].effective &= ~CAP_TO_MASK(CAP_SYS_NICE); // 移除SYS_NICE能力
ret = capset(&capheader, &capdata[0]); // 更新能力
ret = sched_setparam(pid, &param); // 再次尝试设置调度参数
ICUNIT_ASSERT_EQUAL(ret, -1, ret);
wait(nullptr);
exit(92);
@ -160,6 +169,7 @@ static int TestCase(VOID)
int status = 0;
pid_t pid = fork();
ICUNIT_GOTO_WITHIN_EQUAL(pid, 0, 100000, pid, EXIT);
if (pid == 0) {
ret = TestChild();
exit(__LINE__);

BIN
开源软件阅读报告.pdf
View File

Binary file not shown.
Write Preview
Loading…
Cancel
Save