1 /*
2  * Copyright (c) 2022-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 
18 #ifdef GTEST_API_
19 #define private public
20 #define protected public
21 #endif
22 
23 #include "common_net_conn_callback_test.h"
24 #include "http_proxy.h"
25 #include "net_all_capabilities.h"
26 #include "net_conn_callback_stub.h"
27 #include "net_conn_client.h"
28 #include "net_conn_constants.h"
29 #include "net_conn_service.h"
30 #include "net_conn_types.h"
31 #include "net_detection_callback_test.h"
32 #include "net_factoryreset_callback_stub.h"
33 #include "net_http_proxy_tracker.h"
34 #include "net_interface_callback_stub.h"
35 #include "net_manager_center.h"
36 #include "net_mgr_log_wrapper.h"
37 #include "netsys_controller.h"
38 #include "system_ability_definition.h"
39 
40 namespace OHOS {
41 namespace NetManagerStandard {
42 namespace {
43 using namespace testing::ext;
44 constexpr uint32_t TEST_TIMEOUTMS = 1000;
45 constexpr int32_t TEST_NETID = 3;
46 constexpr int32_t TEST_SOCKETFD = 2;
47 const int32_t NET_ID = 2;
48 const int32_t SOCKET_FD = 2;
49 const int32_t ZERO_VALUE = 0;
50 const int32_t INVALID_VALUE = 10;
51 constexpr const char *TEST_IDENT = "testIdent";
52 constexpr const char *TEST_HOST = "testHost";
53 constexpr const char *TEST_PROXY_HOST = "testHttpProxy";
54 constexpr const char *TEST_IPV4_ADDR = "127.0.0.1";
55 constexpr const char *TEST_IPV6_ADDR = "240C:1:1:1::1";
56 constexpr const char *TEST_DOMAIN1 = ".com";
57 constexpr const char *TEST_DOMAIN2 = "test.com";
58 constexpr const char *TEST_DOMAIN3 = "testcom";
59 constexpr const char *TEST_DOMAIN4 = "com.test";
60 constexpr const char *TEST_DOMAIN5 = "test.co.uk";
61 constexpr const char *TEST_DOMAIN6 = "test.com.com";
62 constexpr const char *TEST_DOMAIN7 = "test1.test2.test3.test4.test5.com";
63 constexpr const char *TEST_DOMAIN8 = "http://www.example.com";
64 constexpr const char *TEST_DOMAIN9 = "https://www.example.com";
65 constexpr const char *TEST_DOMAIN10 = "httpd://www.example.com";
66 constexpr const char *TEST_LONG_HOST =
67     "0123456789qwertyuiopasdfghjklzxcvbnm[]:;<>?!@#$%^&()AEFFEqwdqwrtfasfj4897qwe465791qwr87tq4fq7t8qt4654qwr";
68 constexpr const char *TEST_LONG_EXCLUSION_LIST =
69     "www.test0.com,www.test1.com,www.test2.com,www.test3.com,www.test4.com,www.test5.com,www.test6.com,www.test7.com,"
70     "www.test8.com,www.test9.com,www.test10.com,www.test11.com,www.test12.com,www.test12.com,www.test12.com,www.test13."
71     "com,www.test14.com,www.test15.com,www.test16.com,www.test17.com,www.test18.com,www.test19.com,www.test20.com";
72 constexpr const char *NET_CONN_MANAGER_WORK_THREAD = "NET_CONN_MANAGER_WORK_THREAD";
73 constexpr int64_t TEST_UID = 1010;
74 constexpr uint32_t TEST_NOTEXISTSUPPLIER = 1000;
75 
76 class TestDnsService : public DnsBaseService {
77 public:
GetAddressesByName(const std::string & hostName,int32_t netId,std::vector<INetAddr> & addrInfo)78     int32_t GetAddressesByName(const std::string &hostName, int32_t netId,
79                                std::vector<INetAddr> &addrInfo) override
80     {
81         if (netId == TEST_NOTEXISTSUPPLIER) {
82             return NETMANAGER_ERROR;
83         } else if (netId == TEST_NETID) {
84             INetAddr netAddr;
85             netAddr.type_ = INetAddr::IPV4;
86             addrInfo.push_back(netAddr);
87         }
88         return NETSYS_SUCCESS;
89     }
90 };
91 
92 sptr<INetConnCallback> g_callback = new (std::nothrow) NetConnCallbackStubCb();
93 sptr<INetDetectionCallback> g_detectionCallback = new (std::nothrow) NetDetectionCallbackTest();
94 uint32_t g_supplierId = 0;
95 uint32_t g_vpnSupplierId = 0;
96 } // namespace
97 
98 class NetConnServiceTest : public testing::Test {
99 public:
100     static void SetUpTestCase();
101     static void TearDownTestCase();
102     void SetUp();
103     void TearDown();
104 };
105 
SetUpTestCase()106 void NetConnServiceTest::SetUpTestCase()
107 {
108     NetConnService::GetInstance()->OnStart();
109     if (NetConnService::GetInstance()->state_ != NetConnService::STATE_RUNNING) {
110         NetConnService::GetInstance()->netConnEventRunner_ =
111             AppExecFwk::EventRunner::Create(NET_CONN_MANAGER_WORK_THREAD);
112         ASSERT_NE(NetConnService::GetInstance()->netConnEventRunner_, nullptr);
113         NetConnService::GetInstance()->netConnEventHandler_ =
114             std::make_shared<NetConnEventHandler>(NetConnService::GetInstance()->netConnEventRunner_);
115         NetConnService::GetInstance()->serviceIface_ = std::make_unique<NetConnServiceIface>().release();
116         NetManagerCenter::GetInstance().RegisterConnService(NetConnService::GetInstance()->serviceIface_);
117         NetHttpProxyTracker httpProxyTracker;
118         HttpProxy httpProxy;
119         httpProxy.SetPort(0);
120         httpProxyTracker.ReadFromSettingsData(httpProxy);
121         NetConnService::GetInstance()->SendHttpProxyChangeBroadcast(httpProxy);
122     }
123 }
124 
TearDownTestCase()125 void NetConnServiceTest::TearDownTestCase() {}
126 
SetUp()127 void NetConnServiceTest::SetUp() {}
128 
TearDown()129 void NetConnServiceTest::TearDown() {}
130 
131 HWTEST_F(NetConnServiceTest, OnRemoveSystemAbility001, TestSize.Level1)
132 {
133     std::string deviceId = "dev1";
134     NetConnService::GetInstance()->OnRemoveSystemAbility(COMM_NETSYS_NATIVE_SYS_ABILITY_ID, deviceId);
135     EXPECT_TRUE(NetConnService::GetInstance()->hasSARemoved_);
136 }
137 
138 HWTEST_F(NetConnServiceTest, OnAddSystemAbility001, TestSize.Level1)
139 {
140     std::string deviceId = "dev1";
141     NetConnService::GetInstance()->OnAddSystemAbility(COMM_NETSYS_NATIVE_SYS_ABILITY_ID, deviceId);
142     EXPECT_FALSE(NetConnService::GetInstance()->hasSARemoved_);
143 }
144 
145 HWTEST_F(NetConnServiceTest, IsSupplierMatchRequestAndNetworkTest001, TestSize.Level1)
146 {
147     sptr<NetSupplier> supplier = nullptr;
148     bool ret = NetConnService::GetInstance()->IsSupplierMatchRequestAndNetwork(supplier);
149     EXPECT_FALSE(ret);
150 
151     NetConnService::GetInstance()->CreateDefaultRequest();
152     ret = NetConnService::GetInstance()->IsSupplierMatchRequestAndNetwork(supplier);
153     EXPECT_FALSE(ret);
154 }
155 
156 HWTEST_F(NetConnServiceTest, SystemReadyTest001, TestSize.Level1)
157 {
158     if (!NetConnService::GetInstance()->registerToService_) {
159         NetConnService::GetInstance()->state_ = NetConnService::STATE_RUNNING;
160     }
161 
162     NetConnService::GetInstance()->OnStart();
163     int32_t ret = NetConnService::GetInstance()->SystemReady();
164     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
165 }
166 
167 HWTEST_F(NetConnServiceTest, SetInternetPermissionTest001, TestSize.Level1)
168 {
169     uint8_t allow = 1;
170     int32_t ret = NetConnService::GetInstance()->SetInternetPermission(TEST_UID, allow);
171     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
172 }
173 
174 HWTEST_F(NetConnServiceTest, GetDefaultNetTest000, TestSize.Level1)
175 {
176     int32_t netId = 0;
177     auto ret = NetConnService::GetInstance()->GetDefaultNet(netId);
178     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
179 }
180 
181 HWTEST_F(NetConnServiceTest, RegisterNetSupplierTest001, TestSize.Level1)
182 {
183     std::set<NetCap> netCaps;
184     netCaps.insert(NetCap::NET_CAPABILITY_MMS);
185     netCaps.insert(NetCap::NET_CAPABILITY_INTERNET);
186     int32_t ret = NetConnService::GetInstance()->RegisterNetSupplier(NetBearType::BEARER_DEFAULT, TEST_IDENT,
187         netCaps, g_supplierId);
188     EXPECT_EQ(ret, NET_CONN_ERR_NET_TYPE_NOT_FOUND);
189 
190     ret = NetConnService::GetInstance()->RegisterNetSupplier(NetBearType::BEARER_ETHERNET, TEST_IDENT,
191         netCaps, g_supplierId);
192     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
193 
194     ret = NetConnService::GetInstance()->RegisterNetSupplier(NetBearType::BEARER_VPN, TEST_IDENT,
195         netCaps, g_vpnSupplierId);
196     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
197 }
198 
199 HWTEST_F(NetConnServiceTest, RegisterNetSupplierTest002, TestSize.Level1)
200 {
201     std::set<NetCap> netCaps;
202     netCaps.insert(NetCap::NET_CAPABILITY_INTERNAL_DEFAULT);
203     netCaps.insert(NetCap::NET_CAPABILITY_INTERNET);
204     auto ret = NetConnService::GetInstance()->RegisterNetSupplier(NetBearType::BEARER_CELLULAR, TEST_IDENT,
205         netCaps, g_supplierId);
206     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
207 }
208 
209 HWTEST_F(NetConnServiceTest, RegisterNetSupplierCallbackTest001, TestSize.Level1)
210 {
211     sptr<INetSupplierCallback> callback = new (std::nothrow) NetSupplierCallbackStubTestCb();
212     ASSERT_NE(callback, nullptr);
213     std::set<NetCap> netCaps;
214     auto ret = NetConnService::GetInstance()->RegisterNetSupplierCallback(g_supplierId, callback);
215     EXPECT_EQ(ret, NETSYS_SUCCESS);
216 }
217 
218 HWTEST_F(NetConnServiceTest, UpdateNetSupplierInfoTest001, TestSize.Level1)
219 {
220     sptr<NetSupplierInfo> netSupplierInfo = nullptr;
221     auto ret = NetConnService::GetInstance()->UpdateNetSupplierInfo(g_supplierId, netSupplierInfo);
222     EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
223 
224     netSupplierInfo = new (std::nothrow) NetSupplierInfo();
225     ASSERT_NE(netSupplierInfo, nullptr);
226     ret = NetConnService::GetInstance()->UpdateNetSupplierInfo(TEST_NOTEXISTSUPPLIER, netSupplierInfo);
227     EXPECT_EQ(ret, NET_CONN_ERR_NO_SUPPLIER);
228 
229     netSupplierInfo->isAvailable_ = true;
230     netSupplierInfo->uid_ = TEST_UID;
231     netSupplierInfo->ident_ = "0";
232     ret = NetConnService::GetInstance()->UpdateNetSupplierInfo(g_vpnSupplierId, netSupplierInfo);
233     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
234 
235     netSupplierInfo->isAvailable_ = false;
236     netSupplierInfo->ident_ = "";
237     ret = NetConnService::GetInstance()->UpdateNetSupplierInfo(g_vpnSupplierId, netSupplierInfo);
238     EXPECT_EQ(ret, NETSYS_SUCCESS);
239 }
240 
241 HWTEST_F(NetConnServiceTest, UpdateNetLinkInfoTest001, TestSize.Level1)
242 {
243     sptr<NetLinkInfo> netLinkInfo = nullptr;
244     auto ret = NetConnService::GetInstance()->UpdateNetLinkInfo(g_supplierId, netLinkInfo);
245     EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
246 
247     netLinkInfo = new (std::nothrow) NetLinkInfo();
248     ret = NetConnService::GetInstance()->UpdateNetLinkInfo(TEST_NOTEXISTSUPPLIER, netLinkInfo);
249     EXPECT_EQ(ret, NET_CONN_ERR_NO_SUPPLIER);
250 
251     ASSERT_NE(netLinkInfo, nullptr);
252     netLinkInfo->httpProxy_.SetHost(TEST_HOST);
253     ret = NetConnService::GetInstance()->UpdateNetLinkInfo(g_supplierId, netLinkInfo);
254     EXPECT_EQ(ret, NETSYS_SUCCESS);
255 }
256 
257 HWTEST_F(NetConnServiceTest, UpdateNetLinkInfoTest002, TestSize.Level1)
258 {
259     sptr<NetLinkInfo> netLinkInfo = new (std::nothrow) NetLinkInfo();
260     netLinkInfo->ifaceName_ = "rmnet0";
261     INetAddr netAddr;
262     netAddr.type_ = INetAddr::IPV4;
263     netAddr.hostName_ = "testHost";
264     netLinkInfo->netAddrList_.push_back(netAddr);
265     auto ret = NetConnService::GetInstance()->UpdateNetLinkInfo(g_supplierId, netLinkInfo);
266     EXPECT_EQ(ret, NETSYS_SUCCESS);
267     ret = NetConnService::GetInstance()->IsIfaceNameInUse("rmnet0", 1);
268     EXPECT_FALSE(ret);
269     ret = NetConnService::GetInstance()->IsIfaceNameInUse("rmnet0", 100);
270     EXPECT_FALSE(ret);
271 
272     ret = NetConnService::GetInstance()->IsAddrInOtherNetwork("rmnet0", 1, netAddr);
273     EXPECT_FALSE(ret);
274     ret = NetConnService::GetInstance()->IsAddrInOtherNetwork("rmnet0", 100, netAddr);
275     EXPECT_TRUE(ret);
276 }
277 
278 HWTEST_F(NetConnServiceTest, RequestNetConnectionTest002, TestSize.Level1)
279 {
280     sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
281     int64_t TEST_CALLBACK_UID = 1111;
282     auto ret = -1;
283     vector<sptr<INetConnCallback>> uidCallbacks;
284     for (int32_t i = 1; i <= 2000; ++i) {
285         sptr<INetConnCallback> uidCallback = new (std::nothrow) NetConnCallbackStubCb();
286         ret = NetConnService::GetInstance()->RequestNetConnectionAsync(netSpecifier, uidCallback, 0,
287                                                                                         TEST_CALLBACK_UID);
288         EXPECT_EQ(ret, NETMANAGER_SUCCESS);
289         uidCallbacks.push_back(uidCallback);
290     }
291     sptr<INetConnCallback> uidCallback = new (std::nothrow) NetConnCallbackStubCb();
292     ret = NetConnService::GetInstance()->RequestNetConnectionAsync(netSpecifier, uidCallback, 0, TEST_CALLBACK_UID);
293     EXPECT_EQ(ret, NET_CONN_ERR_NET_OVER_MAX_REQUEST_NUM);
294     for (auto& callback : uidCallbacks) {
295         ret = NetConnService::GetInstance()->UnregisterNetConnCallbackAsync(callback, TEST_CALLBACK_UID);
296         EXPECT_EQ(ret, NETMANAGER_SUCCESS);
297     }
298 }
299 
300 HWTEST_F(NetConnServiceTest, RegisterNetConnCallbackTest001, TestSize.Level1)
301 {
302     auto ret = NetConnService::GetInstance()->RegisterNetConnCallback(g_callback);
303     EXPECT_EQ(ret, NETSYS_SUCCESS);
304 }
305 
306 HWTEST_F(NetConnServiceTest, UnregisterNetConnCallbackTest001, TestSize.Level1)
307 {
308     sptr<INetConnCallback> netCallback = new (std::nothrow) NetConnCallbackStubCb();
309     auto ret = NetConnService::GetInstance()->UnregisterNetConnCallback(netCallback);
310     EXPECT_EQ(ret, NET_CONN_ERR_CALLBACK_NOT_FOUND);
311 
312     ret = NetConnService::GetInstance()->UnregisterNetConnCallback(g_callback);
313     EXPECT_EQ(ret, NETSYS_SUCCESS);
314 }
315 
316 HWTEST_F(NetConnServiceTest, RegisterNetConnCallbackTest002, TestSize.Level1)
317 {
318     sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
319     ASSERT_NE(netSpecifier, nullptr);
320     auto ret = NetConnService::GetInstance()->RegisterNetConnCallback(netSpecifier, g_callback,
321                                                                                         TEST_TIMEOUTMS);
322     EXPECT_EQ(ret, NETSYS_SUCCESS);
323 }
324 
325 HWTEST_F(NetConnServiceTest, RegisterNetConnCallbackTest003, TestSize.Level1)
326 {
327     sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
328     int64_t TEST_CALLBACK_UID = 1111;
329     auto ret = -1;
330     vector<sptr<INetConnCallback>> uidCallbacks;
331     for (int32_t i = 1; i <= 2000; ++i) {
332         sptr<INetConnCallback> uidCallback = new (std::nothrow) NetConnCallbackStubCb();
333         ret = NetConnService::GetInstance()->RegisterNetConnCallbackAsync(netSpecifier, uidCallback, 0,
334                                                                                         TEST_CALLBACK_UID);
335         EXPECT_EQ(ret, NETMANAGER_SUCCESS);
336         uidCallbacks.push_back(uidCallback);
337     }
338     sptr<INetConnCallback> uidCallback = new (std::nothrow) NetConnCallbackStubCb();
339     ret = NetConnService::GetInstance()->RegisterNetConnCallbackAsync(netSpecifier, uidCallback, 0, TEST_CALLBACK_UID);
340     EXPECT_EQ(ret, NET_CONN_ERR_NET_OVER_MAX_REQUEST_NUM);
341     for (auto& callback : uidCallbacks) {
342         ret = NetConnService::GetInstance()->UnregisterNetConnCallbackAsync(callback, TEST_CALLBACK_UID);
343         EXPECT_EQ(ret, NETMANAGER_SUCCESS);
344     }
345 }
346 
347 HWTEST_F(NetConnServiceTest, RegisterNetDetectionCallbackTest001, TestSize.Level1)
348 {
349     sptr<INetDetectionCallback> callback_ = nullptr;
350     auto ret = NetConnService::GetInstance()->RegisterNetDetectionCallback(TEST_NETID, callback_);
351     EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
352 
353     ret = NetConnService::GetInstance()->RegisterNetDetectionCallback(TEST_NETID, g_detectionCallback);
354     EXPECT_EQ(ret, NET_CONN_ERR_NETID_NOT_FOUND);
355 
356     ret = NetConnService::GetInstance()->RegisterNetDetectionCallback(MIN_NET_ID, g_detectionCallback);
357     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
358 }
359 
360 HWTEST_F(NetConnServiceTest, UnRegisterNetDetectionCallbackTest001, TestSize.Level1)
361 {
362     auto ret = NetConnService::GetInstance()->UnRegisterNetDetectionCallback(MIN_NET_ID, g_detectionCallback);
363     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
364 }
365 
366 HWTEST_F(NetConnServiceTest, UpdateNetStateForTestTest001, TestSize.Level1)
367 {
368     int32_t netState = 0;
369     sptr<NetSpecifier> netSpecifier = nullptr;
370     auto ret = NetConnService::GetInstance()->UpdateNetStateForTest(netSpecifier, netState);
371     EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
372 
373     netSpecifier = new (std::nothrow) NetSpecifier();
374     ret = NetConnService::GetInstance()->UpdateNetStateForTest(netSpecifier, netState);
375     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
376 }
377 
378 HWTEST_F(NetConnServiceTest, GetAllNetsTest001, TestSize.Level1)
379 {
380     std::list<int32_t> netIdList;
381     auto ret = NetConnService::GetInstance()->GetAllNets(netIdList);
382     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
383 }
384 
385 HWTEST_F(NetConnServiceTest, GetSpecificUidNetTest001, TestSize.Level1)
386 {
387     int32_t defaultNetId = 5;
388     auto ret = NetConnService::GetInstance()->GetDefaultNet(defaultNetId);
389     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
390     EXPECT_NE(defaultNetId, 0);
391 
392     std::list<int32_t> netIdList;
393     ret = NetConnService::GetInstance()->GetSpecificNet(BEARER_VPN, netIdList);
394     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
395     EXPECT_GE(netIdList.size(), 0);
396 
397     int32_t netID = 0;
398     NetConnService::GetInstance()->GetSpecificUidNet(TEST_NOTEXISTSUPPLIER, netID);
399     EXPECT_EQ(netID, defaultNetId);
400 
401     NetConnService::GetInstance()->GetSpecificUidNet(TEST_UID, netID);
402     EXPECT_EQ(netID, *netIdList.begin());
403 }
404 
405 HWTEST_F(NetConnServiceTest, GetConnectionPropertiesTest001, TestSize.Level1)
406 {
407     NetLinkInfo info;
408     auto ret = NetConnService::GetInstance()->GetConnectionProperties(TEST_NETID, info);
409     EXPECT_EQ(ret, NET_CONN_ERR_INVALID_NETWORK);
410 
411     int32_t defaultNetId = 0;
412     ret = NetConnService::GetInstance()->GetDefaultNet(defaultNetId);
413 
414     ret = NetConnService::GetInstance()->GetConnectionProperties(defaultNetId, info);
415     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
416 }
417 
418 HWTEST_F(NetConnServiceTest, GetAddressesByNameTest001, TestSize.Level1)
419 {
420     std::vector<INetAddr> addrList;
421     auto ret = NetConnService::GetInstance()->GetAddressesByName(TEST_HOST, TEST_NETID, addrList);
422     EXPECT_EQ(ret, NETMANAGER_ERROR);
423 }
424 
425 HWTEST_F(NetConnServiceTest, GetAddressByNameTest001, TestSize.Level1)
426 {
427     int32_t netId = 0;
428     auto ret = NetConnService::GetInstance()->GetDefaultNet(netId);
429     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
430     EXPECT_NE(netId, 0);
431 
432     INetAddr addr;
433     ret = NetConnService::GetInstance()->GetAddressByName(TEST_HOST, netId, addr);
434     EXPECT_EQ(ret, NETMANAGER_ERROR);
435 
436     sptr<TestDnsService> dnsService = new (std::nothrow) TestDnsService();
437     NetManagerCenter::GetInstance().RegisterDnsService(dnsService);
438 
439     ret = NetConnService::GetInstance()->GetAddressByName(TEST_HOST, netId, addr);
440     EXPECT_EQ(ret, NET_CONN_ERR_NO_ADDRESS);
441 
442     ret = NetConnService::GetInstance()->GetAddressByName(TEST_HOST, TEST_NETID, addr);
443     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
444 }
445 
446 HWTEST_F(NetConnServiceTest, BindSocketTest001, TestSize.Level1)
447 {
448     auto ret = NetConnService::GetInstance()->BindSocket(TEST_SOCKETFD, TEST_NETID);
449     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
450 }
451 
452 HWTEST_F(NetConnServiceTest, NetDetectionTest001, TestSize.Level1)
453 {
454     auto ret = NetConnService::GetInstance()->NetDetection(TEST_NETID);
455     EXPECT_EQ(ret, NET_CONN_ERR_NETID_NOT_FOUND);
456 
457     ret = NetConnService::GetInstance()->NetDetection(MIN_NET_ID);
458     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
459 }
460 
461 HWTEST_F(NetConnServiceTest, GetNetIdByIdentifierTest001, TestSize.Level1)
462 {
463     std::list<int32_t> netIdList;
464     auto ret = NetConnService::GetInstance()->GetNetIdByIdentifier("", netIdList);
465     EXPECT_EQ(ret, NETMANAGER_ERR_INVALID_PARAMETER);
466 
467     ret = NetConnService::GetInstance()->GetNetIdByIdentifier(TEST_IDENT, netIdList);
468     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
469 }
470 
471 HWTEST_F(NetConnServiceTest, GetDefaultNetTest001, TestSize.Level1)
472 {
473     int32_t netId = 0;
474     auto ret = NetConnService::GetInstance()->GetDefaultNet(netId);
475     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
476 }
477 
478 HWTEST_F(NetConnServiceTest, HasDefaultNetTest001, TestSize.Level1)
479 {
480     bool bFlag = false;
481     auto ret = NetConnService::GetInstance()->HasDefaultNet(bFlag);
482     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
483     EXPECT_TRUE(bFlag);
484 
485     ret = DelayedSingleton<NetConnService>::GetInstance()->HasDefaultNet(bFlag);
486     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
487     EXPECT_FALSE(bFlag);
488 }
489 
490 HWTEST_F(NetConnServiceTest, GetNetCapabilitiesTest001, TestSize.Level1)
491 {
492     int32_t netId = 0;
493     int32_t ret = NetConnService::GetInstance()->GetDefaultNet(netId);
494     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
495 
496     NetAllCapabilities netAllCap;
497     ret = NetConnService::GetInstance()->GetNetCapabilities(TEST_NETID, netAllCap);
498     ASSERT_EQ(ret, NET_CONN_ERR_INVALID_NETWORK);
499 
500     ret = NetConnService::GetInstance()->GetNetCapabilities(netId, netAllCap);
501     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
502 }
503 
504 HWTEST_F(NetConnServiceTest, SetAirplaneModeTest001, TestSize.Level1)
505 {
506     auto ret = NetConnService::GetInstance()->SetAirplaneMode(true);
507     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
508 }
509 
510 HWTEST_F(NetConnServiceTest, SetAirplaneModeTest002, TestSize.Level1)
511 {
512     auto ret = NetConnService::GetInstance()->SetAirplaneMode(false);
513     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
514 }
515 
516 HWTEST_F(NetConnServiceTest, IsDefaultNetMeteredTest001, TestSize.Level1)
517 {
518     bool bRes = false;
519     auto ret = NetConnService::GetInstance()->IsDefaultNetMetered(bRes);
520     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
521 
522     ret = DelayedSingleton<NetConnService>::GetInstance()->IsDefaultNetMetered(bRes);
523     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
524     EXPECT_TRUE(bRes);
525 }
526 
527 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest001, TestSize.Level1)
528 {
529     HttpProxy httpProxy = {TEST_PROXY_HOST, 0, {}};
530     auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
531     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
532 }
533 
534 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest002, TestSize.Level1)
535 {
536     HttpProxy httpProxy = {TEST_DOMAIN1, 8080, {}};
537     auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
538     ASSERT_TRUE(ret == NETMANAGER_SUCCESS);
539 }
540 
541 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest003, TestSize.Level1)
542 {
543     HttpProxy httpProxy = {TEST_DOMAIN2, 8080, {}};
544     auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
545     ASSERT_TRUE(ret == NETMANAGER_SUCCESS);
546 }
547 
548 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest004, TestSize.Level1)
549 {
550     HttpProxy httpProxy = {TEST_DOMAIN3, 8080, {}};
551     auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
552     ASSERT_TRUE(ret == NETMANAGER_SUCCESS);
553 }
554 
555 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest005, TestSize.Level1)
556 {
557     HttpProxy httpProxy = {TEST_DOMAIN4, 8080, {}};
558     auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
559     ASSERT_TRUE(ret == NETMANAGER_SUCCESS);
560 }
561 
562 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest006, TestSize.Level1)
563 {
564     HttpProxy httpProxy = {TEST_DOMAIN5, 8080, {}};
565     auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
566     ASSERT_TRUE(ret == NETMANAGER_SUCCESS);
567 }
568 
569 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest007, TestSize.Level1)
570 {
571     HttpProxy httpProxy = {TEST_DOMAIN6, 8080, {}};
572     auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
573     ASSERT_TRUE(ret == NETMANAGER_SUCCESS);
574 }
575 
576 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest008, TestSize.Level1)
577 {
578     HttpProxy httpProxy = {TEST_DOMAIN7, 8080, {}};
579     auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
580     ASSERT_TRUE(ret == NETMANAGER_SUCCESS);
581 }
582 
583 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest009, TestSize.Level1)
584 {
585     HttpProxy httpProxy = {TEST_DOMAIN8, 8080, {}};
586     auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
587     ASSERT_TRUE(ret == NETMANAGER_SUCCESS);
588 }
589 
590 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest010, TestSize.Level1)
591 {
592     HttpProxy httpProxy = {TEST_DOMAIN9, 8080, {}};
593     auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
594     ASSERT_TRUE(ret == NETMANAGER_SUCCESS);
595 }
596 
597 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest011, TestSize.Level1)
598 {
599     HttpProxy httpProxy = {TEST_DOMAIN10, 8080, {}};
600     auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
601     ASSERT_TRUE(ret == NETMANAGER_SUCCESS);
602 }
603 
604 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest012, TestSize.Level1)
605 {
606     HttpProxy httpProxy = {TEST_IPV4_ADDR, 8080, {}};
607     auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
608     ASSERT_TRUE(ret == NETMANAGER_SUCCESS);
609 }
610 
611 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest013, TestSize.Level1)
612 {
613     HttpProxy httpProxy = {TEST_IPV6_ADDR, 8080, {}};
614     auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
615     ASSERT_TRUE(ret == NETMANAGER_SUCCESS);
616 }
617 
618 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest014, TestSize.Level1)
619 {
620     HttpProxy httpProxy = {TEST_LONG_HOST, 8080, {TEST_LONG_EXCLUSION_LIST}};
621     auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
622     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
623 }
624 
625 HWTEST_F(NetConnServiceTest, GetGlobalHttpProxyTest001, TestSize.Level1)
626 {
627     HttpProxy getGlobalHttpProxy;
628     int32_t ret = NetConnService::GetInstance()->GetGlobalHttpProxy(getGlobalHttpProxy);
629     ASSERT_EQ(ret, NETMANAGER_SUCCESS);
630 }
631 
632 HWTEST_F(NetConnServiceTest, GetDefaultHttpProxyTest001, TestSize.Level1)
633 {
634     int32_t bindNetId = 0;
635     HttpProxy defaultHttpProxy;
636     int32_t ret = NetConnService::GetInstance()->GetDefaultHttpProxy(bindNetId, defaultHttpProxy);
637     ASSERT_TRUE(ret == NET_CONN_SUCCESS);
638 }
639 
640 HWTEST_F(NetConnServiceTest, GetDefaultHttpProxyTest002, TestSize.Level1)
641 {
642     int32_t bindNetId = NET_ID;
643     HttpProxy defaultHttpProxy;
644     int32_t ret = NetConnService::GetInstance()->GetDefaultHttpProxy(bindNetId, defaultHttpProxy);
645     ASSERT_TRUE(ret == NET_CONN_SUCCESS);
646 }
647 
648 HWTEST_F(NetConnServiceTest, GetCallingUserIdTest001, TestSize.Level1)
649 {
650     int32_t userId;
651     int32_t ret = NetConnService::GetInstance()->GetCallingUserId(userId);
652     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
653 }
654 
655 HWTEST_F(NetConnServiceTest, GetTest001, TestSize.Level1)
656 {
657     std::list<int32_t> netIdList;
658     int32_t ret = NetConnService::GetInstance()->GetSpecificNet(BEARER_CELLULAR, netIdList);
659     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
660 
661     ret = NetConnService::GetInstance()->GetSpecificNet(BEARER_DEFAULT, netIdList);
662     EXPECT_EQ(ret, NET_CONN_ERR_NET_TYPE_NOT_FOUND);
663 
664     ret = NetConnService::GetInstance()->RestrictBackgroundChanged(false);
665     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
666 
667     ret = NetConnService::GetInstance()->RestrictBackgroundChanged(false);
668     EXPECT_EQ(ret, NET_CONN_ERR_NET_NO_RESTRICT_BACKGROUND);
669 
670     NetConnService::GetInstance()->HandleDetectionResult(TEST_NOTEXISTSUPPLIER, VERIFICATION_STATE);
671     NetConnService::GetInstance()->HandleDetectionResult(g_supplierId, VERIFICATION_STATE);
672 
673     std::vector<std::u16string> args;
674     args.emplace_back(u"dummy data");
675     ret = NetConnService::GetInstance()->Dump(SOCKET_FD, args);
676     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
677 
678     ret = DelayedSingleton<NetConnService>::GetInstance()->Dump(SOCKET_FD, args);
679     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
680 }
681 
682 HWTEST_F(NetConnServiceTest, OnNetActivateTimeOutTest001, TestSize.Level1)
683 {
684     NetConnService::GetInstance()->OnNetActivateTimeOut(NET_ID);
685     if (NetConnService::GetInstance()->netActivates_.size() > 0) {
686         uint32_t nNetID = NetConnService::GetInstance()->netActivates_.begin()->first;
687         NetConnService::GetInstance()->OnNetActivateTimeOut(nNetID);
688         for (auto iterSupplier = NetConnService::GetInstance()->netSuppliers_.begin();
689              iterSupplier != NetConnService::GetInstance()->netSuppliers_.end(); ++iterSupplier) {
690             if (iterSupplier->second == nullptr) {
691                 continue;
692             }
693             EXPECT_EQ(iterSupplier->second->requestList_.find(nNetID), iterSupplier->second->requestList_.end());
694         }
695     }
696 }
697 
698 HWTEST_F(NetConnServiceTest, GetIfaceNamesTest001, TestSize.Level1)
699 {
700     std::list<std::string> ifaceNames;
701     auto ret = NetConnService::GetInstance()->GetIfaceNames(BEARER_DEFAULT, ifaceNames);
702     EXPECT_EQ(ret, NET_CONN_ERR_NET_TYPE_NOT_FOUND);
703 
704     ret = NetConnService::GetInstance()->GetIfaceNames(BEARER_VPN, ifaceNames);
705     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
706 }
707 
708 HWTEST_F(NetConnServiceTest, GetIfaceNameByTypeTest001, TestSize.Level1)
709 {
710     std::string ifaceName;
711     auto ret = NetConnService::GetInstance()->GetIfaceNameByType(BEARER_DEFAULT, TEST_IDENT, ifaceName);
712     EXPECT_EQ(ret, NET_CONN_ERR_NET_TYPE_NOT_FOUND);
713 
714     ret = NetConnService::GetInstance()->GetIfaceNameByType(BEARER_BLUETOOTH, TEST_IDENT, ifaceName);
715     EXPECT_EQ(ret, NET_CONN_ERR_NO_SUPPLIER);
716 
717     ret = NetConnService::GetInstance()->GetIfaceNameByType(BEARER_VPN, TEST_IDENT, ifaceName);
718     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
719 }
720 
721 HWTEST_F(NetConnServiceTest, GetIfaceNameIdentMapsTest001, TestSize.Level1)
722 {
723     SafeMap<std::string, std::string> data;
724     auto ret = NetConnService::GetInstance()->GetIfaceNameIdentMaps(BEARER_CELLULAR, data);
725     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
726 }
727 
728 HWTEST_F(NetConnServiceTest, SetAppNetTest001, TestSize.Level1)
729 {
730     auto ret = NetConnService::GetInstance()->SetAppNet(TEST_NETID);
731     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
732 }
733 
734 HWTEST_F(NetConnServiceTest, RegisterNetInterfaceCallbackTest001, TestSize.Level1)
735 {
736     sptr<INetInterfaceStateCallback> callback = nullptr;
737     auto ret = NetConnService::GetInstance()->RegisterNetInterfaceCallback(callback);
738     EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
739 
740     callback = new (std::nothrow) NetInterfaceStateCallbackStub();
741     ret = NetConnService::GetInstance()->RegisterNetInterfaceCallback(callback);
742     EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
743 
744     NetConnService::GetInstance()->interfaceStateCallback_ =
745         new (std::nothrow) NetConnService::NetInterfaceStateCallback();
746     ASSERT_NE(NetConnService::GetInstance()->interfaceStateCallback_, nullptr);
747     NetsysController::GetInstance().RegisterCallback(NetConnService::GetInstance()->interfaceStateCallback_);
748 
749     ret = NetConnService::GetInstance()->RegisterNetInterfaceCallback(callback);
750     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
751 }
752 
753 HWTEST_F(NetConnServiceTest, GetNetInterfaceConfigurationTest001, TestSize.Level1)
754 {
755     NetInterfaceConfiguration config;
756     auto ret = NetConnService::GetInstance()->GetNetInterfaceConfiguration("wlan0", config);
757     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
758 }
759 
760 HWTEST_F(NetConnServiceTest, AddNetworkRouteTest001, TestSize.Level1)
761 {
762     int32_t netId = 10;
763     std::string ifName = "wlan0";
764     std::string destination = "0.0.0.0/0";
765     std::string nextHop = "0.0.0.1234";
766     int32_t ret = NetConnService::GetInstance()->AddNetworkRoute(netId, ifName, destination, nextHop);
767     EXPECT_EQ(ret, NETMANAGER_ERROR);
768 }
769 
770 HWTEST_F(NetConnServiceTest, RemoveNetworkRouteTest001, TestSize.Level1)
771 {
772     int32_t netId = 10;
773     std::string ifName = "wlan0";
774     std::string destination = "0.0.0.0/0";
775     std::string nextHop = "0.0.0.1234";
776     int32_t ret = NetConnService::GetInstance()->RemoveNetworkRoute(netId, ifName, destination, nextHop);
777     EXPECT_EQ(ret, NETMANAGER_ERROR);
778 }
779 
780 HWTEST_F(NetConnServiceTest, AddInterfaceAddressTest001, TestSize.Level1)
781 {
782     std::string ifName = "wlan0";
783     std::string ipAddr = "0.0.0.1";
784     int32_t prefixLength = 23;
785     int32_t ret = NetConnService::GetInstance()->AddInterfaceAddress(ifName, ipAddr, prefixLength);
786     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
787 }
788 
789 HWTEST_F(NetConnServiceTest, DelInterfaceAddressTest001, TestSize.Level1)
790 {
791     std::string ifName = "wlan0";
792     std::string ipAddr = "0.0.0.1";
793     int32_t prefixLength = 23;
794     int32_t ret = NetConnService::GetInstance()->DelInterfaceAddress(ifName, ipAddr, prefixLength);
795     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
796 }
797 
798 HWTEST_F(NetConnServiceTest, AddStaticArpTest001, TestSize.Level1)
799 {
800     std::string ipAddr = "192.168.1.100";
801     std::string macAddr = "aa:bb:cc:dd:ee:ff";
802     std::string ifName = "wlan0";
803     int32_t ret = NetConnService::GetInstance()->AddStaticArp(ipAddr, macAddr, ifName);
804     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
805 }
806 
807 HWTEST_F(NetConnServiceTest, DelStaticArpTest001, TestSize.Level1)
808 {
809     std::string ipAddr = "192.168.1.100";
810     std::string macAddr = "aa:bb:cc:dd:ee:ff";
811     std::string ifName = "wlan0";
812     int32_t ret = NetConnService::GetInstance()->DelStaticArp(ipAddr, macAddr, ifName);
813     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
814 }
815 
816 HWTEST_F(NetConnServiceTest, NetConnServiceBranchTest001, TestSize.Level1)
817 {
818     NetConnService::GetInstance()->OnStart();
819     EXPECT_EQ(NetConnService::GetInstance()->state_, NetConnService::STATE_RUNNING);
820     NetConnService::GetInstance()->OnStop();
821     EXPECT_EQ(NetConnService::GetInstance()->state_, NetConnService::STATE_STOPPED);
822     bool result = NetConnService::GetInstance()->Init();
823     EXPECT_FALSE(result);
824 
825     uint32_t reqId = 0;
826     result = NetConnService::GetInstance()->FindSameCallback(nullptr, reqId);
827     EXPECT_FALSE(result);
828 
829     sptr<NetSupplier> supplier = nullptr;
830     std::shared_ptr<NetActivate> netActivateNetwork = nullptr;
831     auto ret = NetConnService::GetInstance()->FindBestNetworkForRequest(supplier, netActivateNetwork);
832     EXPECT_EQ(ret, ZERO_VALUE);
833 
834     NetConnService::GetInstance()->SendAllRequestToNetwork(nullptr);
835 
836     NetConnService::GetInstance()->SendRequestToAllNetwork(nullptr);
837 
838     sptr<NetLinkInfo> netLinkInfo = new (std::nothrow) NetLinkInfo();
839     ASSERT_NE(netLinkInfo, nullptr);
840     netLinkInfo->httpProxy_.SetHost(TEST_HOST);
841     ret = NetConnService::GetInstance()->UpdateNetLinkInfo(g_supplierId, netLinkInfo);
842     EXPECT_EQ(ret, NETMANAGER_ERROR);
843 
844     supplier = NetConnService::GetInstance()->FindNetSupplier(g_supplierId);
845     ASSERT_NE(supplier, nullptr);
846 
847     CallbackType type = CallbackType::CALL_TYPE_LOST;
848     NetConnService::GetInstance()->CallbackForSupplier(supplier, type);
849     type = CallbackType::CALL_TYPE_UPDATE_CAP;
850     NetConnService::GetInstance()->CallbackForSupplier(supplier, type);
851     type = CallbackType::CALL_TYPE_UPDATE_LINK;
852     NetConnService::GetInstance()->CallbackForSupplier(supplier, type);
853     type = CallbackType::CALL_TYPE_BLOCK_STATUS;
854     NetConnService::GetInstance()->CallbackForSupplier(supplier, type);
855 
856     uint32_t validType = INVALID_VALUE;
857     type = static_cast<CallbackType>(validType);
858     NetConnService::GetInstance()->CallbackForSupplier(supplier, type);
859 
860     ret = NetConnService::GetInstance()->RegisterNetConnCallbackAsync(nullptr, nullptr, 0, TEST_UID);
861     EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
862 }
863 
864 HWTEST_F(NetConnServiceTest, NetConnServiceBranchTest002, TestSize.Level1)
865 {
866     auto ret = NetConnService::GetInstance()->UnregisterNetConnCallbackAsync(nullptr, TEST_UID);
867     EXPECT_NE(ret, NETSYS_SUCCESS);
868 
869     sptr<NetSupplier> supplier = nullptr;
870     sptr<NetSupplier> newSupplier = nullptr;
871     NetConnService::GetInstance()->MakeDefaultNetWork(supplier, newSupplier);
872 
873     ret = NetConnService::GetInstance()->ActivateNetwork(nullptr, nullptr, 0);
874     EXPECT_NE(ret, NETSYS_SUCCESS);
875 }
876 
877 HWTEST_F(NetConnServiceTest, FactoryResetNetworkTest001, TestSize.Level1)
878 {
879     NetConnService::GetInstance()->netFactoryResetCallback_ =
880         new (std::nothrow) NetFactoryResetCallback();
881     ASSERT_NE(NetConnService::GetInstance()->netFactoryResetCallback_, nullptr);
882     auto ret = NetConnService::GetInstance()->FactoryResetNetwork();
883     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
884 }
885 
886 HWTEST_F(NetConnServiceTest, RegisterNetFactoryResetCallbackTest001, TestSize.Level1)
887 {
888     sptr<INetFactoryResetCallback> callback = nullptr;
889     auto ret = NetConnService::GetInstance()->RegisterNetFactoryResetCallback(callback);
890     EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
891 
892     NetConnService::GetInstance()->netFactoryResetCallback_ =
893         new (std::nothrow) NetFactoryResetCallback();
894     ASSERT_NE(NetConnService::GetInstance()->netFactoryResetCallback_, nullptr);
895 
896     callback = new (std::nothrow) NetFactoryResetCallbackStub();
897     ret = NetConnService::GetInstance()->RegisterNetFactoryResetCallback(callback);
898     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
899 }
900 
901 HWTEST_F(NetConnServiceTest, NetConnServiceBranchTest004, TestSize.Level1)
902 {
903     NetConnService::GetInstance()->RequestAllNetworkExceptDefault();
904 
905     NetConnService::NetInterfaceStateCallback stateCallback;
906     std::string testString = "test";
907     int32_t testInt = 0;
908     auto ret = stateCallback.OnInterfaceAddressUpdated(testString, testString, testInt, testInt);
909     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
910 
911     ret = stateCallback.OnInterfaceAddressRemoved(testString, testString, testInt, testInt);
912     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
913 
914     ret = stateCallback.OnInterfaceAdded(testString);
915     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
916 
917     ret = stateCallback.OnInterfaceRemoved(testString);
918     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
919 
920     ret = stateCallback.OnInterfaceChanged(testString, false);
921     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
922 
923     ret = stateCallback.OnInterfaceLinkStateChanged(testString, false);
924     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
925 
926     ret = stateCallback.OnRouteChanged(false, testString, testString, testString);
927     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
928 
929     NetsysControllerCallback::DhcpResult dhcpResult;
930     ret = stateCallback.OnDhcpSuccess(dhcpResult);
931     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
932 
933     ret = stateCallback.OnBandwidthReachedLimit(testString, testString);
934     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
935 
936     sptr<INetInterfaceStateCallback> interfaceStateCallback = nullptr;
937     ret = stateCallback.RegisterInterfaceCallback(interfaceStateCallback);
938     EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
939 }
940 
941 HWTEST_F(NetConnServiceTest, NetConnServiceBranchTest005, TestSize.Level1)
942 {
943     NetHttpProxyTracker httpProxyTracker;
944     std::string exclusions = "";
945     NetConnService::GetInstance()->GetPreferredUrl();
946     std::list<std::string> list = httpProxyTracker.ParseExclusionList(exclusions);
947     EXPECT_TRUE(list.empty());
948 
949     std::string result = httpProxyTracker.GetExclusionsAsString(list);
950     EXPECT_TRUE(result.empty());
951 
952     uint32_t supplierId = 10;
953     int32_t type = 0;
954     auto ret = NetConnService::GetInstance()->RegisterSlotType(supplierId, type);
955     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
956 
957     std::string slotType = "";
958     ret = NetConnService::GetInstance()->GetSlotType(slotType);
959     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
960 
961     std::string url = "";
962     bool preferCellular = false;
963     ret = NetConnService::GetInstance()->IsPreferCellularUrl(url, preferCellular);
964     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
965 
966     NetConnService::GetInstance()->netFactoryResetCallback_ = nullptr;
967     ret = NetConnService::GetInstance()->FactoryResetNetwork();
968     EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
969 }
970 
971 HWTEST_F(NetConnServiceTest, FindSupplierWithInternetByBearerType001, TestSize.Level1)
972 {
973     std::set<NetCap> netCaps;
974     netCaps.insert(NetCap::NET_CAPABILITY_MMS);
975     netCaps.insert(NetCap::NET_CAPABILITY_INTERNET);
976     uint32_t supplierId = 0;
977     int32_t ret = NetConnService::GetInstance()->RegisterNetSupplierAsync(NetBearType::BEARER_WIFI, TEST_IDENT,
978         netCaps, supplierId);
979     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
980 
981     std::vector<sptr<NetSupplier>> suppliers =
982         NetConnService::GetInstance()->FindSupplierWithInternetByBearerType(NetBearType::BEARER_WIFI);
983     EXPECT_FALSE(suppliers.empty());
984 }
985 
986 HWTEST_F(NetConnServiceTest, UpdateSupplierScore001, TestSize.Level1)
987 {
988     std::set<NetCap> netCaps;
989     netCaps.insert(NetCap::NET_CAPABILITY_MMS);
990     netCaps.insert(NetCap::NET_CAPABILITY_INTERNET);
991     uint32_t supplierId = 0;
992     int32_t ret = NetConnService::GetInstance()->RegisterNetSupplierAsync(NetBearType::BEARER_WIFI, TEST_IDENT,
993         netCaps, supplierId);
994     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
995     NetConnService::GetInstance()->MakeDefaultNetWork(NetConnService::GetInstance()->defaultNetSupplier_,
996         NetConnService::GetInstance()->netSuppliers_[supplierId]);
997     ret = NetConnService::GetInstance()->UpdateSupplierScoreAsync(NetBearType::BEARER_WIFI,
998         QUALITY_POOR_STATE, supplierId);
999     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1000     auto supplier = NetConnService::GetInstance()->FindNetSupplier(supplierId);
1001     supplier->SetDetectionDone();
1002     EXPECT_EQ(supplier->GetRealScore(), supplier->GetNetScore() - DIFF_SCORE_BETWEEN_GOOD_POOR);
1003 }
1004 
1005 HWTEST_F(NetConnServiceTest, UpdateSupplierScore002, TestSize.Level1)
1006 {
1007     std::set<NetCap> netCaps;
1008     netCaps.insert(NetCap::NET_CAPABILITY_MMS);
1009     netCaps.insert(NetCap::NET_CAPABILITY_INTERNET);
1010     uint32_t supplierId = 0;
1011     int32_t ret = NetConnService::GetInstance()->RegisterNetSupplierAsync(NetBearType::BEARER_WIFI, TEST_IDENT,
1012         netCaps, supplierId);
1013     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1014     ret = NetConnService::GetInstance()->UpdateSupplierScoreAsync(NetBearType::BEARER_WIFI,
1015         QUALITY_GOOD_STATE, supplierId);
1016     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1017 }
1018 
1019 HWTEST_F(NetConnServiceTest, EnableVnicNetwork001, TestSize.Level1)
1020 {
1021     sptr<NetManagerStandard::NetLinkInfo> linkInfo = nullptr;
1022     std::set<int32_t> uids;
1023 
1024     linkInfo = new (std::nothrow) NetManagerStandard::NetLinkInfo();
1025     ASSERT_NE(linkInfo, nullptr);
1026 
1027     int32_t ret = NetConnService::GetInstance()->EnableVnicNetworkAsync(linkInfo, uids);
1028     EXPECT_EQ(ret, NET_CONN_ERR_INVALID_NETWORK);
1029 }
1030 
1031 HWTEST_F(NetConnServiceTest, EnableVnicNetwork002, TestSize.Level1)
1032 {
1033     sptr<NetManagerStandard::NetLinkInfo> linkInfo = nullptr;
1034     std::set<int32_t> uids;
1035 
1036     linkInfo = new (std::nothrow) NetManagerStandard::NetLinkInfo();
1037     ASSERT_NE(linkInfo, nullptr);
1038 
1039     NetManagerStandard::INetAddr inetAddr;
1040     inetAddr.type_ = NetManagerStandard::INetAddr::IpType::IPV4;
1041     inetAddr.family_ = 0x01;
1042     inetAddr.address_ = "10.0.0.2";
1043     inetAddr.netMask_ = "255.255.255.0";
1044     inetAddr.hostName_ = "localhost";
1045     inetAddr.port_ = 80;
1046     inetAddr.prefixlen_ = 24;
1047 
1048     linkInfo->ifaceName_ = "vnic-tun";
1049     linkInfo->netAddrList_.push_back(inetAddr);
1050     linkInfo->mtu_ = 1500;
1051 
1052     int32_t ret = NetConnService::GetInstance()->EnableVnicNetworkAsync(linkInfo, uids);
1053     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1054 }
1055 
1056 HWTEST_F(NetConnServiceTest, DisableVnicNetwork001, TestSize.Level1)
1057 {
1058     int32_t ret = NetConnService::GetInstance()->DisableVnicNetworkAsync();
1059     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1060 }
1061 } // namespace NetManagerStandard
1062 } // namespace OHOS
1063