• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2025-2025 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 "ipc_skeleton.h"
26 #include "net_all_capabilities.h"
27 #include "net_conn_callback_stub.h"
28 #include "net_conn_client.h"
29 #include "net_conn_constants.h"
30 #include "net_conn_service.h"
31 #include "net_conn_types.h"
32 #include "net_detection_callback_test.h"
33 #include "net_factoryreset_callback_stub.h"
34 #include "net_http_proxy_tracker.h"
35 #include "net_interface_callback_stub.h"
36 #include "net_manager_center.h"
37 #include "net_mgr_log_wrapper.h"
38 #include "netmanager_base_test_security.h"
39 #include "netsys_controller.h"
40 #include "system_ability_definition.h"
41 #include "common_mock_net_remote_object_test.h"
42 #include "parameter.h"
43 #include "parameters.h"
44 
45 namespace OHOS {
46 namespace NetManagerStandard {
47 namespace {
48 using namespace testing::ext;
49 constexpr uint32_t TEST_TIMEOUTMS = 1000;
50 constexpr int32_t TEST_NETID = 3;
51 constexpr int32_t TEST_SOCKETFD = 2;
52 const int32_t NET_ID = 2;
53 const int32_t SOCKET_FD = 2;
54 const int32_t ZERO_VALUE = 0;
55 const int32_t INVALID_VALUE = 10;
56 constexpr const char *TEST_IDENT = "testIdent";
57 constexpr const char *TEST_HOST = "testHost";
58 constexpr const char *TEST_PROXY_HOST = "testHttpProxy";
59 constexpr const char *TEST_IPV4_ADDR = "127.0.0.1";
60 constexpr const char *TEST_IPV6_ADDR = "240C:1:1:1::1";
61 constexpr const char *TEST_DOMAIN1 = ".com";
62 constexpr const char *TEST_DOMAIN2 = "test.com";
63 constexpr const char *TEST_DOMAIN3 = "testcom";
64 constexpr const char *TEST_DOMAIN4 = "com.test";
65 constexpr const char *TEST_DOMAIN5 = "test.co.uk";
66 constexpr const char *TEST_DOMAIN6 = "test.com.com";
67 constexpr const char *TEST_DOMAIN7 = "test1.test2.test3.test4.test5.com";
68 constexpr const char *TEST_DOMAIN8 = "http://www.example.com";
69 constexpr const char *TEST_DOMAIN9 = "https://www.example.com";
70 constexpr const char *TEST_DOMAIN10 = "httpd://www.example.com";
71 constexpr const char *TEST_LONG_HOST =
72     "0123456789qwertyuiopasdfghjklzxcvbnm[]:;<>?!@#$%^&()AEFFEqwdqwrtfasfj4897qwe465791qwr87tq4fq7t8qt4654qwr";
73 constexpr const char *TEST_LONG_EXCLUSION_LIST =
74     "www.test0.com,www.test1.com,www.test2.com,www.test3.com,www.test4.com,www.test5.com,www.test6.com,www.test7.com,"
75     "www.test8.com,www.test9.com,www.test10.com,www.test11.com,www.test12.com,www.test12.com,www.test12.com,www.test13."
76     "com,www.test14.com,www.test15.com,www.test16.com,www.test17.com,www.test18.com,www.test19.com,www.test20.com";
77 constexpr const char *NET_CONN_MANAGER_WORK_THREAD = "NET_CONN_MANAGER_WORK_THREAD";
78 constexpr int64_t TEST_UID = 1010;
79 constexpr uint32_t TEST_NOTEXISTSUPPLIER = 1000;
80 constexpr int32_t MAIN_USERID = 100;
81 constexpr int32_t INVALID_USERID = 1;
82 
83 sptr<INetConnCallback> g_callback = new (std::nothrow) NetConnCallbackStubCb();
84 sptr<INetDetectionCallback> g_detectionCallback = new (std::nothrow) NetDetectionCallbackTest();
85 uint32_t g_supplierId = 0;
86 uint32_t g_vpnSupplierId = 0;
87 } // namespace
88 
89 class NetConnServiceExtTest : public testing::Test {
90 public:
91     static void SetUpTestCase();
92     static void TearDownTestCase();
93     void SetUp();
94     void TearDown();
95 };
96 
SetUpTestCase()97 void NetConnServiceExtTest::SetUpTestCase()
98 {
99     NetConnService::GetInstance()->OnStart();
100     if (NetConnService::GetInstance()->state_ != NetConnService::STATE_RUNNING) {
101         NetConnService::GetInstance()->netConnEventRunner_ =
102             AppExecFwk::EventRunner::Create(NET_CONN_MANAGER_WORK_THREAD);
103         ASSERT_NE(NetConnService::GetInstance()->netConnEventRunner_, nullptr);
104         NetConnService::GetInstance()->netConnEventHandler_ =
105             std::make_shared<NetConnEventHandler>(NetConnService::GetInstance()->netConnEventRunner_);
106         NetConnService::GetInstance()->serviceIface_ = std::make_unique<NetConnServiceIface>().release();
107         NetManagerCenter::GetInstance().RegisterConnService(NetConnService::GetInstance()->serviceIface_);
108         NetHttpProxyTracker httpProxyTracker;
109         HttpProxy httpProxy;
110         httpProxy.SetPort(0);
111         httpProxyTracker.ReadFromSettingsData(httpProxy);
112         NetConnService::GetInstance()->SendHttpProxyChangeBroadcast(httpProxy);
113     }
114 }
115 
TearDownTestCase()116 void NetConnServiceExtTest::TearDownTestCase() {}
117 
SetUp()118 void NetConnServiceExtTest::SetUp() {}
119 
TearDown()120 void NetConnServiceExtTest::TearDown() {}
121 
122 HWTEST_F(NetConnServiceExtTest, CheckIfSettingsDataReadyTest001, TestSize.Level1)
123 {
124     NetConnService::GetInstance()->isDataShareReady_ = true;
125     auto ret = NetConnService::GetInstance()->CheckIfSettingsDataReady();
126     EXPECT_TRUE(ret);
127 }
128 
129 HWTEST_F(NetConnServiceExtTest, CheckIfSettingsDataReadyTest002, TestSize.Level1)
130 {
131     NetConnService::GetInstance()->isDataShareReady_ = false;
132     auto ret = NetConnService::GetInstance()->CheckIfSettingsDataReady();
133     EXPECT_TRUE(ret);
134 }
135 
136 HWTEST_F(NetConnServiceExtTest, OnNetSupplierRemoteDiedTest001, TestSize.Level1)
137 {
138     wptr<IRemoteObject> remoteObject = nullptr;
139     NetConnService::GetInstance()->netConnEventHandler_ = nullptr;
140     EXPECT_FALSE(NetConnService::GetInstance()->registerToService_);
141     NetConnService::GetInstance()->OnNetSupplierRemoteDied(remoteObject);
142 }
143 
144 HWTEST_F(NetConnServiceExtTest, OnNetSupplierRemoteDiedTest002, TestSize.Level1)
145 {
146     wptr<IRemoteObject> remoteObject = new MockNetIRemoteObject();
147     EXPECT_NE(remoteObject, nullptr);
148     NetConnService::GetInstance()->netConnEventHandler_ = nullptr;
149     NetConnService::GetInstance()->OnNetSupplierRemoteDied(remoteObject);
150 }
151 
152 HWTEST_F(NetConnServiceExtTest, OnNetSupplierRemoteDiedTest003, TestSize.Level1)
153 {
154     wptr<IRemoteObject> remoteObject = new MockNetIRemoteObject();
155     EXPECT_NE(remoteObject, nullptr);
156     NetConnService::GetInstance()->netConnEventHandler_ = nullptr;
157     NetConnService::GetInstance()->OnNetSupplierRemoteDied(remoteObject);
158 }
159 
160 HWTEST_F(NetConnServiceExtTest, RemoveNetSupplierDeathRecipientTest002, TestSize.Level1)
161 {
162     sptr<INetSupplierCallback> callback = nullptr;
163     EXPECT_FALSE(NetConnService::GetInstance()->registerToService_);
164     NetConnService::GetInstance()->RemoveNetSupplierDeathRecipient(callback);
165 }
166 
167 HWTEST_F(NetConnServiceExtTest, RequestNetConnectionAsyncTest002, TestSize.Level1)
168 {
169     uint32_t callingUid = 1;
170     sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
171     sptr<INetConnCallback> uidCallback = nullptr;
172     int32_t ret = NetConnService::GetInstance()->RequestNetConnectionAsync(netSpecifier, uidCallback, 0, callingUid);
173     EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
174 }
175 
176 HWTEST_F(NetConnServiceExtTest, UnregisterNetSupplierAsyncTest001, TestSize.Level1)
177 {
178     uint32_t supplierId = 1;
179     int32_t callingUid = 1;
180     auto netConnService = NetConnService::GetInstance();
181     std::string netSupplierIdent;
182     std::set<NetCap> netCaps;
183     sptr<NetSupplier> netSupplier = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
184     netConnService->netSuppliers_[supplierId] = netSupplier;
185     auto result = netConnService->FindNetSupplier(supplierId);
186     EXPECT_EQ(result, netSupplier);
187     netConnService->defaultNetSupplier_ = netSupplier;
188     bool ignoreUid = true;
189     auto ret = netConnService->UnregisterNetSupplierAsync(supplierId, ignoreUid, callingUid);
190     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
191 }
192 
193 HWTEST_F(NetConnServiceExtTest, UnregisterNetSupplierAsyncTest002, TestSize.Level1)
194 {
195     uint32_t supplierId = 1;
196     int32_t callingUid = 1;
197     auto netConnService = NetConnService::GetInstance();
198     std::string netSupplierIdent;
199     std::set<NetCap> netCaps;
200     sptr<NetSupplier> netSupplier = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
201     netConnService->netSuppliers_[supplierId] = netSupplier;
202     auto result = netConnService->FindNetSupplier(supplierId);
203     EXPECT_EQ(result, netSupplier);
204     bool ignoreUid = false;
205     netConnService->defaultNetSupplier_ = nullptr;
206     EXPECT_EQ(netConnService->defaultNetSupplier_, nullptr);
207     auto ret = netConnService->UnregisterNetSupplierAsync(supplierId, ignoreUid, callingUid);
208     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
209 }
210 
211 HWTEST_F(NetConnServiceExtTest, CheckAndCompareUidTest001, TestSize.Level1)
212 {
213     uint32_t supplierId = 1;
214     int32_t callingUid = 2;
215     auto netConnService = NetConnService::GetInstance();
216     std::string netSupplierIdent;
217     std::set<NetCap> netCaps;
218     sptr<NetSupplier> netSupplier = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
219     netConnService->netSuppliers_[supplierId] = netSupplier;
220     auto supplier = netConnService->FindNetSupplier(supplierId);
221     EXPECT_EQ(supplier, netSupplier);
222     int32_t uid = netSupplier->GetUid();
223     EXPECT_NE(uid, callingUid);
224     netConnService->CheckAndCompareUid(supplier, callingUid);
225 }
226 
227 HWTEST_F(NetConnServiceExtTest, HandleScreenEventTest001, TestSize.Level1)
228 {
229     auto netConnService = NetConnService::GetInstance();
230     netConnService->defaultNetSupplier_ = nullptr;
231     EXPECT_EQ(netConnService->defaultNetSupplier_, nullptr);
232     netConnService->HandleScreenEvent(true);
233 }
234 
235 HWTEST_F(NetConnServiceExtTest, UpdateNetCapsAsyncTest001, TestSize.Level1)
236 {
237     auto netConnService = NetConnService::GetInstance();
238     std::set<NetCap> netCaps;
239     uint32_t supplierId = 0;
240     EXPECT_EQ(netConnService->defaultNetSupplier_, nullptr);
241     auto supplier = netConnService->FindNetSupplier(supplierId);
242     EXPECT_EQ(supplier, nullptr);
243     auto ret = netConnService->UpdateNetCapsAsync(netCaps, supplierId);
244     EXPECT_EQ(ret, NET_CONN_ERR_NO_SUPPLIER);
245 }
246 
247 HWTEST_F(NetConnServiceExtTest, UpdateNetCapsAsyncTest002, TestSize.Level1)
248 {
249     auto netConnService = NetConnService::GetInstance();
250     std::set<NetCap> netCaps;
251     uint32_t supplierId = 1;
252     std::string netSupplierIdent;
253     sptr<NetSupplier> netSupplier = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
254     netConnService->netSuppliers_[supplierId] = netSupplier;
255     auto result = netConnService->FindNetSupplier(supplierId);
256     EXPECT_EQ(result, netSupplier);
257     auto supplier = netConnService->FindNetSupplier(supplierId);
258     EXPECT_EQ(supplier, netSupplier);
259     auto network = supplier->GetNetwork();
260     EXPECT_EQ(network, nullptr);
261     auto ret = netConnService->UpdateNetCapsAsync(netCaps, supplierId);
262     EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
263 }
264 
265 HWTEST_F(NetConnServiceExtTest, NetDetectionForDnsHealthSyncTest002, TestSize.Level1)
266 {
267     auto netConnService = NetConnService::GetInstance();
268     int32_t netId = 0;
269     auto iterNetwork = netConnService->networks_.find(netId);
270     EXPECT_EQ(iterNetwork, netConnService->networks_.end());
271     auto ret = netConnService->NetDetectionForDnsHealthSync(netId, true);
272     EXPECT_EQ(ret, NET_CONN_ERR_NETID_NOT_FOUND);
273 }
274 
275 HWTEST_F(NetConnServiceExtTest, NetDetectionForDnsHealthSyncTest003, TestSize.Level1)
276 {
277     auto netConnService = NetConnService::GetInstance();
278     int32_t netId = 1;
279     netConnService->networks_[netId] = nullptr;
280     auto iterNetwork = netConnService->networks_.find(netId);
281     EXPECT_NE(iterNetwork, netConnService->networks_.end());
282     auto ret = netConnService->NetDetectionForDnsHealthSync(netId, true);
283     EXPECT_EQ(ret, NET_CONN_ERR_NETID_NOT_FOUND);
284 }
285 
286 HWTEST_F(NetConnServiceExtTest, RestrictBackgroundChangedAsyncTest001, TestSize.Level1)
287 {
288     auto netConnService = NetConnService::GetInstance();
289     netConnService->netSuppliers_.clear();
290     netConnService->netSuppliers_[0] = nullptr;
291     auto ret = netConnService->RestrictBackgroundChangedAsync(true);
292     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
293 }
294 
295 HWTEST_F(NetConnServiceExtTest, RequestAllNetworkExceptDefaultTest001, TestSize.Level1)
296 {
297     auto netConnService = NetConnService::GetInstance();
298     netConnService->defaultNetSupplier_ = nullptr;
299     EXPECT_FALSE(NetConnService::GetInstance()->registerToService_);
300     netConnService->RequestAllNetworkExceptDefault();
301 }
302 
303 HWTEST_F(NetConnServiceExtTest, RequestAllNetworkExceptDefaultTest002, TestSize.Level1)
304 {
305     auto netConnService = NetConnService::GetInstance();
306     std::string netSupplierIdent;
307     std::set<NetCap> netCaps;
308     netConnService->defaultNetSupplier_ = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
309     EXPECT_NE(netConnService->defaultNetSupplier_, nullptr);
310     netConnService->RequestAllNetworkExceptDefault();
311 }
312 
313 HWTEST_F(NetConnServiceExtTest, GenerateNetIdTest001, TestSize.Level1)
314 {
315     auto netConnService = NetConnService::GetInstance();
316     netConnService->netIdLastValue_ = MAX_NET_ID;
317     netConnService->defaultNetSupplier_ = nullptr;
318     EXPECT_EQ(netConnService->defaultNetSupplier_, nullptr);
319     auto ret = netConnService->GenerateNetId();
320     EXPECT_EQ(ret, MIN_NET_ID);
321 }
322 
323 HWTEST_F(NetConnServiceExtTest, GenerateInternalNetIdTest001, TestSize.Level1)
324 {
325     auto netConnService = NetConnService::GetInstance();
326     netConnService->internalNetIdLastValue_ = MAX_NET_ID;
327     auto ret = netConnService->GenerateInternalNetId();
328     EXPECT_NE(ret, MIN_INTERNAL_NET_ID);
329 }
330 
331 HWTEST_F(NetConnServiceExtTest, NotFindBestSupplierTest001, TestSize.Level1)
332 {
333     auto netConnService = NetConnService::GetInstance();
334     EXPECT_FALSE(netConnService->registerToService_);
335     netConnService->NotFindBestSupplier(1, nullptr, nullptr, nullptr);
336 }
337 
338 HWTEST_F(NetConnServiceExtTest, NotFindBestSupplierTest002, TestSize.Level1)
339 {
340     auto netConnService = NetConnService::GetInstance();
341     std::string netSupplierIdent;
342     std::set<NetCap> netCaps;
343     sptr<NetSupplier> supplier = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
344     EXPECT_NE(supplier, nullptr);
345     netConnService->NotFindBestSupplier(1, nullptr, supplier, nullptr);
346 }
347 
348 HWTEST_F(NetConnServiceExtTest, NotFindBestSupplierTest003, TestSize.Level1)
349 {
350     auto netConnService = NetConnService::GetInstance();
351     std::string netSupplierIdent;
352     std::set<NetCap> netCaps;
353     sptr<NetSupplier> supplier = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
354     EXPECT_NE(supplier, nullptr);
355     sptr<INetConnCallback> callback = new (std::nothrow) NetConnCallbackStubCb();
356     netConnService->NotFindBestSupplier(1, nullptr, supplier, callback);
357 }
358 
359 HWTEST_F(NetConnServiceExtTest, HandleCallbackTest001, TestSize.Level1)
360 {
361     auto netConnService = NetConnService::GetInstance();
362     CallbackType type = CALL_TYPE_UPDATE_LINK;
363     std::string netSupplierIdent;
364     std::set<NetCap> netCaps;
365     sptr<NetSupplier> supplier = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
366     EXPECT_EQ(supplier->network_, nullptr);
367     sptr<NetHandle> netHandle = nullptr;
368     sptr<INetConnCallback> callback = new (std::nothrow) NetConnCallbackStubCb();
369     netConnService->HandleCallback(supplier, netHandle, callback, type);
370 }
371 
372 HWTEST_F(NetConnServiceExtTest, HandleCallbackTest002, TestSize.Level1)
373 {
374     auto netConnService = NetConnService::GetInstance();
375     CallbackType type = CALL_TYPE_UNAVAILABLE;
376     sptr<INetConnCallback> callback = new (std::nothrow) NetConnCallbackStubCb();
377     EXPECT_NE(callback, nullptr);
378     sptr<NetSupplier> supplier = nullptr;
379     sptr<NetHandle> netHandle = nullptr;
380     netConnService->HandleCallback(supplier, netHandle, callback, type);
381 }
382 
383 HWTEST_F(NetConnServiceExtTest, CallbackForAvailableTest001, TestSize.Level1)
384 {
385     auto netConnService = NetConnService::GetInstance();
386     std::string netSupplierIdent;
387     std::set<NetCap> netCaps;
388     sptr<NetSupplier> supplier = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
389     EXPECT_EQ(supplier->network_, nullptr);
390     netConnService->CallbackForAvailable(supplier, nullptr);
391 }
392 
393 HWTEST_F(NetConnServiceExtTest, CallbackForAvailableTest002, TestSize.Level1)
394 {
395     auto netConnService = NetConnService::GetInstance();
396     std::string netSupplierIdent;
397     std::set<NetCap> netCaps;
398     sptr<NetSupplier> supplier = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
399     EXPECT_EQ(supplier->network_, nullptr);
400     sptr<INetConnCallback> callback = new (std::nothrow) NetConnCallbackStubCb();
401     netConnService->CallbackForAvailable(supplier, callback);
402 }
403 
404 HWTEST_F(NetConnServiceExtTest, MakeDefaultNetWorkTest001, TestSize.Level1)
405 {
406     auto netConnService = NetConnService::GetInstance();
407     std::string netSupplierIdent;
408     std::set<NetCap> netCaps;
409     sptr<NetSupplier> oldSupplier = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
410     EXPECT_EQ(oldSupplier->network_, nullptr);
411     sptr<NetSupplier> newSupplier = nullptr;
412     netConnService->MakeDefaultNetWork(oldSupplier, newSupplier);
413 }
414 
415 HWTEST_F(NetConnServiceExtTest, GetNetSupplierFromListTest001, TestSize.Level1)
416 {
417     auto netConnService = NetConnService::GetInstance();
418     netConnService->netSuppliers_[1] = nullptr;
419     std::string ident;
420     auto ret = netConnService->GetNetSupplierFromList(BEARER_CELLULAR, ident);
421     EXPECT_TRUE(ret.empty());
422 }
423 
424 HWTEST_F(NetConnServiceExtTest, GetNetSupplierFromListTest002, TestSize.Level1)
425 {
426     auto netConnService = NetConnService::GetInstance();
427     netConnService->netSuppliers_[1] = nullptr;
428     std::string ident;
429     std::set<NetCap> netCaps;
430     auto ret = netConnService->GetNetSupplierFromList(BEARER_CELLULAR, ident, netCaps);
431     EXPECT_EQ(ret, nullptr);
432 }
433 
434 HWTEST_F(NetConnServiceExtTest, GetSpecificNetTest001, TestSize.Level1)
435 {
436     auto netConnService = NetConnService::GetInstance();
437     NetBearType bearerType = static_cast<NetBearType>(-1);
438     std::list<int32_t> netIdList;
439     auto ret = netConnService->GetSpecificNet(bearerType, netIdList);
440     EXPECT_EQ(ret, NET_CONN_ERR_NET_TYPE_NOT_FOUND);
441 }
442 
443 HWTEST_F(NetConnServiceExtTest, GetSpecificNetTest002, TestSize.Level1)
444 {
445     auto netConnService = NetConnService::GetInstance();
446     netConnService->netSuppliers_[1] = nullptr;
447     NetBearType bearerType = BEARER_CELLULAR;
448     std::list<int32_t> netIdList;
449     auto ret = netConnService->GetSpecificNet(bearerType, netIdList);
450     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
451 }
452 
453 HWTEST_F(NetConnServiceExtTest, GetSpecificNetByIdentTest001, TestSize.Level1)
454 {
455     auto netConnService = NetConnService::GetInstance();
456     NetBearType bearerType = static_cast<NetBearType>(-1);
457     std::string ident;
458     std::list<int32_t> netIdList;
459     auto ret = netConnService->GetSpecificNetByIdent(bearerType, ident, netIdList);
460     EXPECT_EQ(ret, NET_CONN_ERR_NET_TYPE_NOT_FOUND);
461 }
462 
463 HWTEST_F(NetConnServiceExtTest, GetSpecificNetByIdentTest002, TestSize.Level1)
464 {
465     auto netConnService = NetConnService::GetInstance();
466     netConnService->netSuppliers_[1] = nullptr;
467     NetBearType bearerType = BEARER_CELLULAR;
468     std::string ident;
469     std::list<int32_t> netIdList;
470     auto ret = netConnService->GetSpecificNetByIdent(bearerType, ident, netIdList);
471     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
472 }
473 
474 HWTEST_F(NetConnServiceExtTest, GetAllNetsTest002, TestSize.Level1)
475 {
476     auto netConnService = NetConnService::GetInstance();
477     EXPECT_EQ(netConnService->netConnEventHandler_, nullptr);
478     std::list<int32_t> netIdList;
479     auto ret = netConnService->GetAllNets(netIdList);
480     EXPECT_EQ(ret, NETMANAGER_ERROR);
481 }
482 
483 HWTEST_F(NetConnServiceExtTest, GetConnectionPropertiesTest002, TestSize.Level1)
484 {
485     auto netConnService = NetConnService::GetInstance();
486     EXPECT_EQ(netConnService->netConnEventHandler_, nullptr);
487     NetLinkInfo info;
488     auto ret = netConnService->GetConnectionProperties(0, info);
489     EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
490 }
491 
492 HWTEST_F(NetConnServiceExtTest, GetIfaceNamesTest002, TestSize.Level1)
493 {
494     auto netConnService = NetConnService::GetInstance();
495     std::list<std::string> ifaceNames;
496     auto ret = netConnService->GetIfaceNames(static_cast<NetBearType>(-1), ifaceNames);
497     EXPECT_EQ(ret, NET_CONN_ERR_NET_TYPE_NOT_FOUND);
498 }
499 
500 HWTEST_F(NetConnServiceExtTest, GetNetIdByIdentifierTest002, TestSize.Level1)
501 {
502     auto netConnService = NetConnService::GetInstance();
503     std::list<int32_t> netIdList;
504     netConnService->netSuppliers_[0] = nullptr;
505     auto ret = netConnService->GetNetIdByIdentifier(TEST_IDENT, netIdList);
506     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
507 }
508 
509 HWTEST_F(NetConnServiceExtTest, GetDumpMessageTest001, TestSize.Level1)
510 {
511     auto netConnService = NetConnService::GetInstance();
512     std::string netSupplierIdent;
513     std::set<NetCap> netCaps;
514     netConnService->defaultNetSupplier_ = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
515     EXPECT_NE(netConnService->defaultNetSupplier_, nullptr);
516     EXPECT_EQ(netConnService->defaultNetSupplier_->network_, nullptr);
517     netConnService->dnsResultCallback_ = new NetDnsResultCallback();
518     std::string message;
519     netConnService->GetDumpMessage(message);
520 }
521 
522 HWTEST_F(NetConnServiceExtTest, IsValidDecValueTest001, TestSize.Level1)
523 {
524     auto netConnService = NetConnService::GetInstance();
525     std::string inputValue = "inputValue test";
526     auto ret = netConnService->IsValidDecValue(inputValue);
527     EXPECT_FALSE(ret);
528 }
529 
530 HWTEST_F(NetConnServiceExtTest, IsValidDecValueTest002, TestSize.Level1)
531 {
532     auto netConnService = NetConnService::GetInstance();
533     std::string inputValue = "input";
534     auto ret = netConnService->IsValidDecValue(inputValue);
535     EXPECT_FALSE(ret);
536 }
537 
538 HWTEST_F(NetConnServiceExtTest, SetAirplaneModeTest003, TestSize.Level1)
539 {
540     auto netConnService = NetConnService::GetInstance();
541     EXPECT_TRUE(netConnService->preAirplaneCallbacks_.empty());
542     netConnService->preAirplaneCallbacks_[0] = new IPreAirplaneCallbackStubTestCb();
543     netConnService->preAirplaneCallbacks_[1] = nullptr;
544     auto ret = netConnService->SetAirplaneMode(true);
545     EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
546 }
547 
548 HWTEST_F(NetConnServiceExtTest, SetCurlOptionsTest001, TestSize.Level1)
549 {
550     auto netConnService = NetConnService::GetInstance();
551     EXPECT_FALSE(netConnService->registerToService_);
552     HttpProxy tempProxy;
553     netConnService->SetCurlOptions(nullptr, tempProxy);
554 }
555 
556 HWTEST_F(NetConnServiceExtTest, GetHttpUrlFromConfigTest001, TestSize.Level1)
557 {
558     auto netConnService = NetConnService::GetInstance();
559     EXPECT_FALSE(netConnService->registerToService_);
560     std::string httpUrl;
561     netConnService->GetHttpUrlFromConfig(httpUrl);
562 }
563 
564 HWTEST_F(NetConnServiceExtTest, IsValidUserIdTest001, TestSize.Level1)
565 {
566     auto netConnService = NetConnService::GetInstance();
567     auto ret = netConnService->IsValidUserId(-1);
568     EXPECT_FALSE(ret);
569 }
570 
571 HWTEST_F(NetConnServiceExtTest, GetValidUserIdFromProxyTest001, TestSize.Level1)
572 {
573     auto netConnService = NetConnService::GetInstance();
574     EXPECT_FALSE(netConnService->registerToService_);
575     HttpProxy httpProxy;
576     httpProxy.SetUserId(NetConnService::ROOT_USER_ID);
577     netConnService->GetValidUserIdFromProxy(httpProxy);
578 }
579 
580 HWTEST_F(NetConnServiceExtTest, GetValidUserIdFromProxyTest002, TestSize.Level1)
581 {
582     auto netConnService = NetConnService::GetInstance();
583     EXPECT_FALSE(netConnService->registerToService_);
584     HttpProxy httpProxy;
585     httpProxy.SetUserId(NetConnService::INVALID_USER_ID);
586     netConnService->GetValidUserIdFromProxy(httpProxy);
587 }
588 
589 HWTEST_F(NetConnServiceExtTest, NetDetectionForDnsHealthTest002, TestSize.Level1)
590 {
591     auto netConnService = NetConnService::GetInstance();
592     EXPECT_NE(netConnService->netConnEventRunner_, nullptr);
593     netConnService->netConnEventHandler_ = std::make_shared<NetConnEventHandler>(netConnService->netConnEventRunner_);
594     EXPECT_NE(netConnService->netConnEventHandler_, nullptr);
595     auto ret = netConnService->NetDetectionForDnsHealth(1, true);
596     EXPECT_NE(ret, NETMANAGER_ERROR);
597 }
598 
599 HWTEST_F(NetConnServiceExtTest, NetDetectionForDnsHealthTest003, TestSize.Level1)
600 {
601     auto netConnService = NetConnService::GetInstance();
602     EXPECT_FALSE(netConnService->registerToService_);
603     netConnService->netConnEventHandler_ = nullptr;
604     auto ret = netConnService->NetDetectionForDnsHealth(1, true);
605     EXPECT_EQ(ret, NETMANAGER_ERROR);
606 }
607 
608 HWTEST_F(NetConnServiceExtTest, LoadGlobalHttpProxyTest001, TestSize.Level1)
609 {
610     auto netConnService = NetConnService::GetInstance();
611     EXPECT_FALSE(netConnService->registerToService_);
612     NetConnService::UserIdType userIdType = NetConnService::UserIdType::LOCAL;
613     HttpProxy httpProxy;
614     netConnService->LoadGlobalHttpProxy(userIdType, httpProxy);
615 }
616 
617 HWTEST_F(NetConnServiceExtTest, LoadGlobalHttpProxyTest002, TestSize.Level1)
618 {
619     auto netConnService = NetConnService::GetInstance();
620     EXPECT_FALSE(netConnService->registerToService_);
621     NetConnService::UserIdType userIdType = static_cast<NetConnService::UserIdType>(-1);
622     HttpProxy httpProxy;
623     netConnService->LoadGlobalHttpProxy(userIdType, httpProxy);
624 }
625 
626 HWTEST_F(NetConnServiceExtTest, LoadGlobalHttpProxyTest003, TestSize.Level1)
627 {
628     auto netConnService = NetConnService::GetInstance();
629     EXPECT_FALSE(netConnService->registerToService_);
630     NetConnService::UserIdType userIdType = NetConnService::UserIdType::SPECIFY;
631     HttpProxy httpProxy;
632     httpProxy.SetUserId(1);
633     netConnService->LoadGlobalHttpProxy(userIdType, httpProxy);
634 }
635 
636 HWTEST_F(NetConnServiceExtTest, UpdateGlobalHttpProxyTest001, TestSize.Level1)
637 {
638     auto netConnService = NetConnService::GetInstance();
639     HttpProxy httpProxy;
640     netConnService->netConnEventHandler_ = std::make_shared<NetConnEventHandler>(netConnService->netConnEventRunner_);
641     EXPECT_NE(netConnService->netConnEventHandler_, nullptr);
642     netConnService->UpdateGlobalHttpProxy(httpProxy);
643 }
644 
645 HWTEST_F(NetConnServiceExtTest, OnInterfaceAddressUpdatedTest001, TestSize.Level1)
646 {
647     NetConnService::NetInterfaceStateCallback stateCallback;
648     EXPECT_TRUE(stateCallback.ifaceStateCallbacks_.empty());
649     stateCallback.ifaceStateCallbacks_.push_back(nullptr);
650     sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackStub();
651     stateCallback.ifaceStateCallbacks_.push_back(callback);
652     std::string testString = "test";
653     int testInt = 0;
654     auto ret = stateCallback.OnInterfaceAddressUpdated(testString, testString, testInt, testInt);
655     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
656 }
657 
658 HWTEST_F(NetConnServiceExtTest, OnInterfaceAddressRemovedTest001, TestSize.Level1)
659 {
660     NetConnService::NetInterfaceStateCallback stateCallback;
661     EXPECT_TRUE(stateCallback.ifaceStateCallbacks_.empty());
662     stateCallback.ifaceStateCallbacks_.push_back(nullptr);
663     sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackStub();
664     stateCallback.ifaceStateCallbacks_.push_back(callback);
665     std::string testString = "test";
666     int testInt = 0;
667     auto ret = stateCallback.OnInterfaceAddressRemoved(testString, testString, testInt, testInt);
668     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
669 }
670 
671 HWTEST_F(NetConnServiceExtTest, OnInterfaceAddedTest001, TestSize.Level1)
672 {
673     NetConnService::NetInterfaceStateCallback stateCallback;
674     EXPECT_TRUE(stateCallback.ifaceStateCallbacks_.empty());
675     stateCallback.ifaceStateCallbacks_.push_back(nullptr);
676     sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackStub();
677     stateCallback.ifaceStateCallbacks_.push_back(callback);
678     std::string testString = "test";
679     auto ret = stateCallback.OnInterfaceAdded(testString);
680     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
681 }
682 
683 HWTEST_F(NetConnServiceExtTest, OnInterfaceRemovedTest001, TestSize.Level1)
684 {
685     NetConnService::NetInterfaceStateCallback stateCallback;
686     EXPECT_TRUE(stateCallback.ifaceStateCallbacks_.empty());
687     stateCallback.ifaceStateCallbacks_.push_back(nullptr);
688     sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackStub();
689     stateCallback.ifaceStateCallbacks_.push_back(callback);
690     std::string testString = "test";
691     auto ret = stateCallback.OnInterfaceRemoved(testString);
692     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
693 }
694 
695 HWTEST_F(NetConnServiceExtTest, OnInterfaceChangedTest001, TestSize.Level1)
696 {
697     NetConnService::NetInterfaceStateCallback stateCallback;
698     EXPECT_TRUE(stateCallback.ifaceStateCallbacks_.empty());
699     stateCallback.ifaceStateCallbacks_.push_back(nullptr);
700     sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackStub();
701     stateCallback.ifaceStateCallbacks_.push_back(callback);
702     std::string testString = "test";
703     auto ret = stateCallback.OnInterfaceChanged(testString, false);
704     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
705 }
706 
707 HWTEST_F(NetConnServiceExtTest, OnInterfaceLinkStateChangedTest001, TestSize.Level1)
708 {
709     NetConnService::NetInterfaceStateCallback stateCallback;
710     EXPECT_TRUE(stateCallback.ifaceStateCallbacks_.empty());
711     stateCallback.ifaceStateCallbacks_.push_back(nullptr);
712     sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackStub();
713     stateCallback.ifaceStateCallbacks_.push_back(callback);
714     std::string testString = "test";
715     auto ret = stateCallback.OnInterfaceLinkStateChanged(testString, false);
716     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
717 }
718 
719 HWTEST_F(NetConnServiceExtTest, OnRouteChangedTest001, TestSize.Level1)
720 {
721     NetConnService::NetInterfaceStateCallback stateCallback;
722     EXPECT_TRUE(stateCallback.ifaceStateCallbacks_.empty());
723     stateCallback.ifaceStateCallbacks_.push_back(nullptr);
724     sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackStub();
725     stateCallback.ifaceStateCallbacks_.push_back(callback);
726     EXPECT_EQ(stateCallback.ifaceStateCallbacks_.size(), 2);
727     std::string testString = "test";
728     auto ret = stateCallback.OnRouteChanged(false, testString, testString, testString);
729     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
730 }
731 
732 HWTEST_F(NetConnServiceExtTest, RegisterInterfaceCallbackTest001, TestSize.Level1)
733 {
734     NetConnService::NetInterfaceStateCallback stateCallback;
735     EXPECT_TRUE(stateCallback.ifaceStateCallbacks_.empty());
736     stateCallback.ifaceStateCallbacks_.push_back(nullptr);
737     sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackStub();
738     EXPECT_NE(callback, nullptr);
739     auto ret = stateCallback.RegisterInterfaceCallback(callback);
740     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
741 }
742 
743 HWTEST_F(NetConnServiceExtTest, RegisterInterfaceCallbackTest002, TestSize.Level1)
744 {
745     NetConnService::NetInterfaceStateCallback stateCallback;
746     EXPECT_TRUE(stateCallback.ifaceStateCallbacks_.empty());
747     stateCallback.ifaceStateCallbacks_.push_back(nullptr);
748     sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackStub();
749     stateCallback.ifaceStateCallbacks_.push_back(callback);
750     EXPECT_EQ(stateCallback.ifaceStateCallbacks_.size(), 2);
751     std::string testString = "test";
752     int testInt = 0;
753     auto ret = stateCallback.RegisterInterfaceCallback(callback);
754     EXPECT_EQ(ret, NET_CONN_ERR_SAME_CALLBACK);
755 }
756 
757 HWTEST_F(NetConnServiceExtTest, OnNetIfaceStateRemoteDiedTest001, TestSize.Level1)
758 {
759     NetConnService::NetInterfaceStateCallback stateCallback;
760     EXPECT_TRUE(stateCallback.ifaceStateCallbacks_.empty());
761     wptr<IRemoteObject> remoteObject = nullptr;
762     stateCallback.OnNetIfaceStateRemoteDied(remoteObject);
763 }
764 
765 HWTEST_F(NetConnServiceExtTest, OnNetIfaceStateRemoteDiedTest002, TestSize.Level1)
766 {
767     NetConnService::NetInterfaceStateCallback stateCallback;
768     wptr<IRemoteObject> remoteObject = new MockNetIRemoteObject();
769     EXPECT_NE(remoteObject, nullptr);
770     stateCallback.OnNetIfaceStateRemoteDied(remoteObject);
771 }
772 
773 HWTEST_F(NetConnServiceExtTest, AddIfaceDeathRecipientTest001, TestSize.Level1)
774 {
775     NetConnService::NetInterfaceStateCallback stateCallback;
776     stateCallback.netIfaceStateDeathRecipient_ = new (std::nothrow)
777         NetConnService::NetInterfaceStateCallback::NetIfaceStateCallbackDeathRecipient(stateCallback);
778     EXPECT_NE(stateCallback.netIfaceStateDeathRecipient_, nullptr);
779     sptr<INetInterfaceStateCallback> callback = new (std::nothrow) NetInterfaceStateCallbackStub();
780     EXPECT_NE(callback, nullptr);
781     stateCallback.AddIfaceDeathRecipient(callback);
782 }
783 
784 HWTEST_F(NetConnServiceExtTest, NetUidPolicyChangeTest001, TestSize.Level1)
785 {
786     std::weak_ptr<NetConnService> netConnService;
787     netConnService.reset();
788     NetConnService::NetPolicyCallback policyCallback(netConnService);
789     auto ret = policyCallback.NetUidPolicyChange(1, 1);
790     EXPECT_EQ(ret, NETMANAGER_ERROR);
791 }
792 
793 HWTEST_F(NetConnServiceExtTest, NetUidPolicyChangeTest002, TestSize.Level1)
794 {
795     NetConnService::NetPolicyCallback policyCallback(NetConnService::GetInstance());
796     EXPECT_NE(NetConnService::GetInstance()->defaultNetSupplier_, nullptr);
797     EXPECT_NE(NetConnService::GetInstance()->netConnEventHandler_, nullptr);
798     auto ret = policyCallback.NetUidPolicyChange(1, 1);
799     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
800 }
801 
802 HWTEST_F(NetConnServiceExtTest, NetUidPolicyChangeTest003, TestSize.Level1)
803 {
804     NetConnService::NetPolicyCallback policyCallback(NetConnService::GetInstance());
805     EXPECT_NE(NetConnService::GetInstance()->defaultNetSupplier_, nullptr);
806     NetConnService::GetInstance()->netConnEventHandler_ = nullptr;
807     auto ret = policyCallback.NetUidPolicyChange(1, 1);
808     EXPECT_EQ(ret, NETMANAGER_ERROR);
809 }
810 
811 HWTEST_F(NetConnServiceExtTest, NetUidPolicyChangeTest004, TestSize.Level1)
812 {
813     NetConnService::NetPolicyCallback policyCallback(NetConnService::GetInstance());
814     EXPECT_NE(NetConnService::GetInstance()->defaultNetSupplier_, nullptr);
815     NetConnService::GetInstance()->defaultNetSupplier_ = nullptr;
816     auto ret = policyCallback.NetUidPolicyChange(1, 1);
817     EXPECT_EQ(ret, NETMANAGER_ERROR);
818 }
819 
820 HWTEST_F(NetConnServiceExtTest, SendNetPolicyChangeTest001, TestSize.Level1)
821 {
822     std::weak_ptr<NetConnService> netConnService;
823     netConnService.reset();
824     NetConnService::NetPolicyCallback policyCallback(netConnService);
825     EXPECT_EQ(NetConnService::GetInstance()->defaultNetSupplier_, nullptr);
826     policyCallback.SendNetPolicyChange(1, 1);
827 }
828 
829 HWTEST_F(NetConnServiceExtTest, SendNetPolicyChangeTest002, TestSize.Level1)
830 {
831     NetConnService::NetPolicyCallback policyCallback(NetConnService::GetInstance());
832     EXPECT_EQ(NetConnService::GetInstance()->defaultNetSupplier_, nullptr);
833     policyCallback.SendNetPolicyChange(1, 1);
834 }
835 
836 HWTEST_F(NetConnServiceExtTest, SendNetPolicyChangeTest003, TestSize.Level1)
837 {
838     auto netConnService = NetConnService::GetInstance();
839     std::string netSupplierIdent;
840     std::set<NetCap> netCaps;
841     netConnService->defaultNetSupplier_ = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
842     EXPECT_NE(netConnService->defaultNetSupplier_, nullptr);
843     NetConnService::NetPolicyCallback policyCallback(netConnService);
844     policyCallback.SendNetPolicyChange(1, 1);
845 }
846 
847 HWTEST_F(NetConnServiceExtTest, OnAddSystemAbilityTest002, TestSize.Level1)
848 {
849     auto netConnService = NetConnService::GetInstance();
850     EXPECT_FALSE(netConnService->hasSARemoved_);
851     std::string deviceId = "dev1";
852     netConnService->OnAddSystemAbility(COMM_NETSYS_NATIVE_SYS_ABILITY_ID, deviceId);
853 }
854 
855 HWTEST_F(NetConnServiceExtTest, OnAddSystemAbilityTest003, TestSize.Level1)
856 {
857     auto netConnService = NetConnService::GetInstance();
858     EXPECT_FALSE(netConnService->registerToService_);
859     std::string deviceId = "dev1";
860     netConnService->OnAddSystemAbility(ACCESS_TOKEN_MANAGER_SERVICE_ID, deviceId);
861 
862     EXPECT_TRUE(netConnService->registerToService_);
863     netConnService->OnAddSystemAbility(ACCESS_TOKEN_MANAGER_SERVICE_ID, deviceId);
864 }
865 
866 HWTEST_F(NetConnServiceExtTest, OnRemoveSystemAbilityTest002, TestSize.Level1)
867 {
868     auto netConnService = NetConnService::GetInstance();
869     std::string deviceId = "dev1";
870     netConnService->OnRemoveSystemAbility(COMM_NET_POLICY_MANAGER_SYS_ABILITY_ID, deviceId);
871     EXPECT_FALSE(netConnService->hasSARemoved_);
872 }
873 
874 HWTEST_F(NetConnServiceExtTest, IsSupplierMatchRequestAndNetworkTest002, TestSize.Level1)
875 {
876     auto netConnService = NetConnService::GetInstance();
877     std::string netSupplierIdent;
878     std::set<NetCap> netCaps;
879     sptr<NetSupplier> supplier = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
880     netConnService->netActivates_[0] = nullptr;
881     bool ret = netConnService->IsSupplierMatchRequestAndNetwork(supplier);
882     EXPECT_FALSE(ret);
883 }
884 
885 HWTEST_F(NetConnServiceExtTest, IsSupplierMatchRequestAndNetworkTest003, TestSize.Level1)
886 {
887     auto netConnService = NetConnService::GetInstance();
888     netConnService->defaultNetActivate_ = nullptr;
889     netConnService->CreateDefaultRequest();
890     bool ret = netConnService->IsSupplierMatchRequestAndNetwork(netConnService->defaultNetSupplier_);
891     EXPECT_FALSE(ret);
892 }
893 
894 HWTEST_F(NetConnServiceExtTest, RecoverNetSysTest001, TestSize.Level1)
895 {
896     auto netConnService = NetConnService::GetInstance();
897     EXPECT_NE(netConnService->defaultNetSupplier_, nullptr);
898     netConnService->netSuppliers_[0] = nullptr;
899     netConnService->netSuppliers_[1] = netConnService->defaultNetSupplier_;
900     netConnService->RecoverNetSys();
901 }
902 
903 HWTEST_F(NetConnServiceExtTest, RecoverNetSysTest002, TestSize.Level1)
904 {
905     auto netConnService = NetConnService::GetInstance();
906     EXPECT_EQ(netConnService->defaultNetSupplier_, nullptr);
907     netConnService->netSuppliers_[1] = nullptr;
908     netConnService->RecoverNetSys();
909 }
910 
911 HWTEST_F(NetConnServiceExtTest, RegisterSlotTypeTest001, TestSize.Level1)
912 {
913     auto netConnService = NetConnService::GetInstance();
914     netConnService->netConnEventHandler_ = nullptr;
915     uint32_t supplierId = 10;
916     int32_t type = 0;
917     auto ret = netConnService->RegisterSlotType(supplierId, type);
918     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
919 
920     EXPECT_NE(netConnService->netConnEventRunner_, nullptr);
921     netConnService->netConnEventHandler_ = std::make_shared<NetConnEventHandler>(netConnService->netConnEventRunner_);
922     EXPECT_NE(netConnService->netConnEventHandler_, nullptr);
923     ret = netConnService->RegisterSlotType(supplierId, type);
924     EXPECT_EQ(ret, NETMANAGER_ERR_INVALID_PARAMETER);
925 
926     supplierId = 1;
927     std::string netSupplierIdent;
928     std::set<NetCap> netCaps;
929     netConnService->netSuppliers_[1] = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
930     ret = netConnService->RegisterSlotType(supplierId, type);
931     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
932 }
933 
934 HWTEST_F(NetConnServiceExtTest, GetSlotTypeTest001, TestSize.Level1)
935 {
936     auto netConnService = NetConnService::GetInstance();
937     std::string type;
938     EXPECT_NE(netConnService->netConnEventHandler_, nullptr);
939     EXPECT_EQ(netConnService->defaultNetSupplier_, nullptr);
940     auto ret = netConnService->GetSlotType(type);
941     EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
942 
943     netConnService->defaultNetSupplier_ = netConnService->netSuppliers_[1];
944     EXPECT_NE(netConnService->defaultNetSupplier_, nullptr);
945     ret = netConnService->GetSlotType(type);
946     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
947 
948     netConnService->netConnEventHandler_ = nullptr;
949     ret = netConnService->GetSlotType(type);
950     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
951 }
952 
953 HWTEST_F(NetConnServiceExtTest, OnNetSysRestartTest001, TestSize.Level1)
954 {
955     auto netConnService = NetConnService::GetInstance();
956     EXPECT_EQ(netConnService->netConnEventHandler_, nullptr);
957     netConnService->OnNetSysRestart();
958 }
959 
960 HWTEST_F(NetConnServiceExtTest, IsIfaceNameInUseTest001, TestSize.Level1)
961 {
962     auto netConnService = NetConnService::GetInstance();
963     int32_t netId = 1;
964     std::string netSupplierIdent;
965     std::set<NetCap> netCaps;
966     sptr<NetSupplier> supplier = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
967     std::shared_ptr<Network> network = std::make_shared<Network>(netId, netId, nullptr,
968         NetBearType::BEARER_ETHERNET, nullptr);
969     supplier->network_ = network;
970     supplier->netSupplierInfo_.isAvailable_ = true;
971     supplier->network_->netLinkInfo_.ifaceName_ = "rmnet0";
972     netConnService->netSuppliers_.clear();
973     netConnService->netSuppliers_[1] = supplier;
974     auto ret = netConnService->IsIfaceNameInUse("rmnet0", 100);
975     EXPECT_TRUE(ret);
976 }
977 
978 HWTEST_F(NetConnServiceExtTest, GetNetCapabilitiesAsStringTest001, TestSize.Level1)
979 {
980     auto netConnService = NetConnService::GetInstance();
981     netConnService->netSuppliers_[0] = nullptr;
982     uint32_t supplierId = 2;
983     auto ret = netConnService->GetNetCapabilitiesAsString(supplierId);
984     EXPECT_TRUE(ret.empty());
985 
986     supplierId = 0;
987     ret = netConnService->GetNetCapabilitiesAsString(supplierId);
988     EXPECT_TRUE(ret.empty());
989 
990     supplierId = 1;
991     ret = netConnService->GetNetCapabilitiesAsString(supplierId);
992     EXPECT_FALSE(ret.empty());
993 }
994 
995 HWTEST_F(NetConnServiceExtTest, FindSupplierWithInternetByBearerTypeTest001, TestSize.Level1)
996 {
997     auto netConnService = NetConnService::GetInstance();
998     EXPECT_FALSE(netConnService->netSuppliers_[1]->GetNetCaps().HasNetCap(NET_CAPABILITY_INTERNET));
999     auto ret = netConnService->FindSupplierWithInternetByBearerType(NetBearType::BEARER_WIFI, TEST_IDENT);
1000     EXPECT_TRUE(ret.empty());
1001 }
1002 
1003 HWTEST_F(NetConnServiceExtTest, OnRemoteDiedTest001, TestSize.Level1)
1004 {
1005     auto netConnService = NetConnService::GetInstance();
1006     EXPECT_NE(netConnService->defaultNetSupplier_, nullptr);
1007     wptr<IRemoteObject> remoteObject = nullptr;
1008     netConnService->OnRemoteDied(remoteObject);
1009 }
1010 
1011 HWTEST_F(NetConnServiceExtTest, OnRemoteDiedTest002, TestSize.Level1)
1012 {
1013     auto netConnService = NetConnService::GetInstance();
1014     wptr<IRemoteObject> remoteObject = new MockNetIRemoteObject();
1015     EXPECT_NE(remoteObject, nullptr);
1016     netConnService->OnRemoteDied(remoteObject);
1017 }
1018 
1019 HWTEST_F(NetConnServiceExtTest, FindSupplierForConnectedTest001, TestSize.Level1)
1020 {
1021     auto netConnService = NetConnService::GetInstance();
1022     std::vector<sptr<NetSupplier>> suppliers = {nullptr};
1023     auto ret = netConnService->FindSupplierForConnected(suppliers);
1024     EXPECT_EQ(ret, 0);
1025 }
1026 
1027 HWTEST_F(NetConnServiceExtTest, OnReceiveEventTest001, TestSize.Level1)
1028 {
1029     EventFwk::CommonEventSubscribeInfo subscribeInfo;
1030     NetConnService::NetConnListener listener(subscribeInfo, nullptr);
1031     EXPECT_NE(NetConnService::GetInstance()->defaultNetSupplier_, nullptr);
1032     EventFwk::CommonEventData eventData;
1033     listener.OnReceiveEvent(eventData);
1034 }
1035 
1036 HWTEST_F(NetConnServiceExtTest, EnableVnicNetworkTest001, TestSize.Level1)
1037 {
1038     auto netConnService = NetConnService::GetInstance();
1039     sptr<NetLinkInfo> netLinkInfo = new NetLinkInfo();
1040     const std::set<int32_t> uids;
1041     EXPECT_EQ(netConnService->netConnEventHandler_, nullptr);
1042     auto ret = netConnService->EnableVnicNetwork(netLinkInfo, uids);
1043     EXPECT_EQ(ret, NETMANAGER_ERROR);
1044 
1045     netConnService->netConnEventHandler_ = nullptr;
1046     ret = netConnService->EnableVnicNetwork(netLinkInfo, uids);
1047     EXPECT_EQ(ret, NETMANAGER_ERROR);
1048 }
1049 
1050 HWTEST_F(NetConnServiceExtTest, EnableVnicNetworkAsyncTest001, TestSize.Level1)
1051 {
1052     auto netConnService = NetConnService::GetInstance();
1053     sptr<NetLinkInfo> netLinkInfo = new NetLinkInfo();
1054     const std::set<int32_t> uids;
1055 
1056     NetManagerStandard::INetAddr inetAddr;
1057     inetAddr.type_ = NetManagerStandard::INetAddr::IpType::IPV4;
1058     inetAddr.family_ = 0x01;
1059     inetAddr.address_ = "10.0.0.2.1";
1060     inetAddr.netMask_ = "255.255.255.0";
1061     inetAddr.hostName_ = "localhost";
1062     inetAddr.port_ = 80;
1063     inetAddr.prefixlen_ = 24;
1064     netLinkInfo->ifaceName_ = "vnic-tun";
1065     netLinkInfo->netAddrList_.push_back(inetAddr);
1066     netLinkInfo->mtu_ = 1500;
1067 
1068     auto ret = netConnService->EnableVnicNetworkAsync(netLinkInfo, uids);
1069     EXPECT_EQ(ret, NET_CONN_ERR_INVALID_NETWORK);
1070 }
1071 
1072 HWTEST_F(NetConnServiceExtTest, DisableVnicNetworkTest001, TestSize.Level1)
1073 {
1074     auto netConnService = NetConnService::GetInstance();
1075     auto ret = netConnService->DisableVnicNetwork();
1076     EXPECT_EQ(ret, NETMANAGER_ERROR);
1077 
1078     netConnService->netConnEventHandler_ = std::make_shared<NetConnEventHandler>(netConnService->netConnEventRunner_);
1079     EXPECT_NE(netConnService->netConnEventHandler_, nullptr);
1080     ret = netConnService->DisableVnicNetwork();
1081     EXPECT_NE(ret, NETMANAGER_ERROR);
1082 }
1083 
1084 HWTEST_F(NetConnServiceExtTest, EnableDistributedClientNetAsyncTest001, TestSize.Level1)
1085 {
1086     auto netConnService = NetConnService::GetInstance();
1087     std::string virnicAddr;
1088     std::string iif;
1089     auto ret = netConnService->EnableDistributedClientNetAsync(virnicAddr, iif);
1090     EXPECT_EQ(ret, NET_CONN_ERR_INVALID_NETWORK);
1091 }
1092 
1093 HWTEST_F(NetConnServiceExtTest, EnableDistributedClientNetAsyncTest002, TestSize.Level1)
1094 {
1095     auto netConnService = NetConnService::GetInstance();
1096     std::string virnicAddr = "192.168.1.300";
1097     std::string iif = "eth0";
1098     auto ret = netConnService->EnableDistributedClientNetAsync(virnicAddr, iif);
1099     EXPECT_EQ(ret, NET_CONN_ERR_INVALID_NETWORK);
1100 }
1101 
1102 HWTEST_F(NetConnServiceExtTest, EnableDistributedClientNetAsyncTest003, TestSize.Level1)
1103 {
1104     auto netConnService = NetConnService::GetInstance();
1105     std::string virnicAddr = "192.168.1.5";
1106     std::string iif = "eth0";
1107     auto ret = netConnService->EnableDistributedClientNetAsync(virnicAddr, iif);
1108     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1109 }
1110 
1111 HWTEST_F(NetConnServiceExtTest, EnableDistributedServerNetTest001, TestSize.Level1)
1112 {
1113     auto netConnService = NetConnService::GetInstance();
1114     std::string iif = "eth0";
1115     std::string devIface = "bond0";
1116     std::string dstAddr = "192.168.1.100";
1117     auto tmpHandler = netConnService->netConnEventHandler_;
1118     netConnService->netConnEventHandler_ = nullptr;
1119     auto ret = netConnService->EnableDistributedServerNet(iif, devIface, dstAddr);
1120     EXPECT_EQ(ret, NETMANAGER_ERROR);
1121 
1122     netConnService->netConnEventHandler_ = tmpHandler;
1123     ret = netConnService->EnableDistributedServerNet(iif, devIface, dstAddr);
1124     EXPECT_NE(ret, NETMANAGER_ERROR);
1125 }
1126 
1127 HWTEST_F(NetConnServiceExtTest, EnableDistributedServerNetAsyncTest001, TestSize.Level1)
1128 {
1129     auto netConnService = NetConnService::GetInstance();
1130     std::string iif;
1131     std::string devIface;
1132     std::string dstAddr;
1133     auto ret = netConnService->EnableDistributedServerNetAsync(iif, devIface, dstAddr);
1134     EXPECT_EQ(ret, NET_CONN_ERR_INVALID_NETWORK);
1135 
1136     iif = "eth0";
1137     ret = netConnService->EnableDistributedServerNetAsync(iif, devIface, dstAddr);
1138     EXPECT_EQ(ret, NET_CONN_ERR_INVALID_NETWORK);
1139 
1140     devIface = "bond0";
1141     dstAddr = "192.168.1.300";
1142     ret = netConnService->EnableDistributedServerNetAsync(iif, devIface, dstAddr);
1143     EXPECT_EQ(ret, NET_CONN_ERR_INVALID_NETWORK);
1144 }
1145 
1146 HWTEST_F(NetConnServiceExtTest, EnableDistributedServerNetAsyncTest002, TestSize.Level1)
1147 {
1148     auto netConnService = NetConnService::GetInstance();
1149     std::string iif = "eth0";
1150     std::string devIface = "bond0";
1151     std::string dstAddr = "192.168.1.100";
1152     auto ret = netConnService->EnableDistributedServerNetAsync(iif, devIface, dstAddr);
1153     EXPECT_EQ(ret, NETMANAGER_ERR_OPERATION_FAILED);
1154 }
1155 
1156 HWTEST_F(NetConnServiceExtTest, DisableDistributedNetTest001, TestSize.Level1)
1157 {
1158     auto netConnService = NetConnService::GetInstance();
1159     auto tmpHandler = netConnService->netConnEventHandler_;
1160     netConnService->netConnEventHandler_ = nullptr;
1161     auto ret = netConnService->DisableDistributedNet(true);
1162     EXPECT_EQ(ret, NETMANAGER_ERROR);
1163 
1164     netConnService->netConnEventHandler_ = tmpHandler;
1165     ret = netConnService->DisableDistributedNet(true);
1166     EXPECT_NE(ret, NETMANAGER_ERROR);
1167 }
1168 
1169 HWTEST_F(NetConnServiceExtTest, DisableDistributedNetAsyncTest001, TestSize.Level1)
1170 {
1171     auto netConnService = NetConnService::GetInstance();
1172     auto ret = netConnService->DisableDistributedNetAsync(false);
1173     EXPECT_TRUE(ret == NETMANAGER_ERR_OPERATION_FAILED || ret == NETMANAGER_SUCCESS);
1174 }
1175 
1176 HWTEST_F(NetConnServiceExtTest, CloseSocketsUidAsyncTest001, TestSize.Level1)
1177 {
1178     auto netConnService = NetConnService::GetInstance();
1179     int32_t netId = 0;
1180     uint32_t uid = 1;
1181     EXPECT_EQ(netConnService->networks_.find(netId), netConnService->networks_.end());
1182     auto ret = netConnService->CloseSocketsUidAsync(netId, uid);
1183     EXPECT_EQ(ret, NET_CONN_ERR_NETID_NOT_FOUND);
1184 
1185     netId = 1;
1186     EXPECT_EQ(netConnService->networks_[netId], nullptr);
1187     ret = netConnService->CloseSocketsUidAsync(netId, uid);
1188     EXPECT_EQ(ret, NET_CONN_ERR_NETID_NOT_FOUND);
1189 }
1190 
1191 HWTEST_F(NetConnServiceExtTest, SetAppIsFrozenedAsyncTest001, TestSize.Level1)
1192 {
1193     auto netConnService = NetConnService::GetInstance();
1194     uint32_t uid = 1;
1195     netConnService->netUidActivates_.clear();
1196     auto ret = netConnService->SetAppIsFrozenedAsync(uid, true);
1197     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1198 }
1199 
1200 HWTEST_F(NetConnServiceExtTest, SetAppIsFrozenedAsyncTest002, TestSize.Level1)
1201 {
1202     auto netConnService = NetConnService::GetInstance();
1203     uint32_t uid = 1;
1204     bool isFrozened = false;
1205     std::vector<std::shared_ptr<NetActivate>> activates;
1206     sptr<NetSpecifier> specifier = nullptr;
1207     sptr<INetConnCallback> callback = nullptr;
1208     std::weak_ptr<INetActivateCallback> timeoutCallback;
1209     std::shared_ptr<AppExecFwk::EventHandler> handler = nullptr;
1210     auto active = std::make_shared<NetActivate>(specifier, callback, timeoutCallback, 0, handler);
1211     activates.push_back(active);
1212     activates[0]->SetIsAppFrozened(isFrozened);
1213     netConnService->netUidActivates_[uid] = activates;
1214     auto ret = netConnService->SetAppIsFrozenedAsync(uid, isFrozened);
1215     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1216 
1217     isFrozened = true;
1218     ret = netConnService->SetAppIsFrozenedAsync(uid, isFrozened);
1219     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1220 
1221     isFrozened = false;
1222     activates[0]->SetIsAppFrozened(true);
1223     activates[0]->SetLastCallbackType(CALL_TYPE_UNKNOWN);
1224     ret = netConnService->SetAppIsFrozenedAsync(uid, isFrozened);
1225     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1226 }
1227 
1228 HWTEST_F(NetConnServiceExtTest, SetAppIsFrozenedAsyncTest003, TestSize.Level1)
1229 {
1230     auto netConnService = NetConnService::GetInstance();
1231     uint32_t uid = 1;
1232     bool isFrozened = false;
1233     auto &activates = netConnService->netUidActivates_[uid];
1234     activates[0]->SetLastCallbackType(CallbackType::CALL_TYPE_AVAILABLE);
1235     auto ret = netConnService->SetAppIsFrozenedAsync(uid, isFrozened);
1236     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1237 
1238     activates[0]->SetLastCallbackType(CallbackType::CALL_TYPE_LOST);
1239     ret = netConnService->SetAppIsFrozenedAsync(uid, isFrozened);
1240     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1241 
1242     std::string netSupplierIdent;
1243     std::set<NetCap> netCaps;
1244     activates[0]->SetLastNetid(1);
1245     EXPECT_EQ(activates[0]->GetNetCallback(), nullptr);
1246     ret = netConnService->SetAppIsFrozenedAsync(uid, isFrozened);
1247     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1248 
1249     activates[0]->netConnCallback_ = new (std::nothrow) NetConnCallbackStubCb();
1250     ret = netConnService->SetAppIsFrozenedAsync(uid, isFrozened);
1251     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1252 }
1253 
1254 HWTEST_F(NetConnServiceExtTest, SetAppIsFrozenedAsyncTest004, TestSize.Level1)
1255 {
1256     auto netConnService = NetConnService::GetInstance();
1257     uint32_t uid = 1;
1258     bool isFrozened = false;
1259     auto &activates = netConnService->netUidActivates_[uid];
1260     activates[0]->SetLastCallbackType(CallbackType::CALL_TYPE_AVAILABLE);
1261     activates[0]->SetServiceSupply(nullptr);
1262     EXPECT_EQ(activates[0]->GetServiceSupply(), nullptr);
1263     auto ret = netConnService->SetAppIsFrozenedAsync(uid, isFrozened);
1264     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1265 
1266     activates[0]->SetLastCallbackType(CallbackType::CALL_TYPE_LOST);
1267     ret = netConnService->SetAppIsFrozenedAsync(uid, isFrozened);
1268     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1269 }
1270 
1271 HWTEST_F(NetConnServiceExtTest, EnableAppFrozenedCallbackLimitationTest002, TestSize.Level1)
1272 {
1273     auto netConnService = NetConnService::GetInstance();
1274     netConnService->netConnEventHandler_ = nullptr;
1275     auto ret = netConnService->EnableAppFrozenedCallbackLimitation(true);
1276     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1277 }
1278 
1279 HWTEST_F(NetConnServiceExtTest, SetReuseSupplierIdTest002, TestSize.Level1)
1280 {
1281     auto netConnService = NetConnService::GetInstance();
1282     uint32_t supplierId = 1;
1283     uint32_t reuseSupplierId = 1;
1284     netConnService->netSuppliers_.clear();
1285     netConnService->netSuppliers_[0] = nullptr;
1286     auto ret = netConnService->SetReuseSupplierId(supplierId, reuseSupplierId, false);
1287     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1288 }
1289 
1290 HWTEST_F(NetConnServiceExtTest, SetReuseSupplierIdTest003, TestSize.Level1)
1291 {
1292     auto netConnService = NetConnService::GetInstance();
1293     uint32_t supplierId = 1;
1294     uint32_t reuseSupplierId = 2;
1295     std::string netSupplierIdent;
1296     std::set<NetCap> netCaps;
1297     sptr<NetSupplier> supplier = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
1298     supplier->supplierId_ = supplierId;
1299     netConnService->netSuppliers_[1] = supplier;
1300     auto ret = netConnService->SetReuseSupplierId(supplierId, reuseSupplierId, false);
1301     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1302 
1303     netConnService->netSuppliers_[1]->supplierId_ = reuseSupplierId;
1304     ret = netConnService->SetReuseSupplierId(supplierId, reuseSupplierId, false);
1305     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1306 
1307     netConnService->netSuppliers_[1]->supplierId_ = 0;
1308     ret = netConnService->SetReuseSupplierId(supplierId, reuseSupplierId, false);
1309     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
1310 }
1311 
1312 HWTEST_F(NetConnServiceExtTest, HandleDetectionResult001, TestSize.Level1)
1313 {
1314     auto netConnService = NetConnService::GetInstance();
1315     std::string netSupplierIdent;
1316     std::set<NetCap> netCaps;
1317     netConnService->defaultNetSupplier_ = new NetSupplier(BEARER_WIFI, netSupplierIdent, netCaps);
1318     EXPECT_NE(netConnService->defaultNetSupplier_, nullptr);
1319     uint32_t supplierId = 1;
1320     netConnService->defaultNetSupplier_->supplierId_ = supplierId;
1321     netConnService->isDelayHandleFindBestNetwork_ = true;
1322     netConnService->netSuppliers_[0] = netConnService->defaultNetSupplier_;
1323     NetConnService::GetInstance()->HandleDetectionResult(supplierId, VERIFICATION_STATE);
1324     EXPECT_FALSE(netConnService->isDelayHandleFindBestNetwork_);
1325     netConnService->defaultNetSupplier_ = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
1326     netConnService->netSuppliers_[0] = netConnService->defaultNetSupplier_;
1327     std::string netWifiSupplierIdent;
1328     sptr<NetSupplier> supplier = new NetSupplier(BEARER_WIFI, netWifiSupplierIdent, netCaps);
1329     supplier->supplierId_ = supplierId;
1330     netConnService->isDelayHandleFindBestNetwork_ = true;
1331     netConnService->delaySupplierId_ = supplierId;
1332     netConnService->netSuppliers_[1] = supplier;
1333     NetConnService::GetInstance()->HandleDetectionResult(supplierId, VERIFICATION_STATE);
1334     EXPECT_TRUE(netConnService->isDelayHandleFindBestNetwork_);
1335     netConnService->delaySupplierId_ = 0;
1336     netConnService->HandleDetectionResult(supplierId, VERIFICATION_STATE);
1337     netConnService->netSuppliers_.clear();
1338 }
1339 
1340 HWTEST_F(NetConnServiceExtTest, HandlePreFindBestNetworkForDelay001, TestSize.Level1)
1341 {
1342     auto netConnService = NetConnService::GetInstance();
1343     netConnService->HandlePreFindBestNetworkForDelay(1, nullptr);
1344     uint32_t supplierId = 1;
1345     std::string netSupplierIdent;
1346     std::set<NetCap> netCaps;
1347     netCaps.insert(NetCap::NET_CAPABILITY_CHECKING_CONNECTIVITY);
1348     sptr<NetSupplier> supplier = new NetSupplier(BEARER_WIFI, netSupplierIdent, netCaps);
1349     supplier->supplierId_ = supplierId;
1350     netConnService->isDelayHandleFindBestNetwork_ = true;
1351     netConnService->HandlePreFindBestNetworkForDelay(supplierId, supplier);
1352     netConnService->defaultNetSupplier_ = new NetSupplier(BEARER_CELLULAR, netSupplierIdent, netCaps);
1353     netConnService->netSuppliers_[1] = supplier;
1354     netConnService->isDelayHandleFindBestNetwork_ = false;
1355     OHOS::system::SetParameter("persist.booster.enable_wifi_delay_weak_signal", "false");
1356     netConnService->HandlePreFindBestNetworkForDelay(supplierId, supplier);
1357     EXPECT_FALSE(netConnService->isDelayHandleFindBestNetwork_);
1358     OHOS::system::SetParameter("persist.booster.enable_wifi_delay_weak_signal", "true");
1359     netConnService->netConnEventHandler_ = std::make_shared<NetConnEventHandler>(netConnService->netConnEventRunner_);
1360     netConnService->HandlePreFindBestNetworkForDelay(supplierId, supplier);
1361     EXPECT_TRUE(netConnService->isDelayHandleFindBestNetwork_);
1362     netConnService->netSuppliers_.clear();
1363 }
1364 
1365 HWTEST_F(NetConnServiceExtTest, HandleFindBestNetworkForDelay001, TestSize.Level1)
1366 {
1367     auto netConnService = NetConnService::GetInstance();
1368     netConnService->HandleFindBestNetworkForDelay();
1369     uint32_t supplierId = 1;
1370     std::string netSupplierIdent;
1371     std::set<NetCap> netCaps;
1372     netCaps.insert(NetCap::NET_CAPABILITY_VALIDATED);
1373     sptr<NetSupplier> supplier = new NetSupplier(BEARER_WIFI, netSupplierIdent, netCaps);
1374     supplier->supplierId_ = supplierId;
1375     netConnService->delaySupplierId_ = supplierId;
1376     netConnService->netSuppliers_[1] = supplier;
1377     netConnService->isDelayHandleFindBestNetwork_ = true;
1378     netConnService->HandleFindBestNetworkForDelay();
1379     EXPECT_EQ(netConnService->delaySupplierId_, 0);
1380     netConnService->netSuppliers_.clear();
1381 }
1382 
1383 HWTEST_F(NetConnServiceExtTest, UpdateNetSupplierInfoAsyncInvalid001, TestSize.Level1)
1384 {
1385     auto netConnService = NetConnService::GetInstance();
1386     uint32_t supplierId = 1;
1387     netConnService->isDelayHandleFindBestNetwork_ = false;
1388     netConnService->UpdateNetSupplierInfoAsyncInvalid(supplierId);
1389     EXPECT_FALSE(netConnService->isDelayHandleFindBestNetwork_);
1390 }
1391 
1392 HWTEST_F(NetConnServiceExtTest, RemoveDelayNetwork001, TestSize.Level1)
1393 {
1394     auto netConnService = NetConnService::GetInstance();
1395     netConnService->isDelayHandleFindBestNetwork_ = true;
1396     netConnService->netConnEventHandler_ = std::make_shared<NetConnEventHandler>(netConnService->netConnEventRunner_);
1397     netConnService->RemoveDelayNetwork();
1398     EXPECT_FALSE(netConnService->isDelayHandleFindBestNetwork_);
1399 }
1400 
1401 HWTEST_F(NetConnServiceExtTest, UpdateNetSupplierInfoAsync001, TestSize.Level1)
1402 {
1403     auto netConnService = NetConnService::GetInstance();
1404     uint32_t supplierId = 1;
1405     std::string netSupplierIdent;
1406     std::set<NetCap> netCaps;
1407     netCaps.insert(NetCap::NET_CAPABILITY_VALIDATED);
1408     sptr<NetSupplier> supplier = new NetSupplier(BEARER_WIFI, netSupplierIdent, netCaps);
1409     supplier->supplierId_ = supplierId;
1410     netConnService->delaySupplierId_ = supplierId;
1411     netConnService->netSuppliers_[1] = supplier;
1412     sptr<NetSupplierInfo> netSupplierInfo = new NetSupplierInfo();
1413     netSupplierInfo->isAvailable_ = false;
1414     netSupplierInfo->isRoaming_ = true;
1415     netSupplierInfo->strength_ = 0x64;
1416     netSupplierInfo->frequency_ = 0x10;
1417     netConnService->isDelayHandleFindBestNetwork_ = true;
1418     netConnService->UpdateNetSupplierInfoAsync(1, netSupplierInfo, 100);
1419     EXPECT_FALSE(netConnService->isDelayHandleFindBestNetwork_);
1420 }
1421 } // namespace NetManagerStandard
1422 } // namespace OHOS
1423