1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #define private public
19 #include "dns_getaddrinfo.h"
20 #undef private
21
22 namespace OHOS {
23 namespace NetsysNative {
24 using namespace testing::ext;
25 using namespace OHOS::nmd;
26
27 class DNSGetaddrinfoTest : public testing::Test {
28 public:
29 static void SetUpTestCase();
30 static void TearDownTestCase();
31 void SetUp();
32 void TearDown();
33 };
34
SetUpTestCase()35 void DNSGetaddrinfoTest::SetUpTestCase() {}
36
TearDownTestCase()37 void DNSGetaddrinfoTest::TearDownTestCase() {}
38
SetUp()39 void DNSGetaddrinfoTest::SetUp() {}
40
TearDown()41 void DNSGetaddrinfoTest::TearDown() {}
42
43 HWTEST_F(DNSGetaddrinfoTest, CheckHintsTest001, TestSize.Level1)
44 {
45 NETNATIVE_LOGI("CheckHintsTest enter");
46 DnsGetAddrInfo getInfo;
47 struct AddrInfo addrInfo;
48 addrInfo.aiFlags = 0;
49 addrInfo.aiFamily = AF_UNSPEC;
50 int32_t ret = getInfo.CheckHints(addrInfo);
51 EXPECT_EQ(ret, DNS_ERR_NONE);
52 }
53
54 HWTEST_F(DNSGetaddrinfoTest, CheckHintsTest002, TestSize.Level1)
55 {
56 NETNATIVE_LOGI("CheckHintsTest error family enter");
57 DnsGetAddrInfo getInfo;
58 struct AddrInfo addrInfo;
59 addrInfo.aiFlags = 0;
60 addrInfo.aiFamily = 88;
61 int32_t ret = getInfo.CheckHints(addrInfo);
62 EXPECT_EQ(ret, EAI_FAMILY);
63 }
64
65 HWTEST_F(DNSGetaddrinfoTest, ParseAddrTest001, TestSize.Level1)
66 {
67 NETNATIVE_LOGI("ParseAddrTest addr number zero enter");
68 DnsGetAddrInfo getInfo;
69 int32_t addrNum = 0;
70 int32_t servNum = 0;
71 struct ServData servData[2] = {};
72 struct AddrData addrData[48] = {};
73 char canon[16] = {0};
74 int32_t len = 16;
75 std::vector<AddrInfo> out;
76 getInfo.ParseAddr(addrNum, servNum, servData, addrData, canon, len, out);
77 int32_t res = out.empty();
78 EXPECT_EQ(res, true);
79 }
80
81 HWTEST_F(DNSGetaddrinfoTest, ParseAddrTest002, TestSize.Level1)
82 {
83 NETNATIVE_LOGI("ParseAddrTest server number zero enter");
84 DnsGetAddrInfo getInfo;
85 int32_t addrNum = 1;
86 int32_t servNum = 0;
87 struct ServData servData[2] = {};
88 struct AddrData addrData[48] = {};
89 char canon[16] = {0};
90 int32_t len = 16;
91 std::vector<AddrInfo> out;
92 getInfo.ParseAddr(addrNum, servNum, servData, addrData, canon, len, out);
93 int32_t res = out.empty();
94 EXPECT_EQ(res, true);
95 }
96
97 HWTEST_F(DNSGetaddrinfoTest, ParseAddrTest003, TestSize.Level1)
98 {
99 NETNATIVE_LOGI("ParseAddrTest canon len zero enter");
100 DnsGetAddrInfo getInfo;
101 int32_t addrNum = 1;
102 int32_t servNum = 1;
103 struct ServData servData[2] = {};
104 struct AddrData addrData[48] = {};
105 char canon[16] = {0};
106 int32_t len = 0;
107 std::vector<AddrInfo> out;
108 getInfo.ParseAddr(addrNum, servNum, servData, addrData, canon, len, out);
109 int32_t res = out.empty();
110 EXPECT_EQ(res, false);
111 }
112
113 HWTEST_F(DNSGetaddrinfoTest, ParseAddrTest004, TestSize.Level1)
114 {
115 NETNATIVE_LOGI("ParseAddrTest IPv4 enter");
116 DnsGetAddrInfo getInfo;
117 int32_t addrNum = 1;
118 int32_t servNum = 1;
119 struct ServData servData[2] = {};
120 struct AddrData addrData[48] = {};
121 addrData[0].family = AF_INET;
122 char canon[16] = {0};
123 int32_t len = 16;
124 std::vector<AddrInfo> out;
125 getInfo.ParseAddr(addrNum, servNum, servData, addrData, canon, len, out);
126 int32_t res = out.empty();
127 EXPECT_EQ(res, false);
128 }
129
130 HWTEST_F(DNSGetaddrinfoTest, ParseAddrTest005, TestSize.Level1)
131 {
132 NETNATIVE_LOGI("ParseAddrTest IPv6 enter");
133 DnsGetAddrInfo getInfo;
134 int32_t addrNum = 1;
135 int32_t servNum = 1;
136 struct ServData servData[2] = {};
137 struct AddrData addrData[48] = {};
138 addrData[0].family = AF_INET6;
139 char canon[16] = {0};
140 int32_t len = 16;
141 std::vector<AddrInfo> out;
142 getInfo.ParseAddr(addrNum, servNum, servData, addrData, canon, len, out);
143 int32_t res = out.empty();
144 EXPECT_EQ(res, false);
145 }
146
147 HWTEST_F(DNSGetaddrinfoTest, ParseAddrTest006, TestSize.Level1)
148 {
149 NETNATIVE_LOGI("ParseAddrTest default enter");
150 DnsGetAddrInfo getInfo;
151 int32_t addrNum = 1;
152 int32_t servNum = 1;
153 struct ServData servData[2] = {};
154 struct AddrData addrData[48] = {};
155 addrData[0].family = 0;
156 char canon[16] = {0};
157 int32_t len = 16;
158 std::vector<AddrInfo> out;
159 getInfo.ParseAddr(addrNum, servNum, servData, addrData, canon, len, out);
160 int32_t res = out.empty();
161 EXPECT_EQ(res, false);
162 }
163
164 HWTEST_F(DNSGetaddrinfoTest, GetAddrInfoTest001, TestSize.Level1)
165 {
166 NETNATIVE_LOGI("GetAddrInfoTest host name empty enter");
167 DnsGetAddrInfo getInfo;
168 std::string host = "";
169 std::string server = "";
170 struct AddrInfo addrInfo = {};
171 uint16_t netId = 101;
172 std::vector<AddrInfo> out;
173 int32_t ret = getInfo.GetAddrInfo(host, server, addrInfo, netId, out);
174 EXPECT_EQ(ret, EAI_NONAME);
175 }
176
177 HWTEST_F(DNSGetaddrinfoTest, GetAddrInfoTest002, TestSize.Level1)
178 {
179 NETNATIVE_LOGI("GetAddrInfoTest AddrInfo error enter");
180 DnsGetAddrInfo getInfo;
181 std::string host = "abcd";
182 std::string server = "dcba";
183 struct AddrInfo addrInfo = {};
184 addrInfo.aiFlags = 0;
185 addrInfo.aiFamily = 88;
186 uint16_t netId = 101;
187 std::vector<AddrInfo> out;
188 int32_t ret = getInfo.GetAddrInfo(host, server, addrInfo, netId, out);
189 EXPECT_EQ(ret, EAI_FAMILY);
190 }
191
192 } // namespace NetsysNative
193 } // namespace OHOS