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 #ifdef GTEST_API_
19 #define private public
20 #define protected public
21 #endif
22
23 #include "dns_lookup_name.cpp"
24 #include "dns_manager.h"
25
26 namespace OHOS {
27 namespace NetsysNative {
28 using namespace testing::ext;
29 using namespace OHOS::nmd;
30 namespace {
31 const uint16_t NET_ID = 3;
32 uint16_t BASE_TIMEOUT_MILLIS = 2000;
33 uint8_t RETRY_COUNT = 3;
34 constexpr int32_t TEST_SOCKET_FD = 7;
35
SockAddrCopy001()36 void SockAddrCopy001()
37 {
38 DnsLookUpName name;
39 ScokAddrCopy addrBuff;
40 addrBuff.family = AF_INET;
41 addrBuff.lookUpNameFd = TEST_SOCKET_FD;
42 sockaddr sockaddr1;
43 sockaddr sockaddr2;
44 int32_t dScope = 0;
45 int32_t preFixLen = 0;
46 uint32_t key = 0;
47 name.SockAddrCopy(addrBuff, &sockaddr1, &sockaddr2, dScope, preFixLen, key);
48 }
49
LookUpNameParamTest001()50 void LookUpNameParamTest001()
51 {
52 NETNATIVE_LOGI("LookUpNameParamTest enter");
53 DnsLookUpName name;
54 const size_t addrDataSize = 5;
55 int32_t cnt = addrDataSize;
56 std::unique_ptr<AddrData[]> addrBuf = std::make_unique<AddrData[]>(addrDataSize);
57 memset_s(addrBuf.get(), sizeof(AddrData) * addrDataSize, 0, sizeof(AddrData) * addrDataSize);
58 addrBuf[0].family = AF_INET6;
59 addrBuf[1].family = AF_INET;
60 name.LookUpNameParam(addrBuf.get(), cnt, 0);
61 }
62 } // namespace
63 class DNSLookupNameTest : public testing::Test {
64 public:
65 static void SetUpTestCase();
66 static void TearDownTestCase();
67 void SetUp();
68 void TearDown();
69 };
70
SetUpTestCase()71 void DNSLookupNameTest::SetUpTestCase() {}
72
TearDownTestCase()73 void DNSLookupNameTest::TearDownTestCase() {}
74
SetUp()75 void DNSLookupNameTest::SetUp() {}
76
TearDown()77 void DNSLookupNameTest::TearDown() {}
78
79 HWTEST_F(DNSLookupNameTest, NameFromNullTest001, TestSize.Level1)
80 {
81 NETNATIVE_LOGI("NameFromNullTest invalid nns enter");
82 SockAddrCopy001();
83 DnsLookUpName name;
84 struct AddrData buf[2] = {};
85 std::string host = "a";
86 int32_t family = 0;
87 int32_t flag = 0;
88 int32_t ret = name.NameFromNull(buf, host, family, flag);
89 EXPECT_EQ(ret, DNS_ERR_NONE);
90 }
91
92 HWTEST_F(DNSLookupNameTest, NameFromNullTest002, TestSize.Level1)
93 {
94 NETNATIVE_LOGI("NameFromNullTest IPv4 AI_Passive enter");
95 DnsLookUpName name;
96 struct AddrData buf[2] = {};
97 std::string host = "";
98 int32_t family = AF_INET;
99 int32_t flag = AI_PASSIVE;
100 int32_t ret = name.NameFromNull(buf, host, family, flag);
101 EXPECT_EQ(ret, 1);
102 }
103
104 HWTEST_F(DNSLookupNameTest, NameFromNullTest003, TestSize.Level1)
105 {
106 NETNATIVE_LOGI("NameFromNullTest IPv6 AI_Passive enter");
107 DnsLookUpName name;
108 struct AddrData buf[2] = {};
109 std::string host = "";
110 int32_t family = AF_INET6;
111 int32_t flag = AI_PASSIVE;
112 int32_t ret = name.NameFromNull(buf, host, family, flag);
113 EXPECT_EQ(ret, 1);
114 }
115
116 HWTEST_F(DNSLookupNameTest, NameFromNullTest004, TestSize.Level1)
117 {
118 NETNATIVE_LOGI("NameFromNullTest IPv4 enter");
119 DnsLookUpName name;
120 struct AddrData buf[2] = {};
121 std::string host = "";
122 int32_t family = AF_INET;
123 int32_t flag = 0;
124 int32_t ret = name.NameFromNull(buf, host, family, flag);
125 EXPECT_EQ(ret, 1);
126 }
127
128 HWTEST_F(DNSLookupNameTest, NameFromNullTest005, TestSize.Level1)
129 {
130 NETNATIVE_LOGI("NameFromNullTest IPv4 enter");
131 DnsLookUpName name;
132 struct AddrData buf[2] = {};
133 std::string host = "";
134 int32_t family = AF_INET6;
135 int32_t flag = 0;
136 int32_t ret = name.NameFromNull(buf, host, family, flag);
137 EXPECT_EQ(ret, 1);
138 }
139
140 HWTEST_F(DNSLookupNameTest, NameFromDnsTest001, TestSize.Level1)
141 {
142 NETNATIVE_LOGI("NameFromDnsTest enter");
143 DnsLookUpName name;
144 struct AddrData addrData[48] = {};
145 char canon[256] = {0};
146 std::string host = "abcd";
147 int32_t family = AF_INET;
148 struct ResolvConf resolvConf = {};
149 int32_t netId = 101;
150 int32_t ret = name.NameFromDns(addrData, canon, host, family, &resolvConf, netId);
151 EXPECT_EQ(ret, EAI_AGAIN);
152 }
153
154 HWTEST_F(DNSLookupNameTest, NameFromDnsTest002, TestSize.Level1)
155 {
156 NETNATIVE_LOGI("NameFromDnsTest invalid host name enter");
157 DnsLookUpName name;
158 struct AddrData addrData[48] = {};
159 char canon[256] = {0};
160 std::string host = "";
161 int32_t family = AF_INET;
162 struct ResolvConf resolvConf = {};
163 int32_t netId = 101;
164 int32_t ret = name.NameFromDns(addrData, canon, host, family, &resolvConf, netId);
165 EXPECT_EQ(ret, EAI_AGAIN);
166 }
167
168 HWTEST_F(DNSLookupNameTest, NameFromDnsTest003, TestSize.Level1)
169 {
170 NETNATIVE_LOGI("NameFromDnsTest enter");
171 DnsLookUpName name;
172 struct AddrData addrData[48] = {};
173 char canon[256] = {0};
174 std::string host = "abcd";
175 int32_t family = AF_INET;
176 struct ResolvConf resolvConf = {};
177 int32_t netId = 101;
178 int32_t ret = name.NameFromDns(addrData, canon, host, family, &resolvConf, netId);
179 EXPECT_EQ(ret, EAI_AGAIN);
180 }
181
182 HWTEST_F(DNSLookupNameTest, NameFromDnsTest004, TestSize.Level1)
183 {
184 NETNATIVE_LOGI("NameFromDnsTest enter");
185 DnsLookUpName name;
186 struct AddrData addrData[48] = {};
187 char canon[256] = {0};
188 std::string host = "abcd";
189 int32_t family = 266;
190 struct ResolvConf resolvConf = {};
191 int32_t netId = 101;
192 int32_t ret = name.NameFromDns(addrData, canon, host, family, &resolvConf, netId);
193 EXPECT_EQ(ret, EAI_AGAIN);
194 }
195
196 HWTEST_F(DNSLookupNameTest, NameFromDnsTest005, TestSize.Level1)
197 {
198 DnsLookUpName name;
199 struct AddrData addrData[48] = {};
200 char canon[256] = {0};
201 std::string host = "abcd";
202 for (int32_t i = 0; i < HOST_MAX_LEN; i++) {
203 host.append("a");
204 }
205 int32_t family = 266;
206 struct ResolvConf resolvConf = {};
207 int32_t netId = 101;
208 int32_t ret = name.NameFromDns(addrData, canon, host, family, &resolvConf, netId);
209 EXPECT_EQ(ret, EAI_NONAME);
210 }
211
212 HWTEST_F(DNSLookupNameTest, NameFromDnsTest006, TestSize.Level1)
213 {
214 DnsLookUpName name;
215 struct AddrData addrData[48] = {};
216 char canon[256] = {0};
217 std::string host = "abcd";
218 for (int32_t i = 0; i < HOST_MAX_LEN / 2; i++) {
219 host.append("a");
220 }
221 int32_t family = AF_INET + 255;
222 struct ResolvConf resolvConf = {};
223 int32_t netId = 101;
224 int32_t ret = name.NameFromDns(addrData, canon, host, family, &resolvConf, netId);
225 EXPECT_EQ(ret, EAI_NONAME);
226 }
227
228 HWTEST_F(DNSLookupNameTest, NameFromDnsTest007, TestSize.Level1)
229 {
230 DnsLookUpName name;
231 AddrData addrData[48] = {};
232 for (int i = 0; i < 48; i++) {
233 addrData[i].family = AF_INET6;
234 }
235 char canon[256] = {0};
236 std::string host = "abcd";
237 for (int32_t i = 0; i < HOST_MAX_LEN / 2; i++) {
238 host.append("a");
239 }
240 int32_t family = AF_INET6;
241 struct ResolvConf resolvConf = {};
242 int32_t netId = 100;
243 int32_t ret = name.NameFromDns(addrData, canon, host, family, &resolvConf, netId);
244 EXPECT_EQ(ret, EAI_NONAME);
245 }
246
247 HWTEST_F(DNSLookupNameTest, NameFromDnsSearchTest001, TestSize.Level1)
248 {
249 NETNATIVE_LOGI("NameFromDnsSearchTest001 host is null enter");
250 DnsManager dnsManager;
251 std::vector<std::string> servers;
252 std::vector<std::string> domains;
253 dnsManager.SetResolverConfig(NET_ID, BASE_TIMEOUT_MILLIS, RETRY_COUNT, servers, domains);
254 DnsLookUpName name;
255 struct AddrData addrData[48] = {};
256 char canon[256] = {0};
257 std::string host = "";
258 int32_t family = AF_INET;
259 int32_t ret = name.NameFromDnsSearch(addrData, canon, host, family, NET_ID);
260 EXPECT_EQ(ret, EAI_NONAME);
261 }
262
263 HWTEST_F(DNSLookupNameTest, NameFromDnsSearchTest002, TestSize.Level1)
264 {
265 NETNATIVE_LOGI("NameFromDnsSearchTest001 host is baidu enter");
266 DnsManager dnsManager;
267 std::vector<std::string> servers;
268 std::vector<std::string> domains;
269 dnsManager.SetResolverConfig(NET_ID, BASE_TIMEOUT_MILLIS, RETRY_COUNT, servers, domains);
270 DnsLookUpName name;
271 struct AddrData addrData[48] = {};
272 char canon[256] = {0};
273 std::string host = "www.baidu.com";
274 int32_t family = AF_INET;
275 int32_t ret = name.NameFromDnsSearch(addrData, canon, host, family, NET_ID);
276 EXPECT_EQ(ret, EAI_NONAME);
277 }
278
279 HWTEST_F(DNSLookupNameTest, LabelOfTest001, TestSize.Level1)
280 {
281 NETNATIVE_LOGI("LabelOfTest001 enter");
282 DnsLookUpName name;
283 sockaddr_in6 da6 = {
284 .sin6_family = AF_INET6,
285 .sin6_port = PORT_NUM,
286 .sin6_scope_id = 1,
287 };
288 int32_t ret = name.LabelOf(&da6.sin6_addr);
289 EXPECT_EQ(ret, 1);
290 }
291
292 HWTEST_F(DNSLookupNameTest, ScopeOfTest001, TestSize.Level1)
293 {
294 DnsLookUpName instance;
295 in6_addr addr;
296 addr.s6_addr[0] = htonl(0xffc00000);
297 addr.s6_addr[ARG_INDEX_1] = 0x01;
298 auto ret = instance.ScopeOf(&addr);
299 EXPECT_EQ(ret, 0x01);
300 }
301
302 HWTEST_F(DNSLookupNameTest, ScopeOfTest002, TestSize.Level1)
303 {
304 DnsLookUpName instance;
305 in6_addr addr;
306 addr.s6_addr32[0] |= htonl(0xfe800000);
307 auto ret = instance.ScopeOf(&addr);
308 EXPECT_EQ(ret, SCOPEOF_RESULT_2);
309 }
310
311 HWTEST_F(DNSLookupNameTest, ScopeOfTest003, TestSize.Level1)
312 {
313 DnsLookUpName instance;
314 in6_addr addr;
315 addr.s6_addr32[0] = 0;
316 addr.s6_addr32[1] = 0;
317 addr.s6_addr32[2] = 0;
318 addr.s6_addr32[3] = htonl(1);
319 auto ret = instance.ScopeOf(&addr);
320 EXPECT_EQ(ret, SCOPEOF_RESULT_2);
321 }
322
323 HWTEST_F(DNSLookupNameTest, ScopeOfTest004, TestSize.Level1)
324 {
325 DnsLookUpName instance;
326 in6_addr addr;
327 addr.s6_addr32[0] = htonl(0xfec00000);
328 auto ret = instance.ScopeOf(&addr);
329 EXPECT_EQ(ret, SCOPEOF_RESULT_5);
330 }
331
332 HWTEST_F(DNSLookupNameTest, ScopeOfTest005, TestSize.Level1)
333 {
334 DnsLookUpName instance;
335 in6_addr addr;
336 addr.s6_addr[0] = 0xFF;
337 addr.s6_addr[1] = 0xFE;
338 addr.s6_addr[2] = 0x80;
339 addr.s6_addr[15] = 0x01;
340 auto ret = instance.ScopeOf(&addr);
341 EXPECT_EQ(ret, SCOPEOF_RESULT_14);
342 }
343
344 HWTEST_F(DNSLookupNameTest, PreFixMatchTest001, TestSize.Level1)
345 {
346 NETNATIVE_LOGI("PreFixMatchTest001 enter");
347 DnsLookUpName name;
348 sockaddr_in6 da6 = {
349 .sin6_family = AF_INET6,
350 .sin6_port = PORT_NUM,
351 .sin6_scope_id = 1,
352 };
353 int32_t ret = name.PreFixMatch(&da6.sin6_addr, &da6.sin6_addr);
354 EXPECT_EQ(ret, PREFIX_SIZE);
355 }
356
357 HWTEST_F(DNSLookupNameTest, CheckNameParamTest001, TestSize.Level1)
358 {
359 NETNATIVE_LOGI("CheckNameParamTest empty host name enter");
360 DnsLookUpName name;
361 std::string host = "";
362 int32_t family = AF_INET;
363 int32_t flag = 0xFFFF;
364 int32_t ret = name.CheckNameParam(host, flag, family);
365 EXPECT_EQ(ret, DNS_ERR_NONE);
366 }
367
368 HWTEST_F(DNSLookupNameTest, CheckNameParamTest002, TestSize.Level1)
369 {
370 NETNATIVE_LOGI("CheckNameParamTest IPv4 enter");
371 DnsLookUpName name;
372 std::string host = "abcd";
373 int32_t family = AF_INET;
374 int32_t flag = 0xFFFF;
375 int32_t ret = name.CheckNameParam(host, flag, family);
376 EXPECT_EQ(ret, DNS_ERR_NONE);
377 }
378
379 HWTEST_F(DNSLookupNameTest, CheckNameParamTest003, TestSize.Level1)
380 {
381 NETNATIVE_LOGI("CheckNameParamTest IPv6 enter");
382 DnsLookUpName name;
383 std::string host = "abcd";
384 int32_t family = AF_INET6;
385 int32_t flag = 0xFFFF;
386 int32_t ret = name.CheckNameParam(host, flag, family);
387 EXPECT_EQ(ret, DNS_ERR_NONE);
388 }
389
390 HWTEST_F(DNSLookupNameTest, CheckNameParamTest004, TestSize.Level1)
391 {
392 DnsLookUpName name;
393 std::string host = "a";
394 for (uint32_t i = 0; i <= 255; i++) {
395 host.append("a");
396 }
397 int32_t family = AF_INET;
398 int32_t flag = 0xFFFF;
399 int32_t ret = name.CheckNameParam(host, flag, family);
400 EXPECT_EQ(ret, EAI_NONAME);
401 }
402
403 HWTEST_F(DNSLookupNameTest, UpdateBufTest001, TestSize.Level1)
404 {
405 NETNATIVE_LOGI("UpdateBufTest IPv4 enter");
406 DnsLookUpName name;
407 struct AddrData sddrData = {};
408 int32_t family = AF_INET;
409 int32_t flag = 0xFFFF;
410 int32_t cnt = 1;
411 bool ret = name.UpdateBuf(flag, family, &sddrData, cnt);
412 EXPECT_EQ(ret, false);
413 }
414
415 HWTEST_F(DNSLookupNameTest, UpdateBufTest002, TestSize.Level1)
416 {
417 NETNATIVE_LOGI("UpdateBufTest IPv6 enter");
418 DnsLookUpName name;
419 struct AddrData sddrData = {};
420 int32_t family = AF_INET;
421 int32_t flag = 0xFFFF;
422 int32_t cnt = 2;
423 bool ret = name.UpdateBuf(flag, family, &sddrData, cnt);
424 EXPECT_EQ(ret, false);
425 }
426
427 HWTEST_F(DNSLookupNameTest, UpdateBufTest003, TestSize.Level1)
428 {
429 LookUpNameParamTest001();
430 DnsLookUpName name;
431 int32_t flags = AI_ALL;
432 int32_t family = AF_INET6;
433 const size_t addrDataSize = 5;
434 std::unique_ptr<AddrData[]> addrBuf = std::make_unique<AddrData[]>(addrDataSize);
435 addrBuf[0].family = AF_INET;
436 addrBuf[1].family = AF_INET6;
437 int32_t cnt = addrDataSize - 1;
438 auto ret = name.UpdateBuf(flags, family, addrBuf.get(), cnt);
439 EXPECT_TRUE(ret);
440 }
441
442 HWTEST_F(DNSLookupNameTest, LookUpNameTest001, TestSize.Level1)
443 {
444 NETNATIVE_LOGI("LookUpNameTest empty host name enter");
445 DnsLookUpName name;
446 struct AddrData addrData[48] = {};
447 char canon[256] = {0};
448 std::string host = "";
449 int32_t family = AF_INET;
450 int32_t flag = 0xFFFF;
451 int32_t netId = 101;
452 int32_t ret = name.LookUpName(addrData, canon, host, family, flag, netId);
453 EXPECT_EQ(ret, 1);
454 }
455
456 HWTEST_F(DNSLookupNameTest, LookUpNameTest002, TestSize.Level1)
457 {
458 NETNATIVE_LOGI("LookUpNameTest IPv4 enter");
459 DnsLookUpName name;
460 struct AddrData addrData[48] = {};
461 char canon[256] = {0};
462 std::string host = "abcd";
463 int32_t family = AF_INET;
464 int32_t flag = 0xFFFF;
465 int32_t netId = 101;
466 int32_t ret = name.LookUpName(addrData, canon, host, family, flag, netId);
467 EXPECT_EQ(ret, EAI_NONAME);
468 }
469
470 HWTEST_F(DNSLookupNameTest, LookUpNameTest003, TestSize.Level1)
471 {
472 NETNATIVE_LOGI("LookUpNameTest IPv6 enter");
473 DnsLookUpName name;
474 struct AddrData addrData[48] = {};
475 char canon[256] = {0};
476 std::string host = "abcd";
477 int32_t family = AF_INET6;
478 int32_t flag = 0xFFFF;
479 int32_t netId = 101;
480 int32_t ret = name.LookUpName(addrData, canon, host, family, flag, netId);
481 EXPECT_EQ(ret, EAI_NONAME);
482 }
483
484 HWTEST_F(DNSLookupNameTest, LookUpNameTest004, TestSize.Level1)
485 {
486 DnsLookUpName name;
487 struct AddrData addrData[48] = {};
488 char canon[256] = {0};
489 std::string host = "a";
490 for (uint32_t i = 0; i <= 255; i++) {
491 host.append("a");
492 }
493 int32_t family = AF_INET6;
494 int32_t flag = 0xFFFF;
495 int32_t netId = 101;
496 int32_t ret = name.LookUpName(addrData, canon, host, family, flag, netId);
497 EXPECT_EQ(ret, EAI_NONAME);
498 }
499
500 HWTEST_F(DNSLookupNameTest, SwitchSocketTypeTest001, TestSize.Level1)
501 {
502 NETNATIVE_LOGI("SwitchSocketTypeTest stream 0 enter");
503 DnsLookUpName name;
504 int32_t sockType = SOCK_STREAM;
505 int32_t proto = 0;
506 std::string host = "";
507 struct ServData buf = {};
508 int32_t ret = name.SwitchSocketType(sockType, host, proto, &buf);
509 EXPECT_EQ(ret, DNS_ERR_NONE);
510 }
511
512 HWTEST_F(DNSLookupNameTest, SwitchSocketTypeTest002, TestSize.Level1)
513 {
514 NETNATIVE_LOGI("SwitchSocketTypeTest stream TCP enter");
515 DnsLookUpName name;
516 int32_t sockType = SOCK_STREAM;
517 int32_t proto = IPPROTO_TCP;
518 std::string host = "";
519 struct ServData buf = {};
520 int32_t ret = name.SwitchSocketType(sockType, host, proto, &buf);
521 EXPECT_EQ(ret, DNS_ERR_NONE);
522 }
523
524 HWTEST_F(DNSLookupNameTest, SwitchSocketTypeTest003, TestSize.Level1)
525 {
526 NETNATIVE_LOGI("SwitchSocketTypeTest stream default enter");
527 DnsLookUpName name;
528 int32_t sockType = SOCK_STREAM;
529 int32_t proto = 88;
530 std::string host = "";
531 struct ServData buf = {};
532 int32_t ret = name.SwitchSocketType(sockType, host, proto, &buf);
533 EXPECT_EQ(ret, EAI_SERVICE);
534 }
535
536 HWTEST_F(DNSLookupNameTest, SwitchSocketTypeTest004, TestSize.Level1)
537 {
538 NETNATIVE_LOGI("SwitchSocketTypeTest dgram 0 enter");
539 DnsLookUpName name;
540 int32_t sockType = SOCK_DGRAM;
541 int32_t proto = 0;
542 std::string host = "";
543 struct ServData buf = {};
544 int32_t ret = name.SwitchSocketType(sockType, host, proto, &buf);
545 EXPECT_EQ(ret, DNS_ERR_NONE);
546 }
547
548 HWTEST_F(DNSLookupNameTest, SwitchSocketTypeTest005, TestSize.Level1)
549 {
550 NETNATIVE_LOGI("SwitchSocketTypeTest dgram udp enter");
551 DnsLookUpName name;
552 int32_t sockType = SOCK_DGRAM;
553 int32_t proto = IPPROTO_UDP;
554 std::string host = "";
555 struct ServData buf = {};
556 int32_t ret = name.SwitchSocketType(sockType, host, proto, &buf);
557 EXPECT_EQ(ret, DNS_ERR_NONE);
558 }
559
560 HWTEST_F(DNSLookupNameTest, SwitchSocketTypeTest006, TestSize.Level1)
561 {
562 NETNATIVE_LOGI("SwitchSocketTypeTest dgram default enter");
563 DnsLookUpName name;
564 int32_t sockType = SOCK_DGRAM;
565 int32_t proto = 88;
566 std::string host = "";
567 struct ServData buf = {};
568 int32_t ret = name.SwitchSocketType(sockType, host, proto, &buf);
569 EXPECT_EQ(ret, EAI_SERVICE);
570 }
571
572 HWTEST_F(DNSLookupNameTest, SwitchSocketTypeTest007, TestSize.Level1)
573 {
574 NETNATIVE_LOGI("SwitchSocketTypeTest default enter");
575 DnsLookUpName name;
576 int32_t sockType = 0;
577 int32_t proto = 0;
578 std::string host = "";
579 struct ServData buf = {};
580 int32_t ret = name.SwitchSocketType(sockType, host, proto, &buf);
581 EXPECT_EQ(ret, DNS_ERR_NONE);
582 }
583
584 HWTEST_F(DNSLookupNameTest, SwitchSocketTypeTest008, TestSize.Level1)
585 {
586 NETNATIVE_LOGI("SwitchSocketTypeTest host name empty enter");
587 DnsLookUpName name;
588 int32_t sockType = 88;
589 int32_t proto = 88;
590 std::string host = "";
591 struct ServData buf = {};
592 int32_t ret = name.SwitchSocketType(sockType, host, proto, &buf);
593 EXPECT_EQ(ret, DNS_ERR_NONE);
594 }
595
596 HWTEST_F(DNSLookupNameTest, SwitchSocketTypeTest009, TestSize.Level1)
597 {
598 NETNATIVE_LOGI("SwitchSocketTypeTest host name empty enter");
599 DnsLookUpName name;
600 int32_t sockType = 88;
601 int32_t proto = 88;
602 std::string host = "abcd";
603 struct ServData buf = {};
604 int32_t ret = name.SwitchSocketType(sockType, host, proto, &buf);
605 EXPECT_EQ(ret, EAI_SERVICE);
606 }
607
608 HWTEST_F(DNSLookupNameTest, LookUpServerTest001, TestSize.Level1)
609 {
610 NETNATIVE_LOGI("LookUpServerTest switch error enter");
611 DnsLookUpName name;
612 struct ServData servData[2] = {};
613 std::string host = "";
614 int32_t proto = 88;
615 int32_t sockType = SOCK_STREAM;
616 int32_t flag = 0;
617 int32_t ret = name.LookUpServer(servData, host, proto, sockType, flag);
618 EXPECT_EQ(ret, EAI_SERVICE);
619 }
620
621 HWTEST_F(DNSLookupNameTest, LookUpServerTest002, TestSize.Level1)
622 {
623 NETNATIVE_LOGI("LookUpServerTest host name empty enter");
624 DnsLookUpName name;
625 struct ServData servData[2] = {};
626 std::string host = "";
627 int32_t proto = IPPROTO_TCP;
628 int32_t sockType = SOCK_STREAM;
629 int32_t flag = 0;
630 int32_t ret = name.LookUpServer(servData, host, proto, sockType, flag);
631 EXPECT_EQ(ret, 1);
632 }
633
634 HWTEST_F(DNSLookupNameTest, AddrCmp001, TestSize.Level1)
635 {
636 DnsLookUpName name;
637 AddrData addrData1;
638 addrData1.sortKey = 2;
639 AddrData addrData2;
640 addrData2.sortKey = 2;
641 int ret = name.AddrCmp(&addrData1, &addrData2);
642 EXPECT_EQ(ret, 0);
643 }
644
645 HWTEST_F(DNSLookupNameTest, AddrCmp002, TestSize.Level1)
646 {
647 DnsLookUpName name;
648 AddrData addrData1;
649 addrData1.sortKey = 0;
650 AddrData addrData2;
651 addrData2.sortKey = 1;
652 int ret = name.AddrCmp(&addrData1, &addrData2);
653 EXPECT_EQ(ret, addrData2.sortKey - addrData1.sortKey);
654 }
655
656 HWTEST_F(DNSLookupNameTest, AddrCmp003, TestSize.Level1)
657 {
658 DnsLookUpName name;
659 AddrData addrData1;
660 addrData1.sortKey = 1;
661 AddrData addrData2;
662 addrData2.sortKey = 0;
663 int ret = name.AddrCmp(&addrData1, &addrData2);
664 EXPECT_EQ(ret, addrData2.sortKey - addrData1.sortKey);
665 }
666
667 HWTEST_F(DNSLookupNameTest, RefreshBuf001, TestSize.Level1)
668 {
669 DnsLookUpName name;
670 int32_t cnt = 2;
671 const size_t bufSize = 2;
672 AddrData buf[bufSize] = {};
673 buf[0].family = AF_INET6;
674 int32_t num = 0;
675 name.RefreshBuf(buf, num, cnt);
676 EXPECT_EQ(cnt, 1);
677 }
678 } // namespace NetsysNative
679 } // namespace OHOS