1 /*
2 * Copyright (C) 2023-2024 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 #include <thread>
18 #include <arpa/inet.h>
19
20 #ifdef GTEST_API_
21 #define private public
22 #define protected public
23 #endif
24
25 #include "mdns_client.h"
26 #include "mdns_client_resume.h"
27 #include "mdns_common.h"
28 #include "discovery_callback_stub.h"
29 #include "registration_callback_stub.h"
30 #include "resolve_callback_stub.h"
31 #include "mock_i_discovery_callback_test.h"
32 #include "net_conn_client.h"
33 #include "netmanager_ext_test_security.h"
34 #include "netmgr_ext_log_wrapper.h"
35 #include "refbase.h"
36 #include "mdns_protocol_impl.h"
37
38 namespace OHOS {
39 namespace NetManagerStandard {
40 using namespace testing::ext;
41
42 constexpr int DEMO_PORT = 12345;
43 constexpr int TIME_ONE_MS = 1;
44 constexpr int TIME_TWO_MS = 2;
45 constexpr int TIME_FOUR_MS = 4;
46 constexpr int TIME_FIVE_MS = 5;
47 constexpr uint32_t DEFAULT_LOST_MS = 20000;
48 constexpr const char *DEMO_NAME = "ala";
49 constexpr const char *DEMO_TYPE = "_hellomdns._tcp";
50 bool g_isScreenOn = true;
51 constexpr int PHASE_PTR = 1;
52 constexpr int PHASE_DOMAIN = 3;
53
54 static const TxtRecord g_txt{{"key", {'v', 'a', 'l', 'u', 'e'}}, {"null", {'\0'}}};
55
MilliSecondsSinceEpochTest()56 int64_t MilliSecondsSinceEpochTest()
57 {
58 return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
59 .count();
60 }
61
62 enum class EventType {
63 UNKNOWN,
64 REGISTER,
65 FOUND,
66 LOST,
67 RESOLVE,
68 };
69
70 std::mutex g_mtx;
71 std::condition_variable g_cv;
72 int g_register = 0;
73 int g_found = 0;
74 int g_lost = 0;
75 int g_resolve = 0;
76
77 class MDnsTestRegistrationCallback : public RegistrationCallbackStub {
78 public:
MDnsTestRegistrationCallback(const MDnsServiceInfo & info)79 explicit MDnsTestRegistrationCallback(const MDnsServiceInfo &info) : expected_(info) {}
80 virtual ~MDnsTestRegistrationCallback() = default;
HandleRegister(const MDnsServiceInfo & info,int32_t retCode)81 int32_t HandleRegister(const MDnsServiceInfo &info, int32_t retCode) override { return 0; }
HandleUnRegister(const MDnsServiceInfo & info,int32_t retCode)82 int32_t HandleUnRegister(const MDnsServiceInfo &info, int32_t retCode) override { return 0; }
HandleRegisterResult(const MDnsServiceInfo & info,int32_t retCode)83 int32_t HandleRegisterResult(const MDnsServiceInfo &info, int32_t retCode) override
84 {
85 g_mtx.lock();
86 EXPECT_EQ(retCode, NETMANAGER_EXT_SUCCESS);
87 std::cerr << "registered instance " << info.name + MDNS_DOMAIN_SPLITER_STR + info.type << "\n";
88 EXPECT_EQ(expected_.name, info.name);
89 EXPECT_EQ(expected_.type, info.type);
90 EXPECT_EQ(expected_.port, info.port);
91 g_register++;
92 g_mtx.unlock();
93 g_cv.notify_one();
94 return NETMANAGER_EXT_SUCCESS;
95 }
96 MDnsServiceInfo expected_;
97 };
98
99 class MDnsTestDiscoveryCallback : public DiscoveryCallbackStub {
100 public:
MDnsTestDiscoveryCallback(const std::vector<MDnsServiceInfo> & info)101 explicit MDnsTestDiscoveryCallback(const std::vector<MDnsServiceInfo> &info) : expected_(info) {}
102 virtual ~MDnsTestDiscoveryCallback() = default;
HandleStartDiscover(const MDnsServiceInfo & info,int32_t retCode)103 int32_t HandleStartDiscover(const MDnsServiceInfo &info, int32_t retCode) override { return 0; }
HandleStopDiscover(const MDnsServiceInfo & info,int32_t retCode)104 int32_t HandleStopDiscover(const MDnsServiceInfo &info, int32_t retCode) override { return 0; }
HandleServiceFound(const MDnsServiceInfo & info,int32_t retCode)105 int32_t HandleServiceFound(const MDnsServiceInfo &info, int32_t retCode) override
106 {
107 g_mtx.lock();
108 EXPECT_EQ(retCode, NETMANAGER_EXT_SUCCESS);
109 std::cerr << "found instance " << info.name + MDNS_DOMAIN_SPLITER_STR + info.type << "\n";
110 EXPECT_TRUE(std::find_if(expected_.begin(), expected_.end(),
111 [&](auto const &x) { return x.name == info.name; }) != expected_.end());
112 EXPECT_TRUE(std::find_if(expected_.begin(), expected_.end(),
113 [&](auto const &x) { return x.type == info.type; }) != expected_.end());
114 g_found++;
115 g_mtx.unlock();
116 g_cv.notify_one();
117 return NETMANAGER_EXT_SUCCESS;
118 }
119
HandleServiceLost(const MDnsServiceInfo & info,int32_t retCode)120 int32_t HandleServiceLost(const MDnsServiceInfo &info, int32_t retCode) override
121 {
122 g_mtx.lock();
123 EXPECT_EQ(retCode, NETMANAGER_EXT_SUCCESS);
124 std::cerr << "lost instance " << info.name + MDNS_DOMAIN_SPLITER_STR + info.type << "\n";
125 EXPECT_TRUE(std::find_if(expected_.begin(), expected_.end(),
126 [&](auto const &x) { return x.name == info.name; }) != expected_.end());
127 EXPECT_TRUE(std::find_if(expected_.begin(), expected_.end(),
128 [&](auto const &x) { return x.type == info.type; }) != expected_.end());
129 g_lost++;
130 g_mtx.unlock();
131 g_cv.notify_one();
132 return NETMANAGER_EXT_SUCCESS;
133 }
134 std::vector<MDnsServiceInfo> expected_;
135 };
136
137 class MDnsTestResolveCallback : public ResolveCallbackStub {
138 public:
MDnsTestResolveCallback(const MDnsServiceInfo & info)139 explicit MDnsTestResolveCallback(const MDnsServiceInfo &info) : expected_(info) {}
140 virtual ~MDnsTestResolveCallback() = default;
HandleResolveResult(const MDnsServiceInfo & info,int32_t retCode)141 int32_t HandleResolveResult(const MDnsServiceInfo &info, int32_t retCode) override
142 {
143 g_mtx.lock();
144 EXPECT_EQ(retCode, NETMANAGER_EXT_SUCCESS);
145 std::cerr << "resolved instance " << info.addr + MDNS_HOSTPORT_SPLITER_STR + std::to_string(info.port) << "\n";
146 EXPECT_EQ(expected_.name, info.name);
147 EXPECT_EQ(expected_.type, info.type);
148 EXPECT_EQ(expected_.port, info.port);
149 EXPECT_EQ(expected_.txtRecord, info.txtRecord);
150 g_resolve++;
151 g_mtx.unlock();
152 g_cv.notify_one();
153 return NETMANAGER_EXT_SUCCESS;
154 }
155 MDnsServiceInfo expected_;
156 };
157
158 class MDnsClientResumeTest : public testing::Test {
159 public:
160 static void SetUpTestCase();
161 static void TearDownTestCase();
162 void SetUp() override;
163 void TearDown() override;
164 };
165
SetUpTestCase()166 void MDnsClientResumeTest::SetUpTestCase() {}
167
TearDownTestCase()168 void MDnsClientResumeTest::TearDownTestCase() {}
169
SetUp()170 void MDnsClientResumeTest::SetUp() {}
171
TearDown()172 void MDnsClientResumeTest::TearDown() {}
173
174 class MDnsClientTest : public testing::Test {
175 public:
176 static void SetUpTestCase();
177 static void TearDownTestCase();
178 void SetUp() override;
179 void TearDown() override;
180 };
181
SetUpTestCase()182 void MDnsClientTest::SetUpTestCase() {}
183
TearDownTestCase()184 void MDnsClientTest::TearDownTestCase() {}
185
SetUp()186 void MDnsClientTest::SetUp() {}
187
TearDown()188 void MDnsClientTest::TearDown() {}
189
190 class MDnsServerTest : public testing::Test {
191 public:
192 static void SetUpTestCase();
193 static void TearDownTestCase();
194 void SetUp() override;
195 void TearDown() override;
196 };
197
SetUpTestCase()198 void MDnsServerTest::SetUpTestCase() {}
199
TearDownTestCase()200 void MDnsServerTest::TearDownTestCase() {}
201
SetUp()202 void MDnsServerTest::SetUp() {}
203
TearDown()204 void MDnsServerTest::TearDown() {}
205
206 class MDnsProtocolImplTest : public testing::Test {
207 public:
208 static void SetUpTestCase();
209 static void TearDownTestCase();
210 void SetUp() override;
211 void TearDown() override;
212 };
213
SetUpTestCase()214 void MDnsProtocolImplTest::SetUpTestCase() {}
215
TearDownTestCase()216 void MDnsProtocolImplTest::TearDownTestCase() {}
217
SetUp()218 void MDnsProtocolImplTest::SetUp() {}
219
TearDown()220 void MDnsProtocolImplTest::TearDown() {}
221
222
223 struct MdnsClientTestParams {
224 MDnsServiceInfo info;
225 MDnsServiceInfo infoBack;
226 sptr<MDnsTestRegistrationCallback> registration;
227 sptr<MDnsTestRegistrationCallback> registrationBack;
228 sptr<MDnsTestDiscoveryCallback> discovery;
229 sptr<MDnsTestDiscoveryCallback> discoveryBack;
230 sptr<MDnsTestResolveCallback> resolve;
231 sptr<MDnsTestResolveCallback> resolveBack;
232 };
233
DoTestForMdnsClient(MdnsClientTestParams param)234 void DoTestForMdnsClient(MdnsClientTestParams param)
235 {
236 NetManagerExtAccessToken token;
237 bool flag = false;
238 NetConnClient::GetInstance().HasDefaultNet(flag);
239 if (!flag) {
240 return;
241 }
242 std::unique_lock<std::mutex> lock(g_mtx);
243 DelayedSingleton<MDnsClient>::GetInstance()->RegisterService(param.info, param.registration);
244 DelayedSingleton<MDnsClient>::GetInstance()->RegisterService(param.infoBack, param.registrationBack);
245 if (!g_cv.wait_for(lock, std::chrono::seconds(TIME_FIVE_MS), []() { return g_register == TIME_TWO_MS; })) {
246 FAIL();
247 }
248 DelayedSingleton<MDnsClient>::GetInstance()->StartDiscoverService(param.info.type, param.discovery);
249 DelayedSingleton<MDnsClient>::GetInstance()->StartDiscoverService(param.info.type, param.discoveryBack);
250 if (!g_cv.wait_for(lock, std::chrono::seconds(TIME_FIVE_MS), []() { return g_found >= TIME_FOUR_MS; })) {
251 FAIL();
252 }
253 DelayedSingleton<MDnsClient>::GetInstance()->ResolveService(param.info, param.resolve);
254 if (!g_cv.wait_for(lock, std::chrono::seconds(TIME_FIVE_MS), []() { return g_resolve >= TIME_ONE_MS; })) {
255 FAIL();
256 }
257 DelayedSingleton<MDnsClient>::GetInstance()->ResolveService(param.infoBack, param.resolveBack);
258 if (!g_cv.wait_for(lock, std::chrono::seconds(TIME_FIVE_MS), []() { return g_resolve >= TIME_TWO_MS; })) {
259 FAIL();
260 }
261 DelayedSingleton<MDnsClient>::GetInstance()->StopDiscoverService(param.discovery);
262 DelayedSingleton<MDnsClient>::GetInstance()->StopDiscoverService(param.discoveryBack);
263 if (!g_cv.wait_for(lock, std::chrono::seconds(TIME_FIVE_MS), []() { return g_lost >= TIME_ONE_MS; })) {
264 FAIL();
265 }
266 DelayedSingleton<MDnsClient>::GetInstance()->UnRegisterService(param.registration);
267 DelayedSingleton<MDnsClient>::GetInstance()->UnRegisterService(param.registrationBack);
268
269 std::this_thread::sleep_for(std::chrono::seconds(TIME_ONE_MS));
270
271 DelayedSingleton<MDnsClient>::GetInstance()->RestartResume();
272 }
273
274 HWTEST_F(MDnsClientResumeTest, ResumeTest001, TestSize.Level1)
275 {
276 MDnsServiceInfo info;
277 MDnsServiceInfo infoBack;
278 info.name = DEMO_NAME;
279 info.type = DEMO_TYPE;
280 info.port = DEMO_PORT;
281 info.SetAttrMap(g_txt);
282
283 sptr<MDnsTestRegistrationCallback> registration(new (std::nothrow) MDnsTestRegistrationCallback(info));
284 sptr<MDnsTestDiscoveryCallback> discovery(new (std::nothrow) MDnsTestDiscoveryCallback({info, infoBack}));
285 ASSERT_NE(registration, nullptr);
286 ASSERT_NE(discovery, nullptr);
287
288 int32_t ret = MDnsClientResume::GetInstance().SaveRegisterService(info, registration);
289 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
290
291 ret = MDnsClientResume::GetInstance().SaveRegisterService(info, registration);
292 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
293
294 ret = MDnsClientResume::GetInstance().SaveStartDiscoverService(info.type, discovery);
295 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
296
297 ret = MDnsClientResume::GetInstance().SaveStartDiscoverService(info.type, discovery);
298 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
299
300 ret = MDnsClientResume::GetInstance().RemoveRegisterService(registration);
301 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
302
303 ret = MDnsClientResume::GetInstance().RemoveRegisterService(registration);
304 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
305
306 ret = MDnsClientResume::GetInstance().RemoveStopDiscoverService(discovery);
307 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
308
309 ret = MDnsClientResume::GetInstance().RemoveStopDiscoverService(discovery);
310 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
311
312 MDnsClientResume::GetInstance().ReRegisterService();
313
314 MDnsClientResume::GetInstance().RestartDiscoverService();
315 }
316
317 HWTEST_F(MDnsServerTest, ServerTest, TestSize.Level1)
318 {
319 MDnsServiceInfo info;
320 info.name = DEMO_NAME;
321 info.type = DEMO_TYPE;
322 info.port = DEMO_PORT;
323 TxtRecord txt{};
324 info.SetAttrMap(txt);
325 info.SetAttrMap(g_txt);
326 auto retMap = info.GetAttrMap();
327 EXPECT_NE(retMap.size(), 0);
328
329 MessageParcel parcel;
330 auto retMar = info.Marshalling(parcel);
331 EXPECT_EQ(retMar, true);
332
333 auto serviceInfo = info.Unmarshalling(parcel);
334 retMar = info.Marshalling(parcel, serviceInfo);
335 EXPECT_EQ(retMar, true);
336 }
337
338 /**
339 * @tc.name: MDnsCommonTest001
340 * @tc.desc: Test MDnsServerTest
341 * @tc.type: FUNC
342 */
343 HWTEST_F(MDnsServerTest, MDnsCommonTest001, TestSize.Level1)
344 {
345 std::string testStr = "abbcccddddcccbba";
346 for (size_t i = 0; i < testStr.size(); ++i) {
347 EXPECT_TRUE(EndsWith(testStr, testStr.substr(i)));
348 }
349
350 for (size_t i = 0; i < testStr.size(); ++i) {
351 EXPECT_TRUE(StartsWith(testStr, testStr.substr(0, testStr.size() - i)));
352 }
353
354 auto lhs = Split(testStr, 'c');
355 auto rhs = std::vector<std::string_view>{
356 "abb",
357 "dddd",
358 "bba",
359 };
360 EXPECT_EQ(lhs, rhs);
361 }
362
363 /**
364 * @tc.name: MDnsCommonTest002
365 * @tc.desc: Test MDnsServerTest
366 * @tc.type: FUNC
367 */
368 HWTEST_F(MDnsServerTest, MDnsCommonTest002, TestSize.Level1)
369 {
370 constexpr size_t isNameIndex = 1;
371 constexpr size_t isTypeIndex = 2;
372 constexpr size_t isInstanceIndex = 3;
373 constexpr size_t isDomainIndex = 4;
374 std::vector<std::tuple<std::string, bool, bool, bool, bool>> test = {
375 {"abbcccddddcccbba", true, false, false, true },
376 {"", false, false, false, true },
377 {"a.b", true, false, false, true },
378 {"_xxx.tcp", true, false, false, true },
379 {"xxx._tcp", true, false, false, true },
380 {"xxx.yyy", true, false, false, true },
381 {"xxx.yyy", true, false, false, true },
382 {"_xxx._yyy", true, false, false, true },
383 {"hello._ipp._tcp", true, false, true, true },
384 {"_x._y._tcp", true, false, true, true },
385 {"_ipp._tcp", true, true, false, true },
386 {"_http._tcp", true, true, false, true },
387 };
388
389 for (auto line : test) {
390 EXPECT_EQ(IsNameValid(std::get<0>(line)), std::get<isNameIndex>(line));
391 EXPECT_EQ(IsTypeValid(std::get<0>(line)), std::get<isTypeIndex>(line));
392 EXPECT_EQ(IsInstanceValid(std::get<0>(line)), std::get<isInstanceIndex>(line));
393 EXPECT_EQ(IsDomainValid(std::get<0>(line)), std::get<isDomainIndex>(line));
394 }
395
396 EXPECT_TRUE(IsPortValid(22));
397 EXPECT_TRUE(IsPortValid(65535));
398 EXPECT_TRUE(IsPortValid(0));
399 EXPECT_FALSE(IsPortValid(-1));
400 EXPECT_FALSE(IsPortValid(65536));
401 }
402
403 /**
404 * @tc.name: MDnsCommonTest003
405 * @tc.desc: Test MDnsServerTest
406 * @tc.type: FUNC
407 */
408 HWTEST_F(MDnsServerTest, MDnsCommonTest003, TestSize.Level1)
409 {
410 std::string instance = "hello._ipp._tcp";
411 std::string instance1 = "_x._y._tcp";
412 std::string name;
413 std::string type;
414 ExtractNameAndType(instance, name, type);
415 EXPECT_EQ(name, "hello");
416 EXPECT_EQ(type, "_ipp._tcp");
417
418 ExtractNameAndType(instance1, name, type);
419 EXPECT_EQ(name, "_x");
420 EXPECT_EQ(type, "_y._tcp");
421 }
422
423 HWTEST_F(MDnsServerTest, MDnsServerBranchTest001, TestSize.Level1)
424 {
425 std::string serviceType = "test";
426 sptr<IDiscoveryCallback> callback = new (std::nothrow) MockIDiscoveryCallbackTest();
427 EXPECT_TRUE(callback != nullptr);
428 if (callback == nullptr) {
429 return;
430 }
431 auto ret = DelayedSingleton<MDnsClient>::GetInstance()->StartDiscoverService(serviceType, callback);
432 EXPECT_EQ(ret, NET_MDNS_ERR_ILLEGAL_ARGUMENT);
433
434 ret = DelayedSingleton<MDnsClient>::GetInstance()->StopDiscoverService(callback);
435 EXPECT_EQ(ret, NET_MDNS_ERR_CALLBACK_NOT_FOUND);
436
437 callback = nullptr;
438 ret = DelayedSingleton<MDnsClient>::GetInstance()->StartDiscoverService(serviceType, callback);
439 EXPECT_EQ(ret, NET_MDNS_ERR_ILLEGAL_ARGUMENT);
440
441 ret = DelayedSingleton<MDnsClient>::GetInstance()->StopDiscoverService(callback);
442 EXPECT_EQ(ret, NET_MDNS_ERR_ILLEGAL_ARGUMENT);
443 }
444
445 /**
446 * @tc.name: MDnsProtocolImplCesTest001
447 * @tc.desc: Test SetScreenState
448 * @tc.type: FUNC
449 */
450 HWTEST_F(MDnsProtocolImplTest, MDnsProtocolImplCesTest001, TestSize.Level1)
451 {
452 MDnsProtocolImpl mDnsProtocolImpl;
453 mDnsProtocolImpl.SubscribeCes();
454
455 EXPECT_NE(mDnsProtocolImpl.subscriber_, nullptr);
456
457 mDnsProtocolImpl.SubscribeCes();
458 mDnsProtocolImpl.SetScreenState(true);
459 mDnsProtocolImpl.SetScreenState(false);
460 }
461
462 /**
463 * @tc.name: MDnsProtocolImplCesTest002
464 * @tc.desc: Test OnReceiveEvent
465 * @tc.type: FUNC
466 */
467 HWTEST_F(MDnsProtocolImplTest, MDnsProtocolImplCesTest002, TestSize.Level1)
468 {
469 MDnsProtocolImpl mDnsProtocolImpl;
470 mDnsProtocolImpl.SubscribeCes();
471
472 EventFwk::CommonEventData eventData;
473 EventFwk::Want want;
474 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON);
475 eventData.SetWant(want);
476 mDnsProtocolImpl.subscriber_->OnReceiveEvent(eventData);
477
478 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF);
479 eventData.SetWant(want);
480 mDnsProtocolImpl.subscriber_->OnReceiveEvent(eventData);
481
482 EXPECT_NE(mDnsProtocolImpl.subscriber_, nullptr);
483 }
484
485 HWTEST_F(MDnsClientTest, RegisterServiceTest001, TestSize.Level1)
486 {
487 MDnsClient mdnsclient;
488 MDnsServiceInfo serviceInfo;
489 serviceInfo.name = "1234";
490 serviceInfo.type = "_xyz._udp";
491 serviceInfo.port = 123;
492 sptr<IRegistrationCallback> cb;
493 EXPECT_EQ(mdnsclient.RegisterService(serviceInfo, cb), NET_MDNS_ERR_ILLEGAL_ARGUMENT);
494 serviceInfo.name = "12.34";
495 EXPECT_EQ(mdnsclient.RegisterService(serviceInfo, cb), NET_MDNS_ERR_ILLEGAL_ARGUMENT);
496 }
497
498 HWTEST_F(MDnsClientTest, UnRegisterServiceTest001, TestSize.Level1)
499 {
500 MDnsClient mdnsclient;
501 sptr<IRegistrationCallback> cb;
502 EXPECT_EQ(mdnsclient.UnRegisterService(cb), NET_MDNS_ERR_ILLEGAL_ARGUMENT);
503 }
504
505 HWTEST_F(MDnsClientTest, StartDiscoverServiceTest001, TestSize.Level1)
506 {
507 std::string serviceType = "_xyz._udp";
508 MDnsClient mdnsclient;
509 sptr<IDiscoveryCallback> cb;
510 EXPECT_EQ(mdnsclient.StartDiscoverService(serviceType, cb), NET_MDNS_ERR_ILLEGAL_ARGUMENT);
511 }
512
513 HWTEST_F(MDnsClientTest, ResolveServiceTest001, TestSize.Level1)
514 {
515 MDnsClient mdnsclient;
516 MDnsServiceInfo serviceInfo;
517 serviceInfo.name = "1234";
518 serviceInfo.type = "_xyz.udp";
519 serviceInfo.port = 123;
520 sptr<IResolveCallback> cb;
521 EXPECT_EQ(mdnsclient.ResolveService(serviceInfo, cb), NET_MDNS_ERR_ILLEGAL_ARGUMENT);
522 serviceInfo.name = "12.34";
523 EXPECT_EQ(mdnsclient.ResolveService(serviceInfo, cb), NET_MDNS_ERR_ILLEGAL_ARGUMENT);
524 serviceInfo.name = "1234";
525 serviceInfo.type = "_xyz._udp";
526 EXPECT_EQ(mdnsclient.ResolveService(serviceInfo, cb), NET_MDNS_ERR_ILLEGAL_ARGUMENT);
527 serviceInfo.name = "12.34";
528 EXPECT_EQ(mdnsclient.ResolveService(serviceInfo, cb), NET_MDNS_ERR_ILLEGAL_ARGUMENT);
529 }
530
531 HWTEST_F(MDnsProtocolImplTest, InitTest001, TestSize.Level0)
532 {
533 MDnsProtocolImpl mDnsProtocolImpl;
534 mDnsProtocolImpl.config_.configAllIface = false;
535 mDnsProtocolImpl.Init();
536 EXPECT_EQ(mDnsProtocolImpl.listener_.runningFlag_, true);
537 }
538
539 HWTEST_F(MDnsProtocolImplTest, BrowseTest001, TestSize.Level0)
540 {
541 MDnsProtocolImpl mDnsProtocolImpl;
542 mDnsProtocolImpl.lastRunTime = -1;
543 g_isScreenOn = true;
544 bool ret = mDnsProtocolImpl.Browse();
545 EXPECT_EQ(ret, false);
546 g_isScreenOn = false;
547 ret = mDnsProtocolImpl.Browse();
548 EXPECT_EQ(ret, false);
549
550 mDnsProtocolImpl.lastRunTime = 1;
551 g_isScreenOn = true;
552 ret = mDnsProtocolImpl.Browse();
553 EXPECT_EQ(ret, false);
554 g_isScreenOn = false;
555 ret = mDnsProtocolImpl.Browse();
556 EXPECT_EQ(ret, false);
557 }
558
559 HWTEST_F(MDnsProtocolImplTest, ConnectControlTest001, TestSize.Level0)
560 {
561 int32_t sockfd = 0;
562 sockaddr serverAddr;
563 MDnsProtocolImpl mDnsProtocolImpl;
564 int32_t result = mDnsProtocolImpl.ConnectControl(sockfd, &serverAddr);
565 EXPECT_EQ(result, NETMANAGER_EXT_ERR_INTERNAL);
566 }
567
568 HWTEST_F(MDnsProtocolImplTest, IsConnectivityTest001, TestSize.Level0)
569 {
570 MDnsProtocolImpl mDnsProtocolImpl;
571 bool result = mDnsProtocolImpl.IsConnectivity("", 1234);
572 EXPECT_FALSE(result);
573
574 result = mDnsProtocolImpl.IsConnectivity("192.168.1.1", 1234);
575 EXPECT_FALSE(result);
576 }
577
578 HWTEST_F(MDnsProtocolImplTest, HandleOfflineServiceTest001, TestSize.Level0)
579 {
580 MDnsProtocolImpl mDnsProtocolImpl;
581 std::vector<MDnsProtocolImpl::Result> res;
582 mDnsProtocolImpl.handleOfflineService("test_key", res);
583
584 MDnsProtocolImpl::Result result;
585 result.state = MDnsProtocolImpl::State::LIVE;
586 result.refrehTime = mDnsProtocolImpl.lastRunTime - DEFAULT_LOST_MS + 1;
587 res.push_back(result);
588 mDnsProtocolImpl.handleOfflineService("test_key", res);
589 EXPECT_EQ(mDnsProtocolImpl.lastRunTime, -1);
590 }
591
592 HWTEST_F(MDnsProtocolImplTest, RegisterAndUnregisterTest001, TestSize.Level0)
593 {
594 MDnsProtocolImpl mDnsProtocolImpl;
595 MDnsProtocolImpl::Result info;
596 info.serviceName = "test_service";
597 info.serviceType = "_test._tcp";
598 info.port = 1234;
599
600 std::vector<uint8_t> txtData;
601 std::string txtStr = "test_txt";
602 for (char c : txtStr) {
603 txtData.push_back(static_cast<uint8_t>(c));
604 }
605 info.txt = txtData;
606
607 auto ret = mDnsProtocolImpl.Register(info);
608 EXPECT_TRUE(ret == NETMANAGER_EXT_SUCCESS || ret == NET_MDNS_ERR_SEND);
609 std::string name = mDnsProtocolImpl.Decorated(info.serviceName + MDNS_DOMAIN_SPLITER_STR + info.serviceType);
610 EXPECT_NE(mDnsProtocolImpl.srvMap_.find(name), mDnsProtocolImpl.srvMap_.end());
611 EXPECT_EQ(mDnsProtocolImpl.Register(info), NET_MDNS_ERR_SERVICE_INSTANCE_DUPLICATE);
612
613 EXPECT_EQ(mDnsProtocolImpl.UnRegister(info.serviceName + MDNS_DOMAIN_SPLITER_STR + info.serviceType),
614 NETMANAGER_EXT_SUCCESS);
615 EXPECT_EQ(mDnsProtocolImpl.srvMap_.find(name), mDnsProtocolImpl.srvMap_.end());
616 EXPECT_EQ(mDnsProtocolImpl.UnRegister(info.serviceName), NET_MDNS_ERR_SERVICE_INSTANCE_NOT_FOUND);
617 }
618
619 HWTEST_F(MDnsProtocolImplTest, RegisterTest001, TestSize.Level0)
620 {
621 MDnsProtocolImpl mDnsProtocolImpl;
622 MDnsProtocolImpl::Result info;
623
624 info.serviceName = "";
625 info.serviceType = "_test._tcp";
626 info.port = 1234;
627 EXPECT_EQ(mDnsProtocolImpl.Register(info), NET_MDNS_ERR_ILLEGAL_ARGUMENT);
628
629 info.serviceName = "test_service";
630 info.serviceType = "_test";
631 EXPECT_EQ(mDnsProtocolImpl.Register(info), NET_MDNS_ERR_ILLEGAL_ARGUMENT);
632
633 info.serviceType = "_test._tcp";
634 info.port = -1;
635 EXPECT_EQ(mDnsProtocolImpl.Register(info), NET_MDNS_ERR_ILLEGAL_ARGUMENT);
636 }
637
638 HWTEST_F(MDnsProtocolImplTest, DiscoveryFromCacheTest001, TestSize.Level0) {
639 MDnsProtocolImpl mDnsProtocolImpl;
640 std::string serviceType = "_test._tcp";
641 std::string topDomain = "local";
642 mDnsProtocolImpl.config_.topDomain = topDomain;
643
644 std::string decoratedName = serviceType + topDomain;
645 MDnsProtocolImpl::Result result;
646 result.state = MDnsProtocolImpl::State::LIVE;
647 mDnsProtocolImpl.browserMap_[decoratedName].push_back(result);
648
649 class MockIDiscoveryCallback : public sptr<IDiscoveryCallback> {
650 public:
651 MockIDiscoveryCallback() = default;
652 ~MockIDiscoveryCallback() = default;
653
HandleServiceFound(const MDnsServiceInfo & info,int32_t code)654 void HandleServiceFound(const MDnsServiceInfo &info, int32_t code) {
655 EXPECT_EQ(code, NETMANAGER_EXT_SUCCESS);
656 }
657 };
658 MockIDiscoveryCallback mockCallback;
659 bool ret = mDnsProtocolImpl.DiscoveryFromCache(serviceType, mockCallback);
660 EXPECT_TRUE(ret);
661 EXPECT_FALSE(mDnsProtocolImpl.browserMap_[decoratedName].empty());
662
663 result.state = MDnsProtocolImpl::State::REMOVE;
664 mDnsProtocolImpl.browserMap_[decoratedName].push_back(result);
665 ret = mDnsProtocolImpl.DiscoveryFromCache(serviceType, mockCallback);
666 EXPECT_TRUE(ret);
667
668 result.state = MDnsProtocolImpl::State::DEAD;
669 mDnsProtocolImpl.browserMap_[decoratedName].push_back(result);
670 ret = mDnsProtocolImpl.DiscoveryFromCache(serviceType, mockCallback);
671 EXPECT_TRUE(ret);
672 }
673
674 HWTEST_F(MDnsProtocolImplTest, DiscoveryFromCacheTest002, TestSize.Level0) {
675 MDnsProtocolImpl mDnsProtocolImpl;
676 std::string serviceType = "nonexistent_service";
677 std::string topDomain = "local";
678 mDnsProtocolImpl.config_.topDomain = topDomain;
679
680 mDnsProtocolImpl.browserMap_.clear();
681 class MockIDiscoveryCallback : public sptr<IDiscoveryCallback> {
682 public:
683 MockIDiscoveryCallback() = default;
684 ~MockIDiscoveryCallback() = default;
685
HandleServiceFound(const MDnsServiceInfo & info,int32_t code)686 void HandleServiceFound(const MDnsServiceInfo &info, int32_t code) {
687 FAIL() << "Callback should not be called";
688 }
689 };
690 MockIDiscoveryCallback mockCallback;
691 bool ret = mDnsProtocolImpl.DiscoveryFromCache(serviceType, mockCallback);
692 EXPECT_FALSE(ret);
693 EXPECT_TRUE(mDnsProtocolImpl.browserMap_.empty());
694 }
695
696 HWTEST_F(MDnsProtocolImplTest, DiscoveryFromNetTest001, TestSize.Level0) {
697 MDnsProtocolImpl mDnsProtocolImpl;
698 std::string serviceType = "_test._tcp";
699 std::string topDomain = "local";
700 mDnsProtocolImpl.config_.topDomain = topDomain;
701
702 mDnsProtocolImpl.browserMap_.clear();
703 mDnsProtocolImpl.taskOnChange_.clear();
704 mDnsProtocolImpl.cacheMap_.clear();
705
706 class MockIDiscoveryCallback : public sptr<IDiscoveryCallback> {
707 public:
708 MockIDiscoveryCallback() = default;
709 ~MockIDiscoveryCallback() = default;
710
HandleServiceFound(const MDnsServiceInfo & info,int32_t code)711 void HandleServiceFound(const MDnsServiceInfo &info, int32_t code) {
712 EXPECT_EQ(code, NETMANAGER_EXT_SUCCESS);
713 }
714
HandleServiceLost(const MDnsServiceInfo & info,int32_t code)715 void HandleServiceLost(const MDnsServiceInfo &info, int32_t code) {
716 EXPECT_EQ(code, NETMANAGER_EXT_SUCCESS);
717 }
718 };
719 MockIDiscoveryCallback mockCallback;
720 bool ret = mDnsProtocolImpl.DiscoveryFromNet(serviceType, mockCallback);
721 EXPECT_TRUE(ret);
722 std::string decoratedName = serviceType + topDomain;
723 EXPECT_FALSE(mDnsProtocolImpl.browserMap_.find(decoratedName) == mDnsProtocolImpl.browserMap_.end());
724 EXPECT_FALSE(mDnsProtocolImpl.nameCbMap_.find(decoratedName) == mDnsProtocolImpl.nameCbMap_.end());
725 }
726
727 HWTEST_F(MDnsProtocolImplTest, ResolveInstanceFromCacheTest001, TestSize.Level0) {
728 MDnsProtocolImpl mDnsProtocolImpl;
729 std::string instanceName = "test_instance.local";
730 std::string domain = "test_domain.local";
731 std::string topDomain = "local";
732 mDnsProtocolImpl.config_.topDomain = topDomain;
733
734 class MockIResolveCallback : public sptr<IResolveCallback> {
735 public:
736 MockIResolveCallback() = default;
737 ~MockIResolveCallback() = default;
738
739 bool handleResolveResultCalled = false;
740
HandleResolveResult(const MDnsServiceInfo & info,int32_t code)741 void HandleResolveResult(const MDnsServiceInfo &info, int32_t code) {
742 handleResolveResultCalled = true;
743 }
744 };
745 MockIResolveCallback mockCallback;
746
747 MDnsProtocolImpl::Result result;
748 result.domain = domain;
749 result.addr = "192.168.1.1";
750 result.ipv6 = false;
751 result.ttl = 100;
752 result.refrehTime = MilliSecondsSinceEpochTest() - 50000;
753 mDnsProtocolImpl.cacheMap_[instanceName] = result;
754 bool ret = mDnsProtocolImpl.ResolveInstanceFromCache(instanceName, mockCallback);
755 EXPECT_TRUE(ret);
756 EXPECT_FALSE(mDnsProtocolImpl.taskQueue_.empty());
757 auto task = mDnsProtocolImpl.taskQueue_.front();
758 task();
759
760 mockCallback.handleResolveResultCalled = false;
761 mDnsProtocolImpl.taskQueue_.clear();
762 mDnsProtocolImpl.cacheMap_.clear();
763
764 result.domain = domain;
765 result.addr = "";
766 result.ipv6 = false;
767 result.ttl = 100;
768 result.refrehTime = MilliSecondsSinceEpochTest() - 50000;
769
770 mDnsProtocolImpl.cacheMap_[instanceName] = result;
771 ret = mDnsProtocolImpl.ResolveInstanceFromCache(instanceName, mockCallback);
772 EXPECT_TRUE(ret);
773 EXPECT_FALSE(mDnsProtocolImpl.taskOnChange_[domain].empty());
774 auto eventTask = mDnsProtocolImpl.taskOnChange_[domain].front();
775 eventTask();
776
777 mockCallback.handleResolveResultCalled = false;
778 mDnsProtocolImpl.taskQueue_.clear();
779 mDnsProtocolImpl.taskOnChange_.clear();
780 mDnsProtocolImpl.cacheMap_.clear();
781
782 ret = mDnsProtocolImpl.ResolveInstanceFromCache(instanceName, mockCallback);
783 EXPECT_FALSE(ret);
784 EXPECT_TRUE(mDnsProtocolImpl.taskQueue_.empty());
785 EXPECT_TRUE(mDnsProtocolImpl.taskOnChange_.empty());
786 }
787
788 HWTEST_F(MDnsProtocolImplTest, ResolveFromCacheTest001, TestSize.Level0) {
789 MDnsProtocolImpl mDnsProtocolImpl;
790 std::string domain = "nonexistent_domain";
791 mDnsProtocolImpl.browserMap_.clear();
792 class MockIResolveCallback : public sptr<IResolveCallback> {
793 public:
794 MockIResolveCallback() = default;
795 ~MockIResolveCallback() = default;
796
HandleResolveResult(const MDnsServiceInfo & info,int32_t code)797 void HandleResolveResult(const MDnsServiceInfo &info, int32_t code) {
798 FAIL() << "Callback should not be called";
799 }
800 };
801 MockIResolveCallback mockCallback;
802 bool ret = mDnsProtocolImpl.ResolveFromCache(domain, mockCallback);
803 EXPECT_FALSE(ret);
804 EXPECT_TRUE(mDnsProtocolImpl.browserMap_.empty());
805 }
806
807 HWTEST_F(MDnsProtocolImplTest, ResolveFromCacheTest002, TestSize.Level0) {
808 MDnsProtocolImpl mDnsProtocolImpl;
809 std::string domain = "valid_domain";
810 mDnsProtocolImpl.cacheMap_[domain].addr = "127.0.0.1";
811 mDnsProtocolImpl.cacheMap_[domain].ttl = 1000;
812 mDnsProtocolImpl.cacheMap_[domain].refrehTime = MilliSecondsSinceEpochTest() - 500;
813 mDnsProtocolImpl.browserMap_.clear();
814 class MockIResolveCallback : public sptr<IResolveCallback> {
815 public:
816 MockIResolveCallback() = default;
817 ~MockIResolveCallback() = default;
818
HandleResolveResult(const MDnsServiceInfo & info,int32_t code)819 void HandleResolveResult(const MDnsServiceInfo &info, int32_t code) {
820 FAIL() << "Callback should not be called";
821 }
822 };
823 MockIResolveCallback mockCallback;
824 bool ret = mDnsProtocolImpl.ResolveFromCache(domain, mockCallback);
825 EXPECT_TRUE(ret);
826 }
827
828 HWTEST_F(MDnsProtocolImplTest, ResolveInstanceTest001, TestSize.Level0) {
829 MDnsProtocolImpl mDnsProtocolImpl;
830 std::string instance = "valid._instance._udp";
831 class MockIResolveCallback : public sptr<IResolveCallback> {
832 public:
833 MockIResolveCallback() = default;
834 ~MockIResolveCallback() = default;
835
HandleResolveResult(const MDnsServiceInfo & info,int32_t code)836 void HandleResolveResult(const MDnsServiceInfo &info, int32_t code) {
837 FAIL() << "Callback should not be called";
838 }
839 };
840 MockIResolveCallback mockCallback;
841 int32_t ret = mDnsProtocolImpl.ResolveInstance(instance, mockCallback);
842 EXPECT_TRUE(ret == NETMANAGER_EXT_SUCCESS || ret == NET_MDNS_ERR_SEND);
843
844 instance = "";
845 ret = mDnsProtocolImpl.ResolveInstance(instance, mockCallback);
846 EXPECT_EQ(ret, NET_MDNS_ERR_ILLEGAL_ARGUMENT);
847
848 instance = "invalid_domain";
849 ret = mDnsProtocolImpl.ResolveInstance(instance, mockCallback);
850 EXPECT_EQ(ret, NET_MDNS_ERR_ILLEGAL_ARGUMENT);
851 }
852
853 HWTEST_F(MDnsServerTest, MDnsCommonTest004, TestSize.Level0)
854 {
855 std::string str = "abc";
856 std::string pat = "abcd";
857 EXPECT_FALSE(StartsWith(str, pat));
858
859 std::string instance = "1.2.3";
860 std::string name = "";
861 std::string type = "";
862 ExtractNameAndType(instance, name, type);
863 EXPECT_NE(name, "");
864
865 instance = "1.2.3.4.5";
866 name = "";
867 ExtractNameAndType(instance, name, type);
868 EXPECT_EQ(name, "");
869
870 instance = "1.2.3._tcp.4";
871 ExtractNameAndType(instance, name, type);
872 EXPECT_NE(name, "");
873 }
874
875 HWTEST_F(MDnsClientTest, IsKeyValueVaildTest001, TestSize.Level0)
876 {
877 MDnsServiceInfo serviceInfo;
878 std::string key = "";
879 std::vector<uint8_t> value;
880 EXPECT_FALSE(serviceInfo.IsKeyValueVaild(key, value));
881 key = "1234567890";
882 EXPECT_TRUE(serviceInfo.IsKeyValueVaild(key, value));
883 key = "\tdef";
884 EXPECT_FALSE(serviceInfo.IsKeyValueVaild(key, value));
885 key = "\x80";
886 EXPECT_FALSE(serviceInfo.IsKeyValueVaild(key, value));
887 key = "=";
888 EXPECT_FALSE(serviceInfo.IsKeyValueVaild(key, value));
889 key = "abc";
890 EXPECT_TRUE(serviceInfo.IsKeyValueVaild(key, value));
891 }
892
893 HWTEST_F(MDnsClientTest, GetAttrMapTest001, TestSize.Level0)
894 {
895 MDnsServiceInfo serviceInfo;
896 serviceInfo.txtRecord = {0};
897 auto result = serviceInfo.GetAttrMap();
898 EXPECT_TRUE(result.empty());
899 }
900
901 HWTEST_F(MDnsClientTest, SetAttrMapTest001, TestSize.Level0)
902 {
903 MDnsServiceInfo serviceInfo;
904 TxtRecord map;
905 map["abc=def"] = {};
906 serviceInfo.SetAttrMap(map);
907 EXPECT_FALSE(map.empty());
908 }
909
910 HWTEST_F(MDnsProtocolImplTest, ReceivePacketTest, TestSize.Level1) {
911 MDnsProtocolImpl mDnsProtocolImpl;
912 int sock = 0;
913 MDnsPayload payload;
914 mDnsProtocolImpl.ReceivePacket(sock, payload);
915 payload = {0x00, 0x00, 0x00, 0x00};
916 mDnsProtocolImpl.ReceivePacket(sock, payload);
917 payload = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
918 mDnsProtocolImpl.ReceivePacket(sock, payload);
919 EXPECT_EQ(mDnsProtocolImpl.lastRunTime, -1);
920 }
921
922 HWTEST_F(MDnsProtocolImplTest, ProcessQuestionTest, TestSize.Level1) {
923 MDnsProtocolImpl mDnsProtocolImpl;
924 int sock = 0;
925 MDnsMessage msg;
926 mDnsProtocolImpl.ProcessQuestion(sock, msg);
927 mDnsProtocolImpl.ProcessAnswer(sock, msg);
928 EXPECT_EQ(mDnsProtocolImpl.lastRunTime, -1);
929 }
930
931 HWTEST_F(MDnsProtocolImplTest, ProcessQuestionRecordTest, TestSize.Level1) {
932 MDnsProtocolImpl mDnsProtocolImpl;
933 MDnsMessage msg;
934 std::string serviceName = "test_service";
935 MDnsProtocolImpl::Result result;
936 result.port = 1234;
937 const char* txtData = "test_txt";
938 size_t txtLength = strlen(txtData);
939 result.txt = std::vector<unsigned char>(txtData, txtData + txtLength);
940 mDnsProtocolImpl.srvMap_[serviceName] = result;
941
942 DNSProto::Question qu;
943 qu.name = "example.local";
944 qu.qtype = DNSProto::RRTYPE_ANY;
945
946 std::any anyAddr = in_addr_t{INADDR_ANY};
947 DNSProto::RRType anyAddrType = DNSProto::RRTYPE_A;
948 int phase = 0;
949 MDnsMessage response;
950
951 mDnsProtocolImpl.ProcessQuestionRecord(anyAddr, anyAddrType, qu, phase, response);
952 EXPECT_GE(phase, PHASE_PTR);
953
954 qu.qtype = DNSProto::RRTYPE_PTR;
955 mDnsProtocolImpl.ProcessQuestionRecord(anyAddr, anyAddrType, qu, phase, response);
956 EXPECT_GE(phase, PHASE_PTR);
957
958 qu.name = "service1";
959 qu.qtype = DNSProto::RRTYPE_SRV;
960 mDnsProtocolImpl.ProcessQuestionRecord(anyAddr, anyAddrType, qu, phase, response);
961 EXPECT_EQ(phase, 1);
962
963 qu.name = "service1";
964 qu.qtype = DNSProto::RRTYPE_TXT;
965 mDnsProtocolImpl.ProcessQuestionRecord(anyAddr, anyAddrType, qu, phase, response);
966 EXPECT_EQ(phase, 1);
967
968 qu.name = mDnsProtocolImpl.GetHostDomain();
969 qu.qtype = DNSProto::RRTYPE_A;
970 in_addr_t ipv4Addr = INADDR_ANY;
971 anyAddr = ipv4Addr;
972 mDnsProtocolImpl.ProcessQuestionRecord(anyAddr, anyAddrType, qu, phase, response);
973 EXPECT_GE(phase, PHASE_DOMAIN);
974
975 qu.name = mDnsProtocolImpl.GetHostDomain();
976 qu.qtype = DNSProto::RRTYPE_AAAA;
977 in6_addr ipv6Addr = in6_addr();
978 anyAddr = ipv6Addr;
979 anyAddrType = DNSProto::RRTYPE_AAAA;
980 mDnsProtocolImpl.ProcessQuestionRecord(anyAddr, anyAddrType, qu, phase, response);
981 EXPECT_GE(phase, PHASE_DOMAIN);
982 }
983
984 HWTEST_F(MDnsProtocolImplTest, UpdatePtrTest_RdataNull, TestSize.Level1) {
985 MDnsProtocolImpl mDnsProtocolImpl;
986 DNSProto::ResourceRecord rr;
987 rr.name = "test";
988 rr.ttl = 100;
989 rr.length = 0;
990 rr.rdata = std::any();
991 std::set<std::string> changed;
992 mDnsProtocolImpl.UpdatePtr(false, rr, changed);
993 EXPECT_EQ(mDnsProtocolImpl.browserMap_.size(), 0);
994 EXPECT_EQ(changed.size(), 0);
995 rr.rdata = std::string("srv.example.com");
996 mDnsProtocolImpl.UpdatePtr(false, rr, changed);
997 EXPECT_EQ(mDnsProtocolImpl.browserMap_.size(), 0);
998 EXPECT_EQ(changed.size(), 0);
999 }
1000
1001 HWTEST_F(MDnsProtocolImplTest, UpdatePtrTest001, TestSize.Level1) {
1002 MDnsProtocolImpl mDnsProtocolImpl;
1003 DNSProto::ResourceRecord rr;
1004 rr.name = "test";
1005 rr.ttl = 100;
1006 rr.length = 0;
1007 rr.rdata = std::string("srv.example.com");
1008 std::set<std::string> changed;
1009 mDnsProtocolImpl.UpdatePtr(false, rr, changed);
1010 EXPECT_EQ(mDnsProtocolImpl.browserMap_.size(), 0);
1011 EXPECT_EQ(changed.size(), 0);
1012
1013 rr.rdata = std::string("");
1014 mDnsProtocolImpl.browserMap_["test"] = std::vector<MDnsProtocolImpl::Result>();
1015 mDnsProtocolImpl.UpdatePtr(false, rr, changed);
1016 EXPECT_EQ(mDnsProtocolImpl.browserMap_["test"].size(), 0);
1017 EXPECT_EQ(changed.size(), 0);
1018 }
1019
1020 HWTEST_F(MDnsProtocolImplTest, UpdatePtrTest002, TestSize.Level1) {
1021 MDnsProtocolImpl mDnsProtocolImpl;
1022 DNSProto::ResourceRecord rr;
1023 rr.name = "test";
1024 rr.ttl = 100;
1025 rr.length = 0;
1026 rr.rdata = std::string("srv.example.com");
1027 std::set<std::string> changed;
1028
1029 mDnsProtocolImpl.browserMap_["test"] = std::vector<MDnsProtocolImpl::Result>();
1030 mDnsProtocolImpl.UpdatePtr(false, rr, changed);
1031 EXPECT_EQ(mDnsProtocolImpl.browserMap_["test"].size(), 1);
1032 EXPECT_EQ(changed.size(), 1);
1033 EXPECT_EQ(changed.count("test"), 1);
1034
1035 mDnsProtocolImpl.browserMap_.clear();
1036 mDnsProtocolImpl.browserMap_["test1"] = std::vector<MDnsProtocolImpl::Result>
1037 {MDnsProtocolImpl::Result{.serviceName = "srv", .state = MDnsProtocolImpl::State::ADD}};
1038 mDnsProtocolImpl.UpdatePtr(false, rr, changed);
1039 EXPECT_EQ(mDnsProtocolImpl.browserMap_["test1"].size(), 1);
1040 EXPECT_EQ(changed.size(), 1);
1041 EXPECT_EQ(changed.count("test1"), 0);
1042 EXPECT_EQ(mDnsProtocolImpl.browserMap_["test1"][0].state, MDnsProtocolImpl::State::ADD);
1043 }
1044
1045 HWTEST_F(MDnsProtocolImplTest, UpdatePtrTest003, TestSize.Level1) {
1046 MDnsProtocolImpl mDnsProtocolImpl;
1047 DNSProto::ResourceRecord rr;
1048 rr.name = "test";
1049 rr.ttl = 100;
1050 rr.length = 0;
1051 rr.rdata = std::string("srv.example.com");
1052 std::set<std::string> changed;
1053 mDnsProtocolImpl.browserMap_["test"] = std::vector<MDnsProtocolImpl::Result>
1054 {MDnsProtocolImpl::Result{.serviceName = "srv", .state = MDnsProtocolImpl::State::DEAD}};
1055 mDnsProtocolImpl.UpdatePtr(false, rr, changed);
1056
1057 EXPECT_EQ(mDnsProtocolImpl.browserMap_["test"].size(), 1);
1058 EXPECT_EQ(changed.size(), 1);
1059 EXPECT_EQ(changed.count("test"), 1);
1060 EXPECT_EQ(mDnsProtocolImpl.browserMap_["test"][0].state, MDnsProtocolImpl::State::REFRESH);
1061
1062 rr.ttl = 0;
1063 mDnsProtocolImpl.browserMap_["test"] = std::vector<MDnsProtocolImpl::Result>
1064 {MDnsProtocolImpl::Result{.serviceName = "srv", .state = MDnsProtocolImpl::State::ADD}};
1065 mDnsProtocolImpl.UpdatePtr(false, rr, changed);
1066 EXPECT_EQ(mDnsProtocolImpl.browserMap_["test"].size(), 1);
1067 EXPECT_EQ(changed.size(), 1);
1068 EXPECT_EQ(changed.count("test"), 1);
1069 EXPECT_EQ(mDnsProtocolImpl.browserMap_["test"][0].state, MDnsProtocolImpl::State::REMOVE);
1070 }
1071
1072 HWTEST_F(MDnsProtocolImplTest, UpdateSrvTest001, TestSize.Level1) {
1073 MDnsProtocolImpl mDnsProtocolImpl;
1074 DNSProto::ResourceRecord rr;
1075 rr.name = "test";
1076 rr.ttl = 100;
1077 rr.length = 0;
1078 rr.rdata = std::string("invalid");
1079 std::set<std::string> changed;
1080
1081 mDnsProtocolImpl.UpdateSrv(false, rr, changed);
1082
1083 EXPECT_EQ(mDnsProtocolImpl.cacheMap_.size(), 0);
1084 EXPECT_EQ(changed.size(), 0);
1085 }
1086
1087 HWTEST_F(MDnsProtocolImplTest, UpdateSrvTest002, TestSize.Level1) {
1088 MDnsProtocolImpl mDnsProtocolImpl;
1089 DNSProto::ResourceRecord rr;
1090 rr.name = "test";
1091 rr.ttl = 100;
1092 rr.length = 0;
1093 DNSProto::RDataSrv srv;
1094 srv.name = "srv.example.com";
1095 srv.port = 1234;
1096 rr.rdata = srv;
1097 std::set<std::string> changed;
1098
1099 mDnsProtocolImpl.UpdateSrv(false, rr, changed);
1100
1101 EXPECT_EQ(mDnsProtocolImpl.cacheMap_.size(), 1);
1102 EXPECT_EQ(mDnsProtocolImpl.cacheMap_["test"].state, MDnsProtocolImpl::State::ADD);
1103 EXPECT_EQ(changed.size(), 1);
1104 EXPECT_EQ(changed.count("test"), 1);
1105 }
1106
1107 HWTEST_F(MDnsProtocolImplTest, UpdateSrvTest003, TestSize.Level1) {
1108 MDnsProtocolImpl mDnsProtocolImpl;
1109 DNSProto::ResourceRecord rr;
1110 rr.name = "test";
1111 rr.ttl = 100;
1112 rr.length = 0;
1113 DNSProto::RDataSrv srv;
1114 srv.name = "srv.example.com";
1115 srv.port = 1234;
1116 rr.rdata = srv;
1117 std::set<std::string> changed;
1118
1119 mDnsProtocolImpl.cacheMap_["test"] = MDnsProtocolImpl::Result {
1120 .serviceName = "srv",
1121 .serviceType = "_srv._tcp",
1122 .domain = "old.example.com",
1123 .port = 5678,
1124 .state = MDnsProtocolImpl::State::LIVE
1125 };
1126
1127 mDnsProtocolImpl.UpdateSrv(false, rr, changed);
1128
1129 EXPECT_EQ(mDnsProtocolImpl.cacheMap_["test"].domain, "srv.example.com");
1130 EXPECT_EQ(mDnsProtocolImpl.cacheMap_["test"].port, 1234);
1131 EXPECT_EQ(mDnsProtocolImpl.cacheMap_["test"].state, MDnsProtocolImpl::State::REFRESH);
1132 EXPECT_EQ(changed.size(), 1);
1133 EXPECT_EQ(changed.count("test"), 1);
1134 }
1135
1136 HWTEST_F(MDnsProtocolImplTest, UpdateSrvTest004, TestSize.Level1) {
1137 MDnsProtocolImpl mDnsProtocolImpl;
1138 DNSProto::ResourceRecord rr;
1139 rr.name = "test";
1140 rr.ttl = 0;
1141 rr.length = 0;
1142 DNSProto::RDataSrv srv;
1143 srv.name = "srv.example.com";
1144 srv.port = 1234;
1145 rr.rdata = srv;
1146 std::set<std::string> changed;
1147
1148 mDnsProtocolImpl.cacheMap_["test"] = MDnsProtocolImpl::Result {
1149 .serviceName = "srv",
1150 .serviceType = "_srv._tcp",
1151 .domain = "srv.example.com",
1152 .port = 1234,
1153 .state = MDnsProtocolImpl::State::LIVE
1154 };
1155
1156 mDnsProtocolImpl.UpdateSrv(false, rr, changed);
1157
1158 EXPECT_EQ(mDnsProtocolImpl.cacheMap_["test"].state, MDnsProtocolImpl::State::REMOVE);
1159 EXPECT_EQ(changed.size(), 1);
1160 EXPECT_EQ(changed.count("test"), 1);
1161 }
1162
1163 HWTEST_F(MDnsProtocolImplTest, UpdateSrvTest005, TestSize.Level1) {
1164 MDnsProtocolImpl mDnsProtocolImpl;
1165 DNSProto::ResourceRecord rr;
1166 rr.name = "test";
1167 rr.ttl = 100;
1168 rr.length = 0;
1169 DNSProto::RDataSrv srv;
1170 srv.name = "srv.example.com";
1171 srv.port = 1234;
1172 rr.rdata = srv;
1173 std::set<std::string> changed;
1174
1175 mDnsProtocolImpl.cacheMap_["test"] = MDnsProtocolImpl::Result {
1176 .serviceName = "srv",
1177 .serviceType = "_srv._tcp",
1178 .domain = "old.example.com",
1179 .port = 5678,
1180 .state = MDnsProtocolImpl::State::DEAD
1181 };
1182
1183 mDnsProtocolImpl.UpdateSrv(false, rr, changed);
1184
1185 EXPECT_EQ(mDnsProtocolImpl.cacheMap_["test"].domain, "srv.example.com");
1186 EXPECT_EQ(mDnsProtocolImpl.cacheMap_["test"].port, 1234);
1187 EXPECT_EQ(mDnsProtocolImpl.cacheMap_["test"].state, MDnsProtocolImpl::State::REFRESH);
1188 EXPECT_EQ(changed.size(), 1);
1189 EXPECT_EQ(changed.count("test"), 1);
1190 }
1191
1192 HWTEST_F(MDnsProtocolImplTest, UpdateSrvTest006, TestSize.Level1) {
1193 MDnsProtocolImpl mDnsProtocolImpl;
1194 DNSProto::ResourceRecord rr;
1195 rr.name = "test";
1196 rr.ttl = 100;
1197 rr.length = 0;
1198 DNSProto::RDataSrv srv;
1199 srv.name = "srv.example.com";
1200 srv.port = 1234;
1201 rr.rdata = srv;
1202 std::set<std::string> changed;
1203
1204 mDnsProtocolImpl.cacheMap_["test"] = MDnsProtocolImpl::Result {
1205 .serviceName = "srv",
1206 .serviceType = "_srv._tcp",
1207 .domain = "srv.example.com",
1208 .port = 1234,
1209 .state = MDnsProtocolImpl::State::LIVE
1210 };
1211
1212 mDnsProtocolImpl.UpdateSrv(false, rr, changed);
1213
1214 EXPECT_EQ(mDnsProtocolImpl.cacheMap_["test"].state, MDnsProtocolImpl::State::LIVE);
1215 EXPECT_EQ(changed.size(), 0);
1216 }
1217
1218 HWTEST_F(MDnsProtocolImplTest, UpdateTxtTest001, TestSize.Level1) {
1219 MDnsProtocolImpl mDnsProtocolImpl;
1220 DNSProto::ResourceRecord rr;
1221 rr.name = "test";
1222 rr.ttl = 100;
1223 rr.length = 0;
1224 rr.rdata = std::string("invalid");
1225 std::set<std::string> changed;
1226
1227 mDnsProtocolImpl.UpdateTxt(false, rr, changed);
1228
1229 EXPECT_EQ(mDnsProtocolImpl.cacheMap_.size(), 0);
1230 EXPECT_EQ(changed.size(), 0);
1231 }
1232
1233 HWTEST_F(MDnsProtocolImplTest, UpdateTxtTest002, TestSize.Level1) {
1234 MDnsProtocolImpl mDnsProtocolImpl;
1235 DNSProto::ResourceRecord rr;
1236 rr.name = "test";
1237 rr.ttl = 100;
1238 rr.length = 0;
1239 TxtRecordEncoded txt;
1240 txt = {0x6B, 0x65, 0x79, 0x00, 0x76, 0x61, 0x6C, 0x75, 0x65};
1241 rr.rdata = txt;
1242 std::set<std::string> changed;
1243
1244 mDnsProtocolImpl.UpdateTxt(false, rr, changed);
1245
1246 EXPECT_EQ(mDnsProtocolImpl.cacheMap_.size(), 1);
1247 EXPECT_EQ(mDnsProtocolImpl.cacheMap_["test"].state, MDnsProtocolImpl::State::ADD);
1248 EXPECT_EQ(changed.size(), 1);
1249 EXPECT_EQ(changed.count("test"), 1);
1250 }
1251
1252 HWTEST_F(MDnsProtocolImplTest, UpdateTxtTest003, TestSize.Level1) {
1253 MDnsProtocolImpl mDnsProtocolImpl;
1254 DNSProto::ResourceRecord rr;
1255 rr.name = "test";
1256 rr.ttl = 100;
1257 rr.length = 0;
1258 TxtRecordEncoded txt;
1259 txt = {0x6B, 0x65, 0x79, 0x00, 0x76, 0x61, 0x6C, 0x75, 0x65};
1260 rr.rdata = txt;
1261 std::set<std::string> changed;
1262
1263 mDnsProtocolImpl.cacheMap_["test"] = MDnsProtocolImpl::Result{
1264 .serviceName = "srv",
1265 .serviceType = "_srv._tcp",
1266 .txt = {0x6F, 0x6C, 0x64, 0x5F, 0x6B, 0x65, 0x79, 0x00, 0x6F,
1267 0x6C, 0x64, 0x5F, 0x76, 0x61, 0x6C, 0x75, 0x65},
1268 .state = MDnsProtocolImpl::State::LIVE
1269 };
1270
1271 mDnsProtocolImpl.UpdateTxt(false, rr, changed);
1272
1273 EXPECT_EQ(mDnsProtocolImpl.cacheMap_["test"].txt.size(), 9);
1274 EXPECT_EQ(mDnsProtocolImpl.cacheMap_["test"].state, MDnsProtocolImpl::State::REFRESH);
1275 EXPECT_EQ(changed.size(), 1);
1276 EXPECT_EQ(changed.count("test"), 1);
1277 }
1278
1279 HWTEST_F(MDnsProtocolImplTest, UpdateTxtTest004, TestSize.Level1) {
1280 MDnsProtocolImpl mDnsProtocolImpl;
1281 DNSProto::ResourceRecord rr;
1282 rr.name = "test";
1283 rr.ttl = 0;
1284 rr.length = 0;
1285 TxtRecordEncoded txt;
1286 txt = {0x6B, 0x65, 0x79, 0x00, 0x76, 0x61, 0x6C, 0x75, 0x65};
1287 rr.rdata = txt;
1288 std::set<std::string> changed;
1289
1290 mDnsProtocolImpl.cacheMap_["test"] = MDnsProtocolImpl::Result{
1291 .serviceName = "srv",
1292 .serviceType = "_srv._tcp",
1293 .txt = {0x6B, 0x65, 0x79, 0x00, 0x76, 0x61, 0x6C, 0x75, 0x65},
1294 .state = MDnsProtocolImpl::State::LIVE
1295 };
1296
1297 mDnsProtocolImpl.UpdateTxt(false, rr, changed);
1298
1299 EXPECT_EQ(mDnsProtocolImpl.cacheMap_["test"].state, MDnsProtocolImpl::State::REMOVE);
1300 EXPECT_EQ(changed.size(), 1);
1301 EXPECT_EQ(changed.count("test"), 1);
1302 }
1303
1304 HWTEST_F(MDnsProtocolImplTest, UpdateTxtTest005, TestSize.Level1) {
1305 MDnsProtocolImpl mDnsProtocolImpl;
1306 DNSProto::ResourceRecord rr;
1307 rr.name = "test";
1308 rr.ttl = 100;
1309 rr.length = 0;
1310 TxtRecordEncoded txt = {0x6B, 0x65, 0x79, 0x00, 0x76, 0x61, 0x6C, 0x75, 0x65};
1311 rr.rdata = txt;
1312 std::set<std::string> changed;
1313
1314 mDnsProtocolImpl.cacheMap_["test"] = MDnsProtocolImpl::Result{
1315 .serviceName = "srv",
1316 .serviceType = "_srv._tcp",
1317 .txt = {0x6F, 0x6C, 0x64, 0x5F, 0x6B, 0x65, 0x79, 0x00, 0x6F,
1318 0x6C, 0x64, 0x5F, 0x76, 0x61, 0x6C, 0x75, 0x65},
1319 .state = MDnsProtocolImpl::State::DEAD
1320 };
1321
1322 mDnsProtocolImpl.UpdateTxt(false, rr, changed);
1323
1324 EXPECT_EQ(mDnsProtocolImpl.cacheMap_["test"].state, MDnsProtocolImpl::State::REFRESH);
1325 EXPECT_EQ(changed.size(), 1);
1326 EXPECT_EQ(changed.count("test"), 1);
1327 }
1328
1329 HWTEST_F(MDnsProtocolImplTest, UpdateTxtTest006, TestSize.Level1) {
1330 MDnsProtocolImpl mDnsProtocolImpl;
1331 DNSProto::ResourceRecord rr;
1332 rr.name = "test";
1333 rr.ttl = 100;
1334 rr.length = 0;
1335 TxtRecordEncoded txt = {0x6B, 0x65, 0x79, 0x00, 0x76, 0x61, 0x6C, 0x75, 0x65};
1336 rr.rdata = txt;
1337 std::set<std::string> changed;
1338
1339 mDnsProtocolImpl.cacheMap_["test"] = MDnsProtocolImpl::Result {
1340 .serviceName = "srv",
1341 .serviceType = "_srv._tcp",
1342 .txt = {0x6B, 0x65, 0x79, 0x00, 0x76, 0x61, 0x6C, 0x75, 0x65},
1343 .state = MDnsProtocolImpl::State::LIVE
1344 };
1345
1346 mDnsProtocolImpl.UpdateTxt(false, rr, changed);
1347
1348 EXPECT_EQ(mDnsProtocolImpl.cacheMap_["test"].state, MDnsProtocolImpl::State::LIVE);
1349 EXPECT_EQ(changed.size(), 0);
1350 }
1351
1352 HWTEST_F(MDnsProtocolImplTest, UpdateAddrTest001, TestSize.Level1) {
1353 MDnsProtocolImpl mDnsProtocolImpl;
1354 DNSProto::ResourceRecord rr;
1355 rr.name = "test";
1356 rr.rtype = DNSProto::RRTYPE_A;
1357 rr.ttl = 100;
1358 rr.length = 0;
1359 rr.rdata = "192.168.1.1";
1360
1361 std::set<std::string> changed;
1362
1363 mDnsProtocolImpl.UpdateAddr(true, rr, changed);
1364
1365 EXPECT_EQ(mDnsProtocolImpl.cacheMap_.size(), 0);
1366 EXPECT_EQ(changed.size(), 0);
1367 }
1368
1369 HWTEST_F(MDnsProtocolImplTest, UpdateAddrTest002, TestSize.Level1) {
1370 MDnsProtocolImpl mDnsProtocolImpl;
1371 DNSProto::ResourceRecord rr;
1372 rr.name = "test";
1373 rr.rtype = DNSProto::RRTYPE_AAAA;
1374 rr.ttl = 100;
1375 rr.length = 0;
1376 rr.rdata = "";
1377
1378 std::set<std::string> changed;
1379
1380 mDnsProtocolImpl.UpdateAddr(true, rr, changed);
1381
1382 EXPECT_EQ(mDnsProtocolImpl.cacheMap_.size(), 0);
1383 EXPECT_EQ(changed.size(), 0);
1384 }
1385
1386 HWTEST_F(MDnsProtocolImplTest, UpdateAddrTest003, TestSize.Level1) {
1387 MDnsProtocolImpl mDnsProtocolImpl;
1388 DNSProto::ResourceRecord rr;
1389 rr.name = "testnew";
1390 rr.rtype = DNSProto::RRTYPE_AAAA;
1391 rr.ttl = 100;
1392 rr.length = 0;
1393
1394 in6_addr ipv6Addr;
1395 inet_pton(AF_INET6, "2001:0db8:85a3:0000:0000:8a2e:0370:7334", &ipv6Addr);
1396 rr.rdata = std::any(ipv6Addr);
1397
1398 mDnsProtocolImpl.cacheMap_.clear();
1399 std::set<std::string> changed;
1400
1401 mDnsProtocolImpl.UpdateAddr(true, rr, changed);
1402
1403 EXPECT_EQ(mDnsProtocolImpl.cacheMap_.size(), 1);
1404 EXPECT_EQ(changed.size(), 1);
1405 EXPECT_NE(changed.find("testnew"), changed.end());
1406
1407 const auto& result = mDnsProtocolImpl.cacheMap_.at("testnew");
1408 EXPECT_EQ(result.state, MDnsProtocolImpl::State::ADD);
1409 EXPECT_EQ(result.ipv6, true);
1410 EXPECT_EQ(result.addr, "2001:db8:85a3::8a2e:370:7334");
1411 EXPECT_EQ(result.ttl, 100);
1412 EXPECT_GT(result.refrehTime, 0);
1413 }
1414
1415 HWTEST_F(MDnsProtocolImplTest, UpdateAddrTest004, TestSize.Level1) {
1416 MDnsProtocolImpl mDnsProtocolImpl;
1417 DNSProto::ResourceRecord rr;
1418 rr.name = "testupdate";
1419 rr.rtype = DNSProto::RRTYPE_AAAA;
1420 rr.ttl = 100;
1421 rr.length = 0;
1422
1423 in6_addr oldIpv6Addr;
1424 inet_pton(AF_INET6, "2001:0db8:85a3:0000:0000:8a2e:0370:7334", &oldIpv6Addr);
1425 rr.rdata = std::any(oldIpv6Addr);
1426
1427 mDnsProtocolImpl.cacheMap_.clear();
1428 mDnsProtocolImpl.cacheMap_["testupdate"].addr = "2001:db8:85a3::8a2e:370:7334";
1429 mDnsProtocolImpl.cacheMap_["testupdate"].ipv6 = true;
1430 mDnsProtocolImpl.cacheMap_["testupdate"].state = MDnsProtocolImpl::State::DEAD;
1431
1432 std::set<std::string> changed;
1433 mDnsProtocolImpl.UpdateAddr(true, rr, changed);
1434
1435 EXPECT_EQ(mDnsProtocolImpl.cacheMap_.size(), 1);
1436 EXPECT_EQ(changed.size(), 1);
1437 EXPECT_NE(changed.find("testupdate"), changed.end());
1438
1439 const auto& result = mDnsProtocolImpl.cacheMap_.at("testupdate");
1440 EXPECT_EQ(result.state, MDnsProtocolImpl::State::REFRESH);
1441 EXPECT_EQ(result.ipv6, true);
1442 EXPECT_EQ(result.addr, "2001:db8:85a3::8a2e:370:7334");
1443 EXPECT_EQ(result.ttl, 100);
1444 EXPECT_GT(result.refrehTime, 0);
1445
1446 mDnsProtocolImpl.cacheMap_["testupdate"].addr = "2001:db8:85a3::8a2e:370:7334";
1447 mDnsProtocolImpl.cacheMap_["testupdate"].ipv6 = false;
1448 mDnsProtocolImpl.cacheMap_["testupdate"].state = MDnsProtocolImpl::State::ADD;
1449 mDnsProtocolImpl.UpdateAddr(true, rr, changed);
1450 EXPECT_EQ(result.ipv6, true);
1451
1452 mDnsProtocolImpl.cacheMap_["testupdate"].ipv6 = false;
1453 mDnsProtocolImpl.cacheMap_["testupdate"].state = MDnsProtocolImpl::State::DEAD;
1454 mDnsProtocolImpl.UpdateAddr(true, rr, changed);
1455 EXPECT_EQ(result.ipv6, true);
1456
1457 mDnsProtocolImpl.cacheMap_["testupdate"].addr = "2001:db8:85a3::8a2e:370:7335";
1458 mDnsProtocolImpl.cacheMap_["testupdate"].ipv6 = true;
1459 mDnsProtocolImpl.cacheMap_["testupdate"].state = MDnsProtocolImpl::State::DEAD;
1460 mDnsProtocolImpl.UpdateAddr(true, rr, changed);
1461 EXPECT_EQ(result.addr, "2001:db8:85a3::8a2e:370:7334");
1462
1463 mDnsProtocolImpl.cacheMap_["testupdate"].ipv6 = false;
1464 mDnsProtocolImpl.UpdateAddr(true, rr, changed);
1465 EXPECT_EQ(result.ipv6, true);
1466
1467 mDnsProtocolImpl.cacheMap_["testupdate"].ipv6 = true;
1468 mDnsProtocolImpl.cacheMap_["testupdate"].state = MDnsProtocolImpl::State::ADD;
1469 mDnsProtocolImpl.UpdateAddr(true, rr, changed);
1470
1471 mDnsProtocolImpl.cacheMap_["testupdate"].ipv6 = false;
1472 mDnsProtocolImpl.UpdateAddr(true, rr, changed);
1473 EXPECT_EQ(result.ipv6, true);
1474 }
1475
1476 HWTEST_F(MDnsProtocolImplTest, UpdateAddrTest005, TestSize.Level1) {
1477 MDnsProtocolImpl mDnsProtocolImpl;
1478 DNSProto::ResourceRecord rr;
1479 rr.name = "testupdate";
1480 rr.rtype = DNSProto::RRTYPE_AAAA;
1481 rr.ttl = 100;
1482 rr.length = 0;
1483
1484 in6_addr oldIpv6Addr;
1485 inet_pton(AF_INET6, "2001:0db8:85a3:0000:0000:8a2e:0370:7334", &oldIpv6Addr);
1486 rr.rdata = std::any(oldIpv6Addr);
1487
1488 mDnsProtocolImpl.cacheMap_.clear();
1489 mDnsProtocolImpl.cacheMap_["testupdate"].addr = "2001:db8:85a3::8a2e:370:7335";
1490 mDnsProtocolImpl.cacheMap_["testupdate"].ipv6 = false;
1491 mDnsProtocolImpl.cacheMap_["testupdate"].state = MDnsProtocolImpl::State::ADD;
1492 std::set<std::string> changed;
1493 mDnsProtocolImpl.UpdateAddr(true, rr, changed);
1494
1495 rr.ttl = 0;
1496 mDnsProtocolImpl.UpdateAddr(true, rr, changed);
1497 const auto& result = mDnsProtocolImpl.cacheMap_.at("testupdate");
1498 EXPECT_EQ(result.state, MDnsProtocolImpl::State::REMOVE);
1499
1500 mDnsProtocolImpl.cacheMap_["testupdate"].state = MDnsProtocolImpl::State::LIVE;
1501 mDnsProtocolImpl.UpdateAddr(true, rr, changed);
1502 }
1503
1504 HWTEST_F(MDnsProtocolImplTest, ProcessAnswerRecordTest001, TestSize.Level1) {
1505 MDnsProtocolImpl mDnsProtocolImpl;
1506 DNSProto::ResourceRecord rr;
1507 rr.name = "test";
1508 rr.rtype = DNSProto::RRTYPE_SRV;
1509 mDnsProtocolImpl.srvMap_["test"] = MDnsProtocolImpl::Result{};
1510 std::set<std::string> changed;
1511 mDnsProtocolImpl.ProcessAnswerRecord(false, rr, changed);
1512 EXPECT_TRUE(changed.empty());
1513 }
1514
1515 HWTEST_F(MDnsProtocolImplTest, ProcessAnswerRecordTest002, TestSize.Level1) {
1516 MDnsProtocolImpl mDnsProtocolImpl;
1517 DNSProto::ResourceRecord rr;
1518 rr.name = "test";
1519 rr.rtype = DNSProto::RRTYPE_PTR;
1520 mDnsProtocolImpl.cacheMap_["test"] = MDnsProtocolImpl::Result{};
1521 std::set<std::string> changed;
1522 mDnsProtocolImpl.ProcessAnswerRecord(false, rr, changed);
1523 EXPECT_GE(changed.size(), 0);
1524 }
1525
1526 HWTEST_F(MDnsProtocolImplTest, ProcessAnswerRecordTest003, TestSize.Level1) {
1527 MDnsProtocolImpl mDnsProtocolImpl;
1528 DNSProto::ResourceRecord rr;
1529 rr.name = "test";
1530 rr.rtype = DNSProto::RRTYPE_SRV;
1531 mDnsProtocolImpl.browserMap_["test"] = std::vector<MDnsProtocolImpl::Result>();
1532 std::set<std::string> changed;
1533 mDnsProtocolImpl.ProcessAnswerRecord(false, rr, changed);
1534 EXPECT_GE(changed.size(), 0);
1535
1536 rr.rtype = DNSProto::RRTYPE_TXT;
1537 mDnsProtocolImpl.ProcessAnswerRecord(false, rr, changed);
1538 EXPECT_GE(changed.size(), 0);
1539
1540 rr.rtype = DNSProto::RRTYPE_A;
1541 mDnsProtocolImpl.ProcessAnswerRecord(false, rr, changed);
1542 EXPECT_GE(changed.size(), 0);
1543
1544 rr.rtype = DNSProto::RRTYPE_AAAA;
1545 mDnsProtocolImpl.ProcessAnswerRecord(false, rr, changed);
1546 EXPECT_GE(changed.size(), 0);
1547 }
1548
1549 HWTEST_F(MDnsProtocolImplTest, ProcessAnswerRecordTest004, TestSize.Level1) {
1550 MDnsProtocolImpl mDnsProtocolImpl;
1551 DNSProto::ResourceRecord rr;
1552 rr.name = "test";
1553 rr.rtype = static_cast<DNSProto::RRType>(999);
1554 mDnsProtocolImpl.cacheMap_["test"] = MDnsProtocolImpl::Result{};
1555 std::set<std::string> changed;
1556 mDnsProtocolImpl.ProcessAnswerRecord(false, rr, changed);
1557 EXPECT_TRUE(changed.empty());
1558 }
1559
1560 HWTEST_F(MDnsProtocolImplTest, KillCacheTest001, TestSize.Level1) {
1561 MDnsProtocolImpl mDnsProtocolImpl;
1562 std::string key = "test1";
1563
1564 mDnsProtocolImpl.browserMap_[key].emplace_back();
1565 mDnsProtocolImpl.browserMap_[key].back().state = MDnsProtocolImpl::State::REMOVE;
1566
1567 mDnsProtocolImpl.cacheMap_[key].state = MDnsProtocolImpl::State::REMOVE;
1568 mDnsProtocolImpl.cacheMap_[key].ttl = 1000;
1569 mDnsProtocolImpl.cacheMap_[key].refrehTime = MilliSecondsSinceEpochTest() - 500;
1570
1571 mDnsProtocolImpl.KillCache(key);
1572
1573 EXPECT_TRUE(mDnsProtocolImpl.browserMap_[key].empty());
1574 EXPECT_FALSE(mDnsProtocolImpl.cacheMap_.count(key));
1575 }
1576
1577 HWTEST_F(MDnsProtocolImplTest, KillCacheTest002, TestSize.Level1) {
1578 MDnsProtocolImpl mDnsProtocolImpl;
1579 std::string key = "test2";
1580 mDnsProtocolImpl.browserMap_[key].emplace_back();
1581 mDnsProtocolImpl.browserMap_[key].back().state = MDnsProtocolImpl::State::REMOVE;
1582 mDnsProtocolImpl.cacheMap_.clear();
1583 mDnsProtocolImpl.KillCache(key);
1584
1585 EXPECT_TRUE(mDnsProtocolImpl.browserMap_[key].empty());
1586 EXPECT_FALSE(mDnsProtocolImpl.IsCacheAvailable(key));
1587 }
1588
1589 HWTEST_F(MDnsProtocolImplTest, KillCacheTest003, TestSize.Level1) {
1590 MDnsProtocolImpl mDnsProtocolImpl;
1591 std::string key = "test3";
1592 mDnsProtocolImpl.cacheMap_[key].state = MDnsProtocolImpl::State::ADD;
1593 mDnsProtocolImpl.cacheMap_[key].ttl = 1000;
1594 mDnsProtocolImpl.cacheMap_[key].refrehTime = MilliSecondsSinceEpochTest() - 500;
1595 mDnsProtocolImpl.KillCache(key);
1596 EXPECT_EQ(mDnsProtocolImpl.cacheMap_[key].state, MDnsProtocolImpl::State::LIVE);
1597 }
1598
1599 HWTEST_F(MDnsProtocolImplTest, KillCacheTest004, TestSize.Level1) {
1600 MDnsProtocolImpl mDnsProtocolImpl;
1601 std::string key = "test4";
1602 mDnsProtocolImpl.cacheMap_[key].state = MDnsProtocolImpl::State::REFRESH;
1603 mDnsProtocolImpl.cacheMap_[key].ttl = 1000;
1604 mDnsProtocolImpl.cacheMap_[key].refrehTime = MilliSecondsSinceEpochTest() - 500;
1605 mDnsProtocolImpl.KillCache(key);
1606 EXPECT_EQ(mDnsProtocolImpl.cacheMap_[key].state, MDnsProtocolImpl::State::LIVE);
1607 }
1608
1609 HWTEST_F(MDnsProtocolImplTest, KillCacheTest005, TestSize.Level1) {
1610 MDnsProtocolImpl mDnsProtocolImpl;
1611 std::string key = "test5";
1612 mDnsProtocolImpl.cacheMap_[key].state = MDnsProtocolImpl::State::ADD;
1613 mDnsProtocolImpl.cacheMap_[key].ttl = 1;
1614 mDnsProtocolImpl.cacheMap_[key].refrehTime = MilliSecondsSinceEpochTest() - 2000;
1615 mDnsProtocolImpl.KillCache(key);
1616 EXPECT_EQ(mDnsProtocolImpl.cacheMap_[key].state, MDnsProtocolImpl::State::ADD);
1617 }
1618
1619 HWTEST_F(MDnsProtocolImplTest, KillCacheTest006, TestSize.Level1) {
1620 MDnsProtocolImpl mDnsProtocolImpl;
1621 std::string key = "test6";
1622 mDnsProtocolImpl.cacheMap_[key].state = MDnsProtocolImpl::State::DEAD;
1623 mDnsProtocolImpl.cacheMap_[key].ttl = 1000;
1624 mDnsProtocolImpl.cacheMap_[key].refrehTime = MilliSecondsSinceEpochTest() - 500;
1625 mDnsProtocolImpl.KillCache(key);
1626 EXPECT_EQ(mDnsProtocolImpl.cacheMap_[key].state, MDnsProtocolImpl::State::DEAD);
1627 }
1628
1629 HWTEST_F(MDnsProtocolImplTest, KillBrowseCacheTest001, TestSize.Level1) {
1630 MDnsProtocolImpl mDnsProtocolImpl;
1631 std::string key = "test1";
1632 MDnsProtocolImpl::Result resultAdd;
1633 resultAdd.state = MDnsProtocolImpl::State::ADD;
1634 resultAdd.serviceName = "service1";
1635 resultAdd.serviceType = "_http._tcp";
1636 mDnsProtocolImpl.browserMap_[key].push_back(resultAdd);
1637 auto it = mDnsProtocolImpl.browserMap_[key].begin();
1638 mDnsProtocolImpl.KillBrowseCache(key, it);
1639 EXPECT_EQ(mDnsProtocolImpl.browserMap_[key].front().state, MDnsProtocolImpl::State::LIVE);
1640 }
1641
1642 HWTEST_F(MDnsProtocolImplTest, KillBrowseCacheTest002, TestSize.Level1) {
1643 MDnsProtocolImpl mDnsProtocolImpl;
1644 std::string key = "test2";
1645 MDnsProtocolImpl::Result resultRefresh;
1646 resultRefresh.state = MDnsProtocolImpl::State::REFRESH;
1647 resultRefresh.serviceName = "service2";
1648 resultRefresh.serviceType = "_http._tcp";
1649 mDnsProtocolImpl.browserMap_[key].push_back(resultRefresh);
1650 auto it = mDnsProtocolImpl.browserMap_[key].begin();
1651 mDnsProtocolImpl.KillBrowseCache(key, it);
1652 EXPECT_EQ(mDnsProtocolImpl.browserMap_[key].front().state, MDnsProtocolImpl::State::LIVE);
1653 }
1654
1655 HWTEST_F(MDnsProtocolImplTest, KillBrowseCacheTest003, TestSize.Level1) {
1656 MDnsProtocolImpl mDnsProtocolImpl;
1657 std::string key = "test3";
1658 MDnsProtocolImpl::Result resultRefresh;
1659 resultRefresh.state = MDnsProtocolImpl::State::REMOVE;
1660 resultRefresh.serviceName = "service3";
1661 resultRefresh.serviceType = "_http._tcp";
1662 mDnsProtocolImpl.browserMap_[key].push_back(resultRefresh);
1663 auto it = mDnsProtocolImpl.browserMap_[key].begin();
1664 mDnsProtocolImpl.KillBrowseCache(key, it);
1665 EXPECT_EQ(mDnsProtocolImpl.browserMap_[key].front().state, MDnsProtocolImpl::State::DEAD);
1666 }
1667
1668 HWTEST_F(MDnsProtocolImplTest, KillBrowseCacheTest004, TestSize.Level1) {
1669 MDnsProtocolImpl mDnsProtocolImpl;
1670 std::string key = "test4";
1671 MDnsProtocolImpl::Result resultRefresh;
1672 resultRefresh.state = MDnsProtocolImpl::State::DEAD;
1673 resultRefresh.serviceName = "service4";
1674 resultRefresh.serviceType = "_http._tcp";
1675 mDnsProtocolImpl.browserMap_[key].push_back(resultRefresh);
1676 auto it = mDnsProtocolImpl.browserMap_[key].begin();
1677 mDnsProtocolImpl.KillBrowseCache(key, it);
1678 EXPECT_EQ(mDnsProtocolImpl.browserMap_[key].front().state, MDnsProtocolImpl::State::DEAD);
1679 }
1680
1681 HWTEST_F(MDnsProtocolImplTest, StopCbMapTest001, TestSize.Level1) {
1682 MDnsProtocolImpl mDnsProtocolImpl;
1683 mDnsProtocolImpl.config_.topDomain = ".local";
1684 std::string serviceType = "_http._tcp";
1685 std::string name = mDnsProtocolImpl.Decorated(serviceType);
1686 int32_t ret = mDnsProtocolImpl.StopCbMap(serviceType);
1687 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1688 EXPECT_EQ(mDnsProtocolImpl.nameCbMap_.size(), 0);
1689 EXPECT_EQ(mDnsProtocolImpl.taskOnChange_.size(), 0);
1690 EXPECT_EQ(mDnsProtocolImpl.browserMap_.size(), 0);
1691 }
1692
1693 HWTEST_F(MDnsProtocolImplTest, StopCbMapTest002, TestSize.Level1) {
1694 MDnsProtocolImpl mDnsProtocolImpl;
1695 mDnsProtocolImpl.config_.topDomain = ".local";
1696 std::string serviceType = "_http._tcp";
1697 std::string name = mDnsProtocolImpl.Decorated(serviceType);
1698 MDnsProtocolImpl::Result result1, result2;
1699 result1.serviceName = "service1";
1700 result1.serviceType = serviceType;
1701 result2.serviceName = "service2";
1702 result2.serviceType = serviceType;
1703 mDnsProtocolImpl.browserMap_[name].push_back(result1);
1704 mDnsProtocolImpl.browserMap_[name].push_back(result2);
1705 int32_t ret = mDnsProtocolImpl.StopCbMap(serviceType);
1706 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1707 EXPECT_EQ(mDnsProtocolImpl.browserMap_.find(name), mDnsProtocolImpl.browserMap_.end());
1708 }
1709
1710 HWTEST_F(MDnsClientTest, RestartResumeTest001, TestSize.Level1)
1711 {
1712 MDnsClient mdnsclient;
1713 sptr<IRegistrationCallback> cb;
1714 mdnsclient.RestartResume();
1715 EXPECT_EQ(mdnsclient.UnRegisterService(cb), NET_MDNS_ERR_ILLEGAL_ARGUMENT);
1716 }
1717 } // namespace NetManagerStandard
1718 } // namespace OHOS