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
main
Lvwenxuan 8 months ago
parent 30c5b2fb9c 2b84597fad
commit feebadef06
22 changed files with 746 additions and 107 deletions
Show Stats Download Patch File Download Diff File

22
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_002.cpp
Unescape View File

@ -32,35 +32,53 @@
#include "lt_net_netdb.h"
// 测试函数AddrInfoTest的定义
static int AddrInfoTest(void)
{
// Prerequisite: correct DNS servers must be configured.
// 假设DNS服务器配置正确
char host_file[] = "127.0.0.2 example.com\n", serv_file[] = "ftp 21/tcp\n";
// 文件路径数组
char *pathList[] = {"/etc/hosts", "/etc/services"};
// 要写入文件的内容数组
char *streamList[] = {host_file, serv_file};
// 内容长度数组
int streamLen[] = {sizeof(host_file), sizeof(serv_file)};
// 文件数量
const int file_number = 2;
// 准备文件环境
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
if (flag != 0) {
// 如果准备失败，恢复文件环境并返回错误
RecoveryFileEnv(pathList, file_number);
return -1;
}
// 声明addrinfo结构体指针
struct addrinfo *addr = NULL;
// 使用getaddrinfo函数解析域名和端口
int ret = getaddrinfo("example.com", "ftp", NULL, &addr);
// 断言getaddrinfo函数返回0，表示成功
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
// 释放addrinfo结构体
freeaddrinfo(addr);
// 尝试解析一个不存在的域名和端口
ret = getaddrinfo("local", "ftp", NULL, &addr);
// 断言getaddrinfo函数返回EAI_AGAIN，表示临时失败
ICUNIT_ASSERT_EQUAL(ret, EAI_AGAIN, ret);
// 尝试解析一个不存在的服务名称
ret = getaddrinfo("localhost", "fp", NULL, &addr);
// 断言getaddrinfo函数返回EAI_SERVICE，表示服务名称错误
ICUNIT_ASSERT_EQUAL(ret, EAI_SERVICE, ret);
// 获取错误信息字符串
const char *p = gai_strerror(EAI_AGAIN);
// 断言错误信息字符串不为空
ICUNIT_ASSERT_NOT_EQUAL(p, NULL, -1);
// 恢复文件环境
RecoveryFileEnv(pathList, file_number);
return ICUNIT_SUCCESS;
}
@ -97,7 +115,9 @@ static int AddrInfoTest(void)
3. **测试用例的完整性**
- 可以增加更多的测试用例，例如测试不同的`hints`参数对`getaddrinfo`的影响，或者测试更多的有效和无效的主机名和服务名组合。
// 测试用例NetNetDbTest002的定义
void NetNetDbTest002(void)
{
// 添加测试用例
TEST_ADD_CASE(__FUNCTION__, AddrInfoTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}

11
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_003.cpp
Unescape View File

@ -28,24 +28,31 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
//123123
#include "lt_net_netdb.h"
// 测试函数IfAddrsTest的定义
static int IfAddrsTest(void)
{
// Prerequisite: correct DNS servers must be configured.
// 假设DNS服务器配置正确
struct ifaddrs *addr = NULL;
// 使用getifaddrs函数获取网络接口地址信息
int ret = getifaddrs(&addr);
// 断言getifaddrs函数返回0，表示成功
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
// 断言返回的地址信息不为空
ICUNIT_ASSERT_NOT_EQUAL(addr, NULL, -1);
// 释放ifaddrs结构体
freeifaddrs(addr);
return ICUNIT_SUCCESS;
}
// 测试用例NetNetDbTest003的定义
void NetNetDbTest003(void)
{
// 添加测试用例
TEST_ADD_CASE(__FUNCTION__, IfAddrsTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}

62
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_004.cpp
Unescape View File

@ -2,74 +2,74 @@
* 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 "lt_net_netdb.h" // 引入测试所需的头文件
// 包含一个头文件，这个头文件可能包含了网络数据库相关的函数声明和宏定义。
#include "lt_net_netdb.h"
// 测试函数，用于测试gethostbyaddr函数
static int GetHostByAddrTest(void)
{
// 定义一个模拟的hosts文件内容
char host_file[] = "127.0.0.1 localhost\n100.0.0.0 example.com example\n";
// 定义hosts文件的路径列表
char *pathList[] = {"/etc/hosts"};
// 定义模拟的hosts文件流列表
char *streamList[] = {host_file};
// 定义模拟的hosts文件流长度列表
int streamLen[] = {sizeof(host_file)};
// 定义文件数量
const int file_number = 1;
// 准备文件环境，将模拟的hosts文件内容设置为系统的hosts文件
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
// 如果准备失败，恢复原始文件环境
if (flag != 0) {
RecoveryFileEnv(pathList, file_number);
return -1;
return -1; // 返回错误码
}
// 定义in_addr结构体，用于存储IP地址
struct in_addr ia;
int length = 4; // the address length is 4;
// 定义地址长度
int length = 4; // IPv4地址长度为4
// 将点分十进制IP地址转换为网络字节序的整数值
ia.s_addr = inet_addr("127.0.0.1");
// 使用gethostbyaddr获取hostent结构体指针
struct hostent *addr = gethostbyaddr(&ia, sizeof ia, AF_INET);
// 断言addr不为空，即gethostbyaddr成功
ICUNIT_ASSERT_NOT_EQUAL(addr, NULL, -1);
// 断言返回的地址类型为AF_INET
ICUNIT_ASSERT_EQUAL(addr->h_addrtype, AF_INET, addr->h_addrtype);
// 断言返回的主机名为"localhost"
ICUNIT_ASSERT_STRING_EQUAL(addr->h_name, "localhost", -1);
// 断言返回的地址长度为4
ICUNIT_ASSERT_EQUAL(addr->h_length, length, -1);
// 测试另一个IP地址
ia.s_addr = inet_addr("100.0.0.0");
addr = gethostbyaddr(&ia, sizeof ia, AF_INET);
ICUNIT_ASSERT_NOT_EQUAL(addr, NULL, -1);
ICUNIT_ASSERT_EQUAL(addr->h_addrtype, AF_INET, addr->h_addrtype);
ICUNIT_ASSERT_STRING_EQUAL(addr->h_name, "example.com", -1);
// 测试一个不存在的IP地址
errno = 0;
ia.s_addr = inet_addr("127.0.0.0");
addr = gethostbyaddr(&ia, sizeof ia, AF_INET);
// 断言errno为ENOENT，表示没有找到对应的主机名
ICUNIT_ASSERT_EQUAL(errno, ENOENT, errno);
// 恢复原始文件环境
RecoveryFileEnv(pathList, file_number);
return ICUNIT_SUCCESS;
return ICUNIT_SUCCESS; // 返回成功码
}
// 定义测试用例
void NetNetDbTest004(void)
{
// 添加测试用例，指定测试函数、测试类型、测试级别等信息
TEST_ADD_CASE(__FUNCTION__, GetHostByAddrTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
}

23
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_005.cpp
Unescape View File

@ -28,11 +28,14 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// 版权声明，说明该代码由华为技术有限公司所有，并规定了代码的使用和分发条件。
#include "lt_net_netdb.h"
// 包含一个头文件，可能包含了网络数据库函数的声明和定义。
static int GetHostByAddrRTest(void)
{
// 定义一个静态函数，用于测试gethostbyaddr_r函数。
struct in_addr ia;
struct hostent addr, *result = NULL;
char buf[1024];
@ -40,29 +43,47 @@ static int GetHostByAddrRTest(void)
int err, ret;
int length = 4;
// 定义了一些变量，包括用于存储IP地址的in_addr结构体，hostent结构体用于存储查询结果，以及其他辅助变量。
ia.s_addr = inet_addr("127.0.0.1");
// 将字符串形式的IP地址"127.0.0.1"转换为网络字节序的二进制形式，并存储在ia结构体中。
ret = gethostbyaddr_r(&ia, sizeof ia, AF_INET, &addr, buf, sizeof buf, &result, &err);
// 使用gethostbyaddr_r函数根据IP地址查询主机信息，并将结果存储在result指向的hostent结构体中。
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
// 断言函数返回值应为0，表示成功。
ICUNIT_ASSERT_NOT_EQUAL(result, NULL, -1);
// 断言result不应为空，表示查询到了主机信息。
ICUNIT_ASSERT_EQUAL(result->h_addrtype, AF_INET, result->h_addrtype);
// 断言查询到的主机地址类型应为AF_INET（IPv4）。
ICUNIT_ASSERT_STRING_EQUAL(result->h_name, "localhost", -1);
// 断言查询到的主机名应为"localhost"。
ICUNIT_ASSERT_EQUAL(result->h_length, length, -1);
// 断言查询到的主机地址长度应为4（IPv4地址长度）。
errno = 0;
// 清空errno，用于检测接下来的函数调用是否设置了errno。
ia.s_addr = inet_addr("127.0.0.0");
// 将字符串形式的IP地址"127.0.0.0"转换为网络字节序的二进制形式，并存储在ia结构体中。
ret = gethostbyaddr_r(&ia, sizeof ia, AF_INET, &addr, buf, sizeof buf, &result, &err);
// 再次调用gethostbyaddr_r函数，但这次传入的是一个无效的IP地址。
ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
// 断言errno应被设置为EINVAL，表示无效参数。
ret = gethostbyaddr_r(&ia, sizeof ia, AF_INET, &addr, buf, sizeof buf, &result, &err);
// 再次调用函数，但errno已经被之前的调用设置，这里检查是否保持不变。
ICUNIT_ASSERT_EQUAL(errno, EINVAL, errno);
// 断言errno仍然为EINVAL。
ret = gethostbyaddr_r(&ia, sizeof ia, AF_INET, &addr, buf1, sizeof buf1, &result, &err);
// 调用gethostbyaddr_r函数，但这次传入的缓冲区buf1大小不足以存储结果。
ICUNIT_ASSERT_EQUAL(ret, ERANGE, ret);
// 断言函数返回值应为ERANGE，表示缓冲区太小。
return ICUNIT_SUCCESS;
// 返回测试成功。
}
void NetNetDbTest005(void)
{
TEST_ADD_CASE(__FUNCTION__, GetHostByAddrRTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
// 将当前测试函数添加到测试用例中，指定测试类型、协议、级别和函数。
}

22
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_006.cpp
Unescape View File

@ -28,42 +28,60 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// 版权声明，说明该代码由华为技术有限公司和华为设备有限公司所有，并规定了代码的使用和分发条件。
#include "lt_net_netdb.h"
// 引入头文件，可能包含了网络数据库相关的函数声明和宏定义。
static int GetHostByNameTest(void)
{
// 定义一个模拟的hosts文件内容
char host_file[] = "127.0.0.1 localhost\n";
// 定义hosts文件的路径列表
char *pathList[] = {"/etc/hosts"};
// 定义模拟的hosts文件流列表
char *streamList[] = {host_file};
// 定义模拟的hosts文件流长度列表
int streamLen[] = {sizeof(host_file)};
// 定义文件数量
int flag = PrepareFileEnv(pathList, streamList, streamLen, 1);
// 如果准备文件环境失败，则恢复原始文件环境并返回错误码
if (flag != 0) {
RecoveryFileEnv(pathList, 1);
return -1;
}
// 使用gethostbyname函数根据主机名获取hostent结构体指针
struct hostent *addr = gethostbyname("localhost");
// 断言addr不为空，即gethostbyname成功
ICUNIT_ASSERT_NOT_EQUAL(addr, NULL, -1);
// 断言返回的主机名与输入的主机名相同
ICUNIT_ASSERT_EQUAL(strcmp(addr->h_name, "localhost"), 0, -1);
// 断言返回的地址类型为AF_INET
ICUNIT_ASSERT_EQUAL(addr->h_addrtype, AF_INET, addr->h_addrtype);
// 断言返回的地址长度不为0
ICUNIT_ASSERT_NOT_EQUAL(addr->h_length, 0, addr->h_length);
// 测试gethostbyname函数，传入IP地址字符串作为主机名
addr = gethostbyname("127.0.0.1");
ICUNIT_ASSERT_NOT_EQUAL(addr, NULL, -1);
ICUNIT_ASSERT_EQUAL(strcmp(addr->h_name, "127.0.0.1"), 0, -1);
ICUNIT_ASSERT_EQUAL(addr->h_addrtype, AF_INET, addr->h_addrtype);
ICUNIT_ASSERT_NOT_EQUAL(addr->h_length, 0, addr->h_length);
// 测试一个不存在的主机名
addr = gethostbyname("lo");
// 断言addr为空，即gethostbyname失败
ICUNIT_ASSERT_EQUAL(addr, NULL, -1);
// 恢复原始文件环境
RecoveryFileEnv(pathList, 1);
return ICUNIT_SUCCESS;
}
// 定义测试用例
void NetNetDbTest006(void)
{
// 添加测试用例，指定测试函数、测试类型、测试级别等信息
TEST_ADD_CASE(__FUNCTION__, GetHostByNameTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
}

27
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_007.cpp
Unescape View File

@ -31,33 +31,51 @@
#include "lt_net_netdb.h"
// 引入头文件，可能包含了网络数据库相关的函数声明和宏定义。
static int GetHostByNameRTest(void)
{
char host_file[] = "127.0.0.1 localhost\n";
// 定义一个模拟的hosts文件内容，包含localhost映射到127.0.0.1的条目。
char *pathList[] = {"/etc/hosts"};
// 定义hosts文件的路径列表，这里只有一个路径指向系统的hosts文件。
char *streamList[] = {static_cast<char *>(host_file)};
// 定义模拟的hosts文件流列表，这里将模拟的hosts文件内容转换为char*类型。
int streamLen[] = {sizeof(host_file)};
// 定义模拟的hosts文件流长度列表。
const int file_number = 1;
// 定义文件数量。
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
// 调用PrepareFileEnv函数准备文件环境，模拟hosts文件。
if (flag != 0) {
RecoveryFileEnv(pathList, file_number);
return -1;
}
// 如果准备文件环境失败，则恢复原始文件环境并返回错误码。
struct hostent addr, *result = NULL;
// 定义hostent结构体变量addr，用于存储gethostbyname_r函数的结果。
char buf[1024];
// 定义一个足够大的缓冲区buf，用于gethostbyname_r函数。
char buf1[1];
// 定义一个非常小的缓冲区buf1，用于测试gethostbyname_r函数的边界条件。
int err, ret;
ret = gethostbyname_r("localhost", &addr, buf, sizeof buf, &result, &err);
// 使用gethostbyname_r函数根据主机名"localhost"获取hostent结构体指针。
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
// 断言返回值ret为0，表示gethostbyname_r函数调用成功。
ICUNIT_ASSERT_NOT_EQUAL(result, NULL, -1);
// 断言result不为空，即gethostbyname_r成功。
ICUNIT_ASSERT_EQUAL(strcmp(result->h_name, "localhost"), 0, -1);
// 断言返回的主机名与输入的主机名相同。
ICUNIT_ASSERT_EQUAL(result->h_addrtype, AF_INET, result->h_addrtype);
// 断言返回的地址类型为AF_INET。
ICUNIT_ASSERT_NOT_EQUAL(result->h_length, 0, result->h_length);
// 断言返回的地址长度不为0。
ret = gethostbyname_r("127.0.0.1", &addr, buf, sizeof buf, &result, &err);
// 使用gethostbyname_r函数根据IP地址字符串"127.0.0.1"获取hostent结构体指针。
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_NOT_EQUAL(result, NULL, -1);
ICUNIT_ASSERT_EQUAL(strcmp(result->h_name, "127.0.0.1"), 0, -1);
@ -65,17 +83,26 @@ static int GetHostByNameRTest(void)
ICUNIT_ASSERT_NOT_EQUAL(result->h_length, 0, result->h_length);
ret = gethostbyname_r("127.0.0.1", &addr, buf1, sizeof buf1, &result, &err);
// 测试gethostbyname_r函数的边界条件，传入的缓冲区太小。
ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
// 断言返回值ret不为0，表示gethostbyname_r函数调用失败。
ret = gethostbyname_r("127.0.0.0.0", &addr, buf, sizeof buf, &result, &err);
// 测试一个不存在的IP地址。
ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
// 断言返回值ret不为0，表示gethostbyname_r函数调用失败。
ret = gethostbyname_r("lo", &addr, buf, sizeof buf, &result, &err);
// 测试一个不存在的主机名。
ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
// 断言返回值ret不为0，表示gethostbyname_r函数调用失败。
RecoveryFileEnv(pathList, file_number);
// 恢复原始文件环境。
return ICUNIT_SUCCESS;
// 返回测试成功。
}
void NetNetDbTest007(void)
{
TEST_ADD_CASE(__FUNCTION__, GetHostByNameRTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
// 定义测试用例，将GetHostByNameRTest函数注册为一个测试案例。

19
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_008.cpp
Unescape View File

@ -31,42 +31,61 @@
#include "lt_net_netdb.h"
// 引入头文件，可能包含了网络数据库相关的函数声明和宏定义。
static int GetHostByName2Test(void)
{
char host_file[] = "127.0.0.1 localhost\n";
// 定义一个模拟的hosts文件内容，包含localhost映射到127.0.0.1的条目。
char *pathList[] = {"/etc/hosts"};
// 定义hosts文件的路径列表，这里只有一个路径指向系统的hosts文件。
char *streamList[] = {static_cast<char *>(host_file)};
// 定义模拟的hosts文件流列表，这里将模拟的hosts文件内容转换为char*类型。
int streamLen[] = {sizeof(host_file)};
// 定义模拟的hosts文件流长度列表。
const int file_number = 1;
// 定义文件数量。
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
// 调用PrepareFileEnv函数准备文件环境，模拟hosts文件。
if (flag != 0) {
RecoveryFileEnv(pathList, file_number);
return -1;
}
// 如果准备文件环境失败，则恢复原始文件环境并返回错误码。
struct hostent *addr = gethostbyname2("localhost", AF_INET);
// 使用gethostbyname2函数根据主机名"localhost"和地址族AF_INET获取hostent结构体指针。
ICUNIT_ASSERT_NOT_EQUAL(addr, NULL, -1);
// 断言addr不为空，即gethostbyname2成功。
ICUNIT_ASSERT_EQUAL(strcmp(addr->h_name, "localhost"), 0, -1);
// 断言返回的主机名与输入的主机名相同。
ICUNIT_ASSERT_EQUAL(addr->h_addrtype, AF_INET, addr->h_addrtype);
// 断言返回的地址类型为AF_INET。
ICUNIT_ASSERT_NOT_EQUAL(addr->h_length, 0, addr->h_length);
// 断言返回的地址长度不为0。
addr = gethostbyname2("127.0.0.1", AF_INET);
// 使用gethostbyname2函数根据IP地址字符串"127.0.0.1"和地址族AF_INET获取hostent结构体指针。
ICUNIT_ASSERT_NOT_EQUAL(addr, NULL, -1);
ICUNIT_ASSERT_EQUAL(strcmp(addr->h_name, "127.0.0.1"), 0, -1);
ICUNIT_ASSERT_EQUAL(addr->h_addrtype, AF_INET, addr->h_addrtype);
ICUNIT_ASSERT_NOT_EQUAL(addr->h_length, 0, addr->h_length);
addr = gethostbyname2("127.0.0.1", AF_INET6);
// 尝试使用gethostbyname2函数根据IP地址字符串"127.0.0.1"和地址族AF_INET6获取hostent结构体指针，预期失败。
ICUNIT_ASSERT_EQUAL(addr, NULL, -1);
addr = gethostbyname2("localh", AF_INET);
// 尝试使用gethostbyname2函数根据不完整的主机名"localh"和地址族AF_INET获取hostent结构体指针，预期失败。
ICUNIT_ASSERT_EQUAL(addr, NULL, -1);
RecoveryFileEnv(pathList, file_number);
// 恢复原始文件环境。
return ICUNIT_SUCCESS;
// 返回测试成功。
}
void NetNetDbTest008(void)
{
TEST_ADD_CASE(__FUNCTION__, GetHostByName2Test, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
// 定义测试用例，将GetHostByName2Test函数注册为一个测试案例。

27
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_009.cpp
Unescape View File

@ -30,33 +30,51 @@
*/
#include "lt_net_netdb.h"
// 引入头文件，可能包含了网络数据库相关的函数声明和宏定义。
static int GetHostByName2RTest(void)
{
char host_file[] = "127.0.0.1 localhost\n";
// 定义一个模拟的hosts文件内容，包含localhost映射到127.0.0.1的条目。
char *pathList[] = {"/etc/hosts"};
// 定义hosts文件的路径列表，这里只有一个路径指向系统的hosts文件。
char *streamList[] = {host_file};
// 定义模拟的hosts文件流列表，这里直接使用host_file。
int streamLen[] = {sizeof(host_file)};
// 定义模拟的hosts文件流长度列表。
const int file_number = 1;
// 定义文件数量。
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
// 调用PrepareFileEnv函数准备文件环境，模拟hosts文件。
if (flag != 0) {
RecoveryFileEnv(pathList, file_number);
return -1;
}
// 如果准备文件环境失败，则恢复原始文件环境并返回错误码。
struct hostent addr, *result = NULL;
// 定义hostent结构体变量addr，用于存储gethostbyname2_r函数的结果。
char buf[1024];
// 定义一个足够大的缓冲区buf，用于gethostbyname2_r函数。
char buf1[1];
// 定义一个非常小的缓冲区buf1，用于测试gethostbyname2_r函数的边界条件。
int err, ret;
ret = gethostbyname2_r("localhost", AF_INET, &addr, buf, sizeof buf, &result, &err);
// 使用gethostbyname2_r函数根据主机名"localhost"、地址族AF_INET获取hostent结构体指针。
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
// 断言返回值ret为0，表示gethostbyname2_r函数调用成功。
ICUNIT_ASSERT_NOT_EQUAL(result, NULL, -1);
// 断言result不为空，即gethostbyname2_r成功。
ICUNIT_ASSERT_EQUAL(strcmp(result->h_name, "localhost"), 0, -1);
// 断言返回的主机名与输入的主机名相同。
ICUNIT_ASSERT_EQUAL(result->h_addrtype, AF_INET, result->h_addrtype);
// 断言返回的地址类型为AF_INET。
ICUNIT_ASSERT_NOT_EQUAL(result->h_length, 0, result->h_length);
// 断言返回的地址长度不为0。
ret = gethostbyname2_r("127.0.0.1", AF_INET, &addr, buf, sizeof buf, &result, &err);
// 使用gethostbyname2_r函数根据IP地址字符串"127.0.0.1"、地址族AF_INET获取hostent结构体指针。
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
ICUNIT_ASSERT_NOT_EQUAL(result, NULL, -1);
ICUNIT_ASSERT_EQUAL(strcmp(result->h_name, "127.0.0.1"), 0, -1);
@ -64,17 +82,26 @@ static int GetHostByName2RTest(void)
ICUNIT_ASSERT_NOT_EQUAL(result->h_length, 0, result->h_length);
ret = gethostbyname2_r("127.0.0.1", AF_INET, &addr, buf1, sizeof buf1, &result, &err);
// 测试gethostbyname2_r函数的边界条件，传入的缓冲区太小。
ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
// 断言返回值ret不为0，表示gethostbyname2_r函数调用失败。
ret = gethostbyname2_r("127.0.0.1.1", AF_INET, &addr, buf, sizeof buf, &result, &err);
// 测试一个不存在的IP地址。
ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
// 断言返回值ret不为0，表示gethostbyname2_r函数调用失败。
ret = gethostbyname2_r("lo", AF_INET, &addr, buf, sizeof buf, &result, &err);
// 测试一个不存在的主机名。
ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
// 断言返回值ret不为0，表示gethostbyname2_r函数调用失败。
RecoveryFileEnv(pathList, file_number);
// 恢复原始文件环境。
return ICUNIT_SUCCESS;
// 返回测试成功。
}
void NetNetDbTest009(void)
{
TEST_ADD_CASE(__FUNCTION__, GetHostByName2RTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
// 定义测试用例，将GetHostByName2RTest函数注册为一个测试案例。

10
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_010.cpp
Unescape View File

@ -31,21 +31,31 @@
#include "lt_net_netdb.h"
// 引入头文件，可能包含了网络数据库相关的函数声明和宏定义。
static int NameInfoTest(void)
{
char host[256], serv[256];
// 定义两个数组，用于存储getnameinfo函数返回的主机名和服务器名。
struct sockaddr_in addr;
// 定义一个sockaddr_in结构体，用于存储IPv4地址信息。
addr.sin_family = AF_INET;
// 设置地址族为IPv4。
addr.sin_port = htons(22);
// 设置端口号为22（例如SSH端口），htons函数用于将主机字节序转换为网络字节序。
addr.sin_addr.s_addr = inet_addr("127.0.0.1");
// 设置IP地址为127.0.0.1，inet_addr函数将点分十进制IP地址转换为网络字节序的整数。
int ret = getnameinfo((struct sockaddr*)&addr, sizeof addr, host, sizeof host, serv, sizeof serv, 0);
// 调用getnameinfo函数，传入地址信息、主机名和服务器名的缓冲区，尝试获取主机名和服务器名。
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
// 断言getnameinfo函数调用成功，返回值为0。
return ICUNIT_SUCCESS;
// 返回测试成功。
}
void NetNetDbTest010(void)
{
TEST_ADD_CASE(__FUNCTION__, NameInfoTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
// 定义测试用例，将NameInfoTest函数注册为一个测试案例。

20
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_011.cpp
Unescape View File

@ -31,37 +31,57 @@
#include "lt_net_netdb.h"
// 引入头文件，可能包含了网络数据库相关的函数声明和宏定义。
static int GetServByPortTest(void)
{
// refer to the `/etc/services' file.
char serv_file[] = "ssh 22/tcp\n";
// 定义一个模拟的services文件内容，包含ssh服务的条目。
char *pathList[] = {"/etc/services"};
// 定义services文件的路径列表，这里只有一个路径指向系统的services文件。
char *streamList[] = {static_cast<char *>(serv_file)};
// 定义模拟的services文件流列表，这里将模拟的services文件内容转换为char*类型。
int streamLen[] = {sizeof(serv_file)};
// 定义模拟的services文件流长度列表。
const int file_number = 1;
// 定义文件数量。
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
// 调用PrepareFileEnv函数准备文件环境，模拟services文件。
if (flag != 0) {
RecoveryFileEnv(pathList, file_number);
return -1;
}
// 如果准备文件环境失败，则恢复原始文件环境并返回错误码。
const int test_port_no = 22; // ssh port number is 22
// 定义测试的端口号，这里是22，即SSH服务的标准端口号。
struct servent *se1 = nullptr;
// 定义servent结构体指针变量se1，初始化为nullptr。
struct servent *se = getservbyport(htons(test_port_no), "tcp");
// 使用getservbyport函数根据端口号和协议名（"tcp"）获取servent结构体指针。
ICUNIT_ASSERT_NOT_EQUAL(se, NULL, -1);
// 断言se不为空，即getservbyport成功。
ICUNIT_ASSERT_STRING_EQUAL(se->s_name, "ssh", -1);
// 断言返回的服务名称与"ssh"相同。
ICUNIT_ASSERT_STRING_EQUAL(se->s_proto, "tcp", -1);
// 断言返回的服务协议与"tcp"相同。
ICUNIT_ASSERT_STRING_EQUAL(se->s_aliases[0], "ssh", -1);
// 断言返回的服务别名与"ssh"相同。
se1 = getservbyport(htons(test_port_no), "tp");
// 尝试使用getservbyport函数根据端口号和错误的协议名（"tp"）获取servent结构体指针，预期失败。
ICUNIT_ASSERT_EQUAL(se1, nullptr, -1);
// 断言se1为空，即getservbyport失败。
RecoveryFileEnv(pathList, file_number);
// 恢复原始文件环境。
return ICUNIT_SUCCESS;
// 返回测试成功。
}
void NetNetDbTest011(void)
{
TEST_ADD_CASE(__FUNCTION__, GetServByPortTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
// 定义测试用例，将GetServByPortTest函数注册为一个测试案例。

30
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_012.cpp
Unescape View File

@ -31,50 +31,80 @@
#include "lt_net_netdb.h"
// 引入头文件，可能包含了网络数据库相关的函数声明和宏定义。
static int GetServByPortRTest(void)
{
// refer to the `/etc/services' file.
char serv_file[] = "ssh 22/tcp\n";
// 定义一个模拟的services文件内容，包含ssh服务的条目。
char *pathList[] = {"/etc/services"};
// 定义services文件的路径列表，这里只有一个路径指向系统的services文件。
char *streamList[] = {static_cast<char *>(serv_file)};
// 定义模拟的services文件流列表，这里将模拟的services文件内容转换为char*类型。
int streamLen[] = {sizeof(serv_file)};
// 定义模拟的services文件流长度列表。
const int file_number = 1;
// 定义文件数量。
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
// 调用PrepareFileEnv函数准备文件环境，模拟services文件。
if (flag != 0) {
RecoveryFileEnv(pathList, file_number);
return -1;
}
// 如果准备文件环境失败，则恢复原始文件环境并返回错误码。
struct servent se, *result = NULL;
// 定义servent结构体变量se，用于存储getservbyport_r函数的结果。
char buf[1024];
// 定义一个足够大的缓冲区buf，用于getservbyport_r函数。
char buf1[2];
// 定义一个非常小的缓冲区buf1，用于测试getservbyport_r函数的边界条件。
const int test_port_no = 22; // ssh port number is 22
// 定义测试的端口号，这里是22，即SSH服务的标准端口号。
int ret = getservbyport_r(htons(test_port_no), "tcp", &se, buf, sizeof buf, &result);
// 使用getservbyport_r函数根据端口号和协议名（"tcp"）获取servent结构体指针。
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
// 断言返回值ret为0，表示getservbyport_r函数调用成功。
ICUNIT_ASSERT_NOT_EQUAL(result, NULL, -1);
// 断言result不为空，即getservbyport_r成功。
ICUNIT_ASSERT_STRING_EQUAL(se.s_name, "ssh", -1);
// 断言返回的服务名称与"ssh"相同。
ICUNIT_ASSERT_STRING_EQUAL(se.s_proto, "tcp", -1);
// 断言返回的服务协议与"tcp"相同。
ICUNIT_ASSERT_STRING_EQUAL(se.s_aliases[0], "ssh", -1);
// 断言返回的服务别名与"ssh"相同。
ICUNIT_ASSERT_STRING_EQUAL(result->s_name, "ssh", -1);
// 断言result结构体中的服务名称与"ssh"相同。
ICUNIT_ASSERT_STRING_EQUAL(result->s_proto, "tcp", -1);
// 断言result结构体中的服务协议与"tcp"相同。
ICUNIT_ASSERT_STRING_EQUAL(result->s_aliases[0], "ssh", -1);
// 断言result结构体中的服务别名与"ssh"相同。
ret = getservbyport_r(htons(test_port_no), "udp", &se, buf, sizeof buf, &result);
// 尝试使用getservbyport_r函数根据端口号和协议名（"udp"）获取servent结构体指针，预期失败。
ICUNIT_ASSERT_EQUAL(ret, ENOENT, -1);
// 断言返回值ret为ENOENT，表示未找到对应服务。
ret = getservbyport_r(htons(test_port_no), "udp", &se, buf1, sizeof buf1, &result);
// 测试getservbyport_r函数的边界条件，传入的缓冲区太小。
ICUNIT_ASSERT_EQUAL(ret, ERANGE, ret);
// 断言返回值ret为ERANGE，表示缓冲区太小。
ret = getservbyport_r(htons(test_port_no), "ud", &se, buf, sizeof buf, &result);
// 尝试使用getservbyport_r函数根据端口号和不完整的协议名（"ud"）获取servent结构体指针，预期失败。
ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
// 断言返回值ret为EINVAL，表示提供的协议名不合法。
RecoveryFileEnv(pathList, file_number);
// 恢复原始文件环境。
return ICUNIT_SUCCESS;
// 返回测试成功。
}
void NetNetDbTest012(void)
{
TEST_ADD_CASE(__FUNCTION__, GetServByPortRTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
// 定义测试用例，将GetServByPortRTest函数注册为一个测试案例。

13
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_015.cpp
Unescape View File

@ -1,5 +1,5 @@
/*
* opyright (c) 2021-2021, Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2021-2021, 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,
@ -30,6 +30,7 @@
#include "lt_net_netdb.h"
#include <net/if.h>
// 引入头文件，包括网络数据库相关的函数声明和宏定义，以及网络接口相关的函数和宏定义。
static int IfNameToIndexTest(void)
{
@ -38,20 +39,30 @@ static int IfNameToIndexTest(void)
char *str = nullptr;
ret = if_nametoindex("lo");
// 调用if_nametoindex函数将接口名称"lo"转换为系统索引。
ICUNIT_ASSERT_NOT_EQUAL(ret, 0, -1);
// 断言转换成功，返回的索引值不为0。
str = if_indextoname(ret, if_name);
// 调用if_indextoname函数将系统索引转换回接口名称。
ICUNIT_ASSERT_NOT_EQUAL(str, nullptr, -1);
// 断言转换成功，返回的字符串指针不为nullptr。
ICUNIT_ASSERT_STRING_EQUAL(if_name, "lo", -1);
// 断言转换回的接口名称为"lo"。
ret = if_nametoindex("eth1");
// 尝试调用if_nametoindex函数将接口名称"eth1"转换为系统索引。
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
// 断言转换失败，返回的索引值为0。
ICUNIT_ASSERT_EQUAL(errno, ENODEV, errno);
// 断言errno被设置为ENODEV，表示没有找到对应的设备。
return ICUNIT_SUCCESS;
// 返回测试成功。
}
void NetNetDbTest015(void)
{
TEST_ADD_CASE(__FUNCTION__, IfNameToIndexTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
// 定义测试用例，将IfNameToIndexTest函数注册为一个测试案例。

25
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_016.cpp
Unescape View File

@ -1,5 +1,5 @@
/*
* opyright (c) 2021-2021, Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2021-2021, 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,
@ -29,6 +29,7 @@
*/
#include "lt_net_netdb.h"
// 引入头文件，可能包含了网络数据库相关的函数声明和宏定义。
static int GetServByNameTest(void)
{
@ -38,43 +39,65 @@ static int GetServByNameTest(void)
"discard 9/udp sink null\n"
"systat 11/tcp users\n"
"ssh 22/tcp\n";
// 定义一个模拟的services文件内容，包含多个服务的条目。
char *pathList[] = {"/etc/services"};
// 定义services文件的路径列表，这里只有一个路径指向系统的services文件。
char *streamList[] = {static_cast<char *>(serv_file)};
// 定义模拟的services文件流列表，这里将模拟的services文件内容转换为char*类型。
int streamLen[] = {sizeof(serv_file)};
// 定义模拟的services文件流长度列表。
const int file_number = 1;
// 定义文件数量。
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
// 调用PrepareFileEnv函数准备文件环境，模拟services文件。
if (flag != 0) {
RecoveryFileEnv(pathList, file_number);
return -1;
}
// 如果准备文件环境失败，则恢复原始文件环境并返回错误码。
struct servent *se1 = nullptr;
struct servent *se2 = nullptr;
se1 = getservbyname("discard", "tcp");
// 使用getservbyname函数根据服务名"discard"和协议名"tcp"获取servent结构体指针。
ICUNIT_ASSERT_NOT_EQUAL(se1, NULL, -1);
// 断言se1不为空，即getservbyname成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->s_name, "discard", -1);
// 断言返回的服务名称与"discard"相同。
ICUNIT_ASSERT_STRING_EQUAL(se1->s_proto, "tcp", -1);
// 断言返回的服务协议与"tcp"相同。
ICUNIT_ASSERT_STRING_EQUAL(se1->s_aliases[0], "discard", -1);
// 断言返回的服务别名与"discard"相同。
se1 = getservbyname("ssh", "tcp");
// 使用getservbyname函数根据服务名"ssh"和协议名"tcp"获取servent结构体指针。
ICUNIT_ASSERT_NOT_EQUAL(se1, nullptr, -1);
// 断言se1不为空，即getservbyname成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->s_name, "ssh", -1);
// 断言返回的服务名称与"ssh"相同。
ICUNIT_ASSERT_STRING_EQUAL(se1->s_proto, "tcp", -1);
// 断言返回的服务协议与"tcp"相同。
ICUNIT_ASSERT_STRING_EQUAL(se1->s_aliases[0], "ssh", -1);
// 断言返回的服务别名与"ssh"相同。
se2 = getservbyname("cho", "udp");
// 尝试使用getservbyname函数根据错误的服务名"cho"和协议名"udp"获取servent结构体指针，预期失败。
ICUNIT_ASSERT_EQUAL(se2, nullptr, -1);
se2 = getservbyname("systat", "udp");
// 尝试使用getservbyname函数根据服务名"systat"和协议名"udp"获取servent结构体指针，预期失败。
ICUNIT_ASSERT_EQUAL(se2, nullptr, -1);
RecoveryFileEnv(pathList, file_number);
// 恢复原始文件环境。
return ICUNIT_SUCCESS;
// 返回测试成功。
}
void NetNetDbTest016(void)
{
TEST_ADD_CASE(__FUNCTION__, GetServByNameTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
// 定义测试用例，将GetServByNameTest函数注册为一个测试案例。

28
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_017.cpp
Unescape View File

@ -1,5 +1,5 @@
/*
* opyright (c) 2021-2021, Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2021-2021, 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,
@ -29,19 +29,27 @@
*/
#include "lt_net_netdb.h"
// 引入头文件，可能包含了网络数据库相关的函数声明和宏定义。
static int GetServByNameRTest(void)
{
char serv_file[] = "ssh 22/tcp\n";
// 定义一个模拟的services文件内容，包含ssh服务的条目。
char *pathList[] = {"/etc/services"};
// 定义services文件的路径列表，这里只有一个路径指向系统的services文件。
char *streamList[] = {static_cast<char *>(serv_file)};
// 定义模拟的services文件流列表，这里将模拟的services文件内容转换为char*类型。
int streamLen[] = {sizeof(serv_file)};
// 定义模拟的services文件流长度列表。
const int file_number = 1;
// 定义文件数量。
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
// 调用PrepareFileEnv函数准备文件环境，模拟services文件。
if (flag != 0) {
RecoveryFileEnv(pathList, file_number);
return -1;
}
// 如果准备文件环境失败，则恢复原始文件环境并返回错误码。
struct servent se;
struct servent *result = NULL;
@ -51,29 +59,47 @@ static int GetServByNameRTest(void)
errno = 0;
ret = getservbyname_r("ssh", "tcp", &se, buf1, sizeof buf1, &result);
// 使用getservbyname_r函数根据服务名"ssh"和协议名"tcp"获取servent结构体指针。
ICUNIT_ASSERT_EQUAL(ret, 0, ret);
// 断言返回值ret为0，表示getservbyname_r函数调用成功。
ICUNIT_ASSERT_NOT_EQUAL(result, NULL, -1);
// 断言result不为空，即getservbyname_r成功。
ICUNIT_ASSERT_STRING_EQUAL(se.s_name, "ssh", -1);
// 断言返回的服务名称与"ssh"相同。
ICUNIT_ASSERT_STRING_EQUAL(se.s_proto, "tcp", -1);
// 断言返回的服务协议与"tcp"相同。
ICUNIT_ASSERT_STRING_EQUAL(se.s_aliases[0], "ssh", -1);
// 断言返回的服务别名与"ssh"相同。
ICUNIT_ASSERT_STRING_EQUAL(result->s_name, "ssh", -1);
// 断言result结构体中的服务名称与"ssh"相同。
ICUNIT_ASSERT_STRING_EQUAL(result->s_proto, "tcp", -1);
// 断言result结构体中的服务协议与"tcp"相同。
ICUNIT_ASSERT_STRING_EQUAL(result->s_aliases[0], "ssh", -1);
// 断言result结构体中的服务别名与"ssh"相同。
ret = getservbyname_r("ssh", "tcp", &se, buf2, sizeof buf2, &result);
// 测试getservbyname_r函数的边界条件，传入的缓冲区太小。
ICUNIT_ASSERT_EQUAL(ret, ERANGE, ret);
// 断言返回值ret为ERANGE，表示缓冲区太小。
ret = getservbyname_r("ssh", "tp", &se, buf1, sizeof buf1, &result);
// 尝试使用getservbyname_r函数根据服务名"ssh"和错误的协议名"tp"获取servent结构体指针，预期失败。
ICUNIT_ASSERT_EQUAL(ret, EINVAL, ret);
// 断言返回值ret为EINVAL，表示提供的协议名不合法。
ret = getservbyname_r("sh", "tcp", &se, buf1, sizeof buf1, &result);
// 尝试使用getservbyname_r函数根据不完整的服务名"sh"和协议名"tcp"获取servent结构体指针，预期失败。
ICUNIT_ASSERT_EQUAL(ret, ENOENT, ret);
// 断言返回值ret为ENOENT，表示未找到对应服务。
RecoveryFileEnv(pathList, file_number);
// 恢复原始文件环境。
return ICUNIT_SUCCESS;
// 返回测试成功。
}
void NetNetDbTest017(void)
{
TEST_ADD_CASE(__FUNCTION__, GetServByNameRTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
// 定义测试用例，将GetServByNameRTest函数注册为一个测试案例。

51
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_018.cpp
Unescape View File

@ -1,5 +1,5 @@
/*
* opyright (c) 2021-2021, Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2021-2021, 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,
@ -29,6 +29,7 @@
*/
#include "lt_net_netdb.h"
// 引入头文件，可能包含了网络数据库相关的函数声明和宏定义。
static int GetServEntTest(void)
{
@ -39,15 +40,22 @@ static int GetServEntTest(void)
"ssh 100000/tcp\n"
"ssh /tcp\n"
"ssh 22/";
// 定义一个模拟的services文件内容，包含多个服务的条目。
char *pathList[] = {"/etc/services"};
// 定义services文件的路径列表，这里只有一个路径指向系统的services文件。
char *streamList[] = {static_cast<char *>(serv_file)};
// 定义模拟的services文件流列表，这里将模拟的services文件内容转换为char*类型。
int streamLen[] = {sizeof(serv_file)};
// 定义模拟的services文件流长度列表。
const int file_number = 1;
// 定义文件数量。
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
// 调用PrepareFileEnv函数准备文件环境，模拟services文件。
if (flag != 0) {
RecoveryFileEnv(pathList, file_number);
return -1;
}
// 如果准备文件环境失败，则恢复原始文件环境并返回错误码。
/* tcpmux,echo,discard port number is 1,7,9 */
const int tcpmux_port_no = 1;
@ -59,55 +67,96 @@ static int GetServEntTest(void)
struct servent *se3 = nullptr;
se1 = getservent();
// 调用getservent函数获取services数据库中的第一个服务条目。
ICUNIT_ASSERT_NOT_EQUAL(se1, nullptr, -1);
// 断言se1不为空，即getservent成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->s_name, "tcpmux", -1);
// 断言返回的服务名称与"tcpmux"相同。
ICUNIT_ASSERT_STRING_EQUAL(se1->s_proto, "tcp", -1);
// 断言返回的服务协议与"tcp"相同。
ICUNIT_ASSERT_EQUAL(se1->s_port, ntohs(tcpmux_port_no), -1);
// 断言返回的服务端口号与转换为网络字节序的1相同。
endservent();
// 调用endservent函数结束服务数据库的搜索。
se2 = getservent();
// 再次调用getservent函数获取services数据库中的第一个服务条目。
ICUNIT_ASSERT_NOT_EQUAL(se2, nullptr, -1);
// 断言se2不为空，即getservent成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->s_name, se2->s_name, -1);
// 断言返回的服务名称与之前相同。
ICUNIT_ASSERT_STRING_EQUAL(se1->s_proto, se2->s_proto, -1);
// 断言返回的服务协议与之前相同。
ICUNIT_ASSERT_EQUAL(se1->s_port, se2->s_port, -1);
// 断言返回的服务端口号与之前相同。
setservent(0);
// 调用setservent函数设置服务数据库的搜索位置到开始。
se3 = getservent();
// 调用getservent函数获取services数据库中的第一个服务条目。
ICUNIT_ASSERT_NOT_EQUAL(se3, nullptr, -1);
// 断言se3不为空，即getservent成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->s_name, se3->s_name, -1);
// 断言返回的服务名称与之前相同。
ICUNIT_ASSERT_STRING_EQUAL(se1->s_proto, se3->s_proto, -1);
// 断言返回的服务协议与之前相同。
ICUNIT_ASSERT_EQUAL(se1->s_port, se3->s_port, -1);
// 断言返回的服务端口号与之前相同。
se3 = getservent();
// 获取下一个服务条目。
ICUNIT_ASSERT_NOT_EQUAL(se3, nullptr, -1);
// 断言se3不为空，即getservent成功。
ICUNIT_ASSERT_STRING_EQUAL(se3->s_name, "echo", -1);
// 断言返回的服务名称与"echo"相同。
ICUNIT_ASSERT_STRING_EQUAL(se3->s_proto, "tcp", -1);
// 断言返回的服务协议与"tcp"相同。
ICUNIT_ASSERT_EQUAL(se3->s_port, ntohs(echo_port_no), -1);
// 断言返回的服务端口号与转换为网络字节序的7相同。
se3 = getservent();
// 获取下一个服务条目。
ICUNIT_ASSERT_NOT_EQUAL(se3, nullptr, -1);
// 断言se3不为空，即getservent成功。
ICUNIT_ASSERT_STRING_EQUAL(se3->s_name, "echo", -1);
// 断言返回的服务名称与"echo"相同。
ICUNIT_ASSERT_STRING_EQUAL(se3->s_proto, "udp", -1);
// 断言返回的服务协议与"udp"相同。
ICUNIT_ASSERT_EQUAL(se3->s_port, ntohs(echo_port_no), -1);
// 断言返回的服务端口号与转换为网络字节序的7相同。
se3 = getservent();
// 获取下一个服务条目。
ICUNIT_ASSERT_NOT_EQUAL(se3, nullptr, -1);
// 断言se3不为空，即getservent成功。
ICUNIT_ASSERT_STRING_EQUAL(se3->s_name, "discard", -1);
// 断言返回的服务名称与"discard"相同。
ICUNIT_ASSERT_STRING_EQUAL(se3->s_proto, "tcp", -1);
// 断言返回的服务协议与"tcp"相同。
ICUNIT_ASSERT_EQUAL(se3->s_port, ntohs(discard_port_no), -1);
// 断言返回的服务端口号与转换为网络字节序的9相同。
ICUNIT_ASSERT_STRING_EQUAL(se3->s_aliases[0], "sink", -1);
// 断言返回的服务别名列表中的第一个别名与"sink"相同。
ICUNIT_ASSERT_STRING_EQUAL(se3->s_aliases[1], "null", -1);
// 断言返回的服务别名列表中的第二个别名与"null"相同。
ICUNIT_ASSERT_EQUAL(se3->s_aliases[2], nullptr, -1);
// 断言返回的服务别名列表中的第三个别名为nullptr，表示别名列表结束。
se3 = getservent();
// 获取下一个服务条目。
ICUNIT_ASSERT_EQUAL(se3, nullptr, -1);
// 断言se3为空，即已经到达services数据库的末尾。
endservent();
// 调用endservent函数结束服务数据库的搜索。
RecoveryFileEnv(pathList, file_number);
// 恢复原始文件环境。
return ICUNIT_SUCCESS;
// 返回测试成功。
}
void NetNetDbTest018(void)
{
TEST_ADD_CASE(__FUNCTION__, GetServEntTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
// 定义测试用例，将GetServEntTest函数注册为一个测试案例。

51
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_019.cpp
Unescape View File

@ -1,5 +1,5 @@
/*
* opyright (c) 2021-2021, Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2021-2021, 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,
@ -29,7 +29,8 @@
*/
#include "lt_net_netdb.h"
#include<arpa/nameser.h>
#include <arpa/nameser.h>
// 引入头文件，包括网络数据库相关的函数声明和宏定义，以及Nameser.h中定义的与DNS相关的宏和结构。
static int GetHostEntTest(void)
{
@ -38,15 +39,22 @@ static int GetHostEntTest(void)
"10.0.0.0 example example.com example.cn\n"
"10.0.0.0\n"
"10.0.0 example.com";
// 定义一个模拟的hosts文件内容，包含IPv4和IPv6的条目。
char *pathList[] = {"/etc/hosts"};
// 定义hosts文件的路径列表，这里只有一个路径指向系统的hosts文件。
char *streamList[] = {static_cast<char *>(host_file)};
// 定义模拟的hosts文件流列表，这里将模拟的hosts文件内容转换为char*类型。
int streamLen[] = {sizeof(host_file)};
// 定义模拟的hosts文件流长度列表。
const int file_number = 1;
// 定义文件数量。
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
// 调用PrepareFileEnv函数准备文件环境，模拟hosts文件。
if (flag != 0) {
RecoveryFileEnv(pathList, file_number);
return -1;
}
// 如果准备文件环境失败，则恢复原始文件环境并返回错误码。
struct hostent *se1 = nullptr;
struct hostent *se2 = nullptr;
@ -54,52 +62,91 @@ static int GetHostEntTest(void)
char addr[INET6_ADDRSTRLEN];
se1 = gethostent();
// 调用gethostent函数获取hosts数据库中的第一个主机条目。
ICUNIT_ASSERT_NOT_EQUAL(se1, nullptr, -1);
// 断言se1不为空，即gethostent成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->h_name, "localhost", -1);
// 断言返回的主机名与"localhost"相同。
ICUNIT_ASSERT_EQUAL(se1->h_addrtype, AF_INET, -1);
// 断言返回的地址类型为AF_INET（IPv4）。
ICUNIT_ASSERT_EQUAL(se1->h_length, INADDRSZ, -1);
// 断言返回的地址长度为IPv4地址长度。
ICUNIT_ASSERT_STRING_EQUAL("127.0.0.1", inet_ntop(AF_INET, se1->h_addr_list[0], addr, INET_ADDRSTRLEN), -1);
// 断言返回的第一个地址为"127.0.0.1"。
ICUNIT_ASSERT_EQUAL(se1->h_aliases[0], nullptr, -1);
// 断言别名列表中的第一个别名为nullptr，表示别名列表结束。
endhostent();
// 调用endhostent函数结束主机数据库的搜索。
se2 = gethostent();
// 再次调用gethostent函数获取hosts数据库中的第一个主机条目。
ICUNIT_ASSERT_NOT_EQUAL(se2, nullptr, -1);
// 断言se2不为空，即gethostent成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->h_name, se2->h_name, -1);
// 断言返回的主机名与之前相同。
ICUNIT_ASSERT_EQUAL(se1->h_addrtype, se2->h_addrtype, -1);
// 断言返回的地址类型与之前相同。
ICUNIT_ASSERT_EQUAL(se1->h_length, se2->h_length, -1);
// 断言返回的地址长度与之前相同。
sethostent(0);
// 调用sethostent函数设置主机数据库的搜索位置到开始。
se3 = gethostent();
// 调用gethostent函数获取hosts数据库中的第一个主机条目。
ICUNIT_ASSERT_NOT_EQUAL(se3, nullptr, -1);
// 断言se3不为空，即gethostent成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->h_name, se3->h_name, -1);
// 断言返回的主机名与之前相同。
ICUNIT_ASSERT_EQUAL(se1->h_addrtype, se3->h_addrtype, -1);
// 断言返回的地址类型与之前相同。
ICUNIT_ASSERT_EQUAL(se1->h_length, se3->h_length, -1);
// 断言返回的地址长度与之前相同。
se3 = gethostent();
// 获取下一个主机条目。
ICUNIT_ASSERT_NOT_EQUAL(se3, nullptr, -1);
// 断言se3不为空，即gethostent成功。
ICUNIT_ASSERT_EQUAL(se3->h_addrtype, AF_INET6, -1);
// 断言返回的地址类型为AF_INET6（IPv6）。
ICUNIT_ASSERT_STRING_EQUAL(se3->h_name, "ip6-localhost", -1);
// 断言返回的主机名为"ip6-localhost"。
ICUNIT_ASSERT_EQUAL(se3->h_length, IN6ADDRSZ, -1);
// 断言返回的地址长度为IPv6地址长度。
ICUNIT_ASSERT_STRING_EQUAL("::1", inet_ntop(AF_INET6, se3->h_addr_list[0], addr, INET6_ADDRSTRLEN), -1);
// 断言返回的第一个地址为"::1"。
se3 = gethostent();
// 获取下一个主机条目。
ICUNIT_ASSERT_NOT_EQUAL(se3, nullptr, -1);
// 断言se3不为空，即gethostent成功。
ICUNIT_ASSERT_EQUAL(se3->h_addrtype, AF_INET, -1);
// 断言返回的地址类型为AF_INET（IPv4）。
ICUNIT_ASSERT_STRING_EQUAL(se3->h_name, "example", -1);
// 断言返回的主机名为"example"。
ICUNIT_ASSERT_STRING_EQUAL("10.0.0.0", inet_ntop(AF_INET, se3->h_addr_list[0], addr, INET_ADDRSTRLEN), -1);
// 断言返回的第一个地址为"10.0.0.0"。
ICUNIT_ASSERT_STRING_EQUAL(se3->h_aliases[0], "example.com", -1);
// 断言别名列表中的第一个别名为"example.com"。
ICUNIT_ASSERT_STRING_EQUAL(se3->h_aliases[1], "example.cn", -1);
// 断言别名列表中的第二个别名为"example.cn"。
ICUNIT_ASSERT_EQUAL(se3->h_aliases[2], nullptr, -1);
// 断言别名列表中的第三个别名为nullptr，表示别名列表结束。
se3 = gethostent();
// 获取下一个主机条目。
ICUNIT_ASSERT_EQUAL(se3, nullptr, -1);
// 断言se3为空，即已经到达hosts数据库的末尾。
endhostent();
// 调用endhostent函数结束主机数据库的搜索。
RecoveryFileEnv(pathList, file_number);
// 恢复原始文件环境。
return ICUNIT_SUCCESS;
// 返回测试成功。
}
void NetNetDbTest019(void)
{
TEST_ADD_CASE(__FUNCTION__, GetHostEntTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
// 定义测试用例，将GetHostEntTest函数注册为一个测试案例。

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

@ -1,5 +1,5 @@
/*
* opyright (c) 2021-2021, Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2021-2021, 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,
@ -29,6 +29,7 @@
*/
#include "lt_net_netdb.h"
// 引入头文件，包含了网络数据库相关的函数声明和宏定义。
static int GetNetEntTest(void)
{
@ -36,56 +37,94 @@ static int GetNetEntTest(void)
"link-local 169.254.0.0\n"
"example 192.168.1.0 network example-network\n"
"test1";
// 定义一个模拟的networks文件内容，包含网络名称和对应的地址。
char *pathList[] = {"/etc/networks"};
// 定义networks文件的路径列表，这里只有一个路径指向系统的networks文件。
char *streamList[] = {static_cast<char *>(network_file)};
// 定义模拟的networks文件流列表，这里将模拟的networks文件内容转换为char*类型。
int streamLen[] = {sizeof(network_file)};
// 定义模拟的networks文件流长度列表。
const int file_number = 1;
// 定义文件数量。
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
// 调用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数据库中的第一个网络条目。
ICUNIT_ASSERT_NOT_EQUAL(se1, nullptr, -1);
// 断言se1不为空，即getnetent成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->n_name, "link-local", -1);
// 断言返回的网络名称与"link-local"相同。
ICUNIT_ASSERT_EQUAL(se1->n_addrtype, AF_INET, -1);
// 断言返回的地址类型为AF_INET（IPv4）。
ICUNIT_ASSERT_EQUAL(se1->n_net, inet_network("169.254.0.0"), -1);
// 断言返回的网络地址与"169.254.0.0"相同。
ICUNIT_ASSERT_EQUAL(se1->n_aliases[0], nullptr, -1);
// 断言别名列表中的第一个别名为nullptr，表示别名列表结束。
endnetent();
// 调用endnetent函数结束网络数据库的搜索。
se2 = getnetent();
// 再次调用getnetent函数获取networks数据库中的第一个网络条目。
ICUNIT_ASSERT_NOT_EQUAL(se2, nullptr, -1);
// 断言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函数设置网络数据库的搜索位置到开始。
se3 = getnetent();
// 调用getnetent函数获取networks数据库中的第一个网络条目。
ICUNIT_ASSERT_NOT_EQUAL(se3, nullptr, -1);
// 断言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成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->n_name, "example", -1);
// 断言返回的网络名称与"example"相同。
ICUNIT_ASSERT_EQUAL(se1->n_addrtype, AF_INET, -1);
// 断言返回的地址类型为AF_INET（IPv4）。
ICUNIT_ASSERT_EQUAL(se1->n_net, inet_network("192.168.1.0"), -1);
// 断言返回的网络地址与"192.168.1.0"相同。
ICUNIT_ASSERT_STRING_EQUAL(se1->n_aliases[0], "network", -1);
// 断言别名列表中的第一个别名为"network"。
ICUNIT_ASSERT_STRING_EQUAL(se1->n_aliases[1], "example-network", -1);
// 断言别名列表中的第二个别名为"example-network"。
ICUNIT_ASSERT_EQUAL(se1->n_aliases[2], nullptr, -1);
// 断言别名列表中的第三个别名为nullptr，表示别名列表结束。
se1 = getnetent();
// 获取下一个网络条目。
ICUNIT_ASSERT_EQUAL(se1, nullptr, -1);
// 断言se1为空，即已经到达networks数据库的末尾。
endnetent();
// 调用endnetent函数结束网络数据库的搜索。
RecoveryFileEnv(pathList, file_number);
// 恢复原始文件环境。
return ICUNIT_SUCCESS;
// 返回测试成功。
}
void NetNetDbTest020(void)

20
kernel_liteos_a-master/testsuites/unittest/net/netdb/full/net_netdb_test_021.cpp
Unescape View File

@ -1,5 +1,5 @@
/*
* opyright (c) 2021-2021, Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2021-2021, 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,
@ -29,42 +29,60 @@
*/
#include "lt_net_netdb.h"
// 引入头文件，包含了网络数据库相关的函数声明和宏定义。
static int GetNetBynametTest(void)
{
char network_file[] = "# symbolic names for networks, see networks(5) for more information\n"
"link-local 169.254.0.0\n";
// 定义一个模拟的networks文件内容，包含网络名称和对应的地址。
char *pathList[] = {"/etc/networks"};
// 定义networks文件的路径列表，这里只有一个路径指向系统的networks文件。
char *streamList[] = {static_cast<char *>(network_file)};
// 定义模拟的networks文件流列表，这里将模拟的networks文件内容转换为char*类型。
int streamLen[] = {sizeof(network_file)};
// 定义模拟的networks文件流长度列表。
const int file_number = 1;
// 定义文件数量。
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
// 调用PrepareFileEnv函数准备文件环境，模拟networks文件。
if (flag != 0) {
RecoveryFileEnv(pathList, file_number);
return -1;
}
// 如果准备文件环境失败，则恢复原始文件环境并返回错误码。
struct netent *se1 = nullptr;
struct netent *se2 = nullptr;
struct netent *se3 = nullptr;
se1 = getnetbyname("link-local");
// 使用getnetbyname函数根据网络名称"link-local"获取netent结构体指针。
ICUNIT_ASSERT_NOT_EQUAL(se1, nullptr, -1);
// 断言se1不为空，即getnetbyname成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->n_name, "link-local", -1);
// 断言返回的网络名称与"link-local"相同。
ICUNIT_ASSERT_EQUAL(se1->n_addrtype, AF_INET, -1);
// 断言返回的地址类型为AF_INET（IPv4）。
ICUNIT_ASSERT_EQUAL(se1->n_net, inet_network("169.254.0.0"), -1);
// 断言返回的网络地址与"169.254.0.0"相同。
se2 = getnetbyname("link");
// 尝试使用getnetbyname函数根据不完整的网络名称"link"获取netent结构体指针，预期失败。
ICUNIT_ASSERT_EQUAL(se2, nullptr, -1);
se3 = getnetbyname("hs");
// 尝试使用getnetbyname函数根据不存在的网络名称"hs"获取netent结构体指针，预期失败。
ICUNIT_ASSERT_EQUAL(se3, nullptr, -1);
RecoveryFileEnv(pathList, file_number);
// 恢复原始文件环境。
return ICUNIT_SUCCESS;
// 返回测试成功。
}
void NetNetDbTest021(void)
{
TEST_ADD_CASE(__FUNCTION__, GetNetBynametTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
// 定义测试用例，将GetNetBynametTest函数注册为一个测试案例。

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

@ -1,5 +1,5 @@
/*
* opyright (c) 2021-2021, Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2021-2021, 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,
@ -29,39 +29,56 @@
*/
#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文件内容，包含网络名称和对应的地址。
char *pathList[] = {"/etc/networks"};
// 定义networks文件的路径列表，这里只有一个路径指向系统的networks文件。
char *streamList[] = {static_cast<char *>(network_file)};
// 定义模拟的networks文件流列表，这里将模拟的networks文件内容转换为char*类型。
int streamLen[] = {sizeof(network_file)};
// 定义模拟的networks文件流长度列表。
const int file_number = 1;
// 定义文件数量。
int flag = PrepareFileEnv(pathList, streamList, streamLen, file_number);
// 调用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结构体指针。
ICUNIT_ASSERT_NOT_EQUAL(se1, nullptr, -1);
// 断言se1不为空，即getnetbyaddr成功。
ICUNIT_ASSERT_STRING_EQUAL(se1->n_name, "link-local", -1);
// 断言返回的网络名称与"link-local"相同。
ICUNIT_ASSERT_EQUAL(se1->n_addrtype, AF_INET, -1);
// 断言返回的地址类型为AF_INET（IPv4）。
ICUNIT_ASSERT_EQUAL(se1->n_net, inet_network("169.254.0.0"), -1);
// 断言返回的网络地址与"169.254.0.0"相同。
se2 = getnetbyaddr(inet_network("169.254.0.1"), AF_INET);
// 尝试使用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结构体指针，预期失败。
ICUNIT_ASSERT_EQUAL(se3, nullptr, -1);
RecoveryFileEnv(pathList, file_number);
// 恢复原始文件环境。
return ICUNIT_SUCCESS;
// 返回测试成功。
}
void NetNetDbTest022(void)

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

@ -2,58 +2,46 @@
* 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 "lt_net_netdb.h" // 包含测试所需的网络数据库头文件
#include "lt_net_netdb.h"
// 定义一个测试函数，用于测试协议数据库的功能
static int ProtoentTest(void)
{
setprotoent(1);
setprotoent(1); // 打开协议数据库文件，参数1表示重置文件指针到文件开始
// refer to the `/etc/protocols' file.
// 引用/etc/protocols文件，获取名为"icmp"的协议条目
struct protoent *prot = getprotobyname("icmp");
// 断言：确保获取到的协议条目不为空
ICUNIT_ASSERT_NOT_EQUAL(prot, NULL, -1);
// 断言：确保获取到的协议编号是1（ICMP协议的编号）
ICUNIT_ASSERT_EQUAL(prot->p_proto, 1, prot->p_proto);
// 获取编号为1的协议条目（也是ICMP协议）
prot = getprotobynumber(1);
// 断言：确保获取到的协议条目不为空
ICUNIT_ASSERT_NOT_EQUAL(prot, NULL, -1);
ICUNIT_ASSERT_EQUAL(strcmp(prot->p_name, "icmp"), 0, -1);
// 断言：确保获取到的协议名称是"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测试添加到测试套件中
void NetNetDbTest001(void)
{
// 添加测试用例到测试框架中，包括测试用例名称、测试函数、测试类别、测试协议、测试级别和测试类型
TEST_ADD_CASE(__FUNCTION__, ProtoentTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
以下是对这段代码的批注：

48
kernel_liteos_a-master/testsuites/unittest/net/netdb/smoke/net_netdb_test_013.cpp
Unescape View File

@ -1,48 +1,34 @@
/*
* 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 "lt_net_netdb.h" // 包含测试所需的网络数据库头文件，可能定义了测试框架和相关的宏、函数原型等
#include "lt_net_netdb.h"
// 定义一个测试函数，用于测试hstrerror和herror函数的功能
static int HerrorTest(void)
{
// 调用hstrerror函数，传入一个错误码（TRY_AGAIN是一个宏，通常代表一个网络相关的错误码）
// hstrerror函数用于将错误码转换为对应的错误描述字符串
const char *err = hstrerror(TRY_AGAIN);
// 断言：确保hstrerror返回的错误描述字符串不为空
// 如果为空，则测试失败，返回-1作为错误码
ICUNIT_ASSERT_NOT_EQUAL(err, NULL, -1);
// 调用herror函数，传入hstrerror返回的错误描述字符串
// herror函数通常用于将错误描述打印到标准错误输出（stderr）
herror(err);
// 返回测试成功标志
return ICUNIT_SUCCESS;
}
// 定义一个测试注册函数，用于将HerrorTest测试添加到测试套件中
void NetNetDbTest013(void)
{
// 使用TEST_ADD_CASE宏添加测试用例到测试框架中
// 宏的参数包括测试用例的名称（当前函数名）、测试函数、测试类别、测试协议、测试级别和测试类型
// 这些参数帮助测试框架组织和执行测试用例
TEST_ADD_CASE(__FUNCTION__, HerrorTest, TEST_POSIX, TEST_TCP, TEST_LEVEL0, TEST_FUNCTION);
}
}

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

@ -28,6 +28,242 @@
* 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标准库中的极限定义
#include <climits>
// 包含Google Test测试框架头文件
#include <gtest/gtest.h>
// 包含自定义的pthread测试头文件
#include "it_pthread_test.h"
// 包含系统资源库头文件
#include <sys/resource.h>
// 使用Google Test框架的扩展命名空间
using namespace testing::ext;
// 定义一个名为OHOS的命名空间，用于封装测试代码
namespace OHOS {
// 定义一个测试类ProcessPthreadTest，它继承自Google Test框架的Test类
class ProcessPthreadTest : public testing::Test {
public:
// 测试套件开始前调用的静态成员函数，用于设置测试环境
static void SetUpTestCase(void) {
struct sched_param param = { 0 }; // 定义调度参数结构体
int currThreadPolicy, ret; // 定义当前线程策略和返回值变量
// 获取当前线程的调度参数
ret = pthread_getschedparam(pthread_self(), &currThreadPolicy, &param);
// 断言返回值为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作为错误码
ICUNIT_ASSERT_EQUAL_VOID(ret, 0, -ret);
}
// 测试套件结束后调用的静态成员函数，用于清理测试环境（这里为空实现）
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
*/
// 定义测试用例ItTestPthread003
HWTEST_F(ProcessPthreadTest, ItTestPthread003, TestSize.Level0) {
ItTestPthread003();
}
#endif
#ifndef LOSCFG_USER_TEST_SMP
// 如果未定义LOSCFG_USER_TEST_SMP，则编译并执行以下测试用例
/* *
* @tc.name: it_test_pthread_006
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
// 定义测试用例ItTestPthread006
HWTEST_F(ProcessPthreadTest, ItTestPthread006, TestSize.Level0) {
ItTestPthread006();
}
#endif
// 以下是其他测试用例的定义，每个测试用例都有相应的注释说明其功能和类型
/* *
* @tc.name: it_test_pthread_007
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread007, TestSize.Level0) {
ItTestPthread007();
}
/* *
* @tc.name: it_test_pthread_008
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread008, TestSize.Level0) {
ItTestPthread008();
}
/* *
* @tc.name: it_test_pthread_009
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread009, TestSize.Level0) {
ItTestPthread009();
}
#ifndef 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();
}
#endif
/* *
* @tc.name: it_test_pthread_011
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread011, TestSize.Level0) {
ItTestPthread011();
}
/* *
* @tc.name: it_test_pthread_012
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread012, TestSize.Level0) {
ItTestPthread012();
}
/* *
* @tc.name: it_test_pthread_013
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread013, TestSize.Level0) {
ItTestPthread013();
}
/* *
* @tc.name: it_test_pthread_015
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread015, TestSize.Level0) {
ItTestPthread015();
}
/* *
* @tc.name: it_test_pthread_016
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread016, TestSize.Level0) {
ItTestPthread016();
}
/* *
* @tc.name: it_test_pthread_018
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread018, TestSize.Level0) {
ItTestPthread018();
}
/* *
* @tc.name: it_test_pthread_019
* @tc.desc: function for ProcessPthreadTest
* @tc.type: FUNC
*/
HWTEST_F(ProcessPthreadTest, ItTestPthread019, TestSize.Level0) {
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();
}
/* *
* @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, 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> // 引入字符类型限制头文件

Write Preview
Loading…
Cancel
Save