1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #ifdef GTEST_API_
19 #define private public
20 #define protected public
21 #endif
22
23 #include "accesstoken_kit.h"
24 #include "net_all_capabilities.h"
25 #include "net_conn_service.h"
26 #include "net_conn_client.h"
27 #include "net_conn_constants.h"
28 #include "net_conn_types.h"
29 #include "net_manager_constants.h"
30 #include "net_mgr_log_wrapper.h"
31 #include "token_setproc.h"
32 #include "net_supplier_callback_stub.h"
33 #include "net_conn_callback_stub.h"
34 #include "http_proxy.h"
35 #include "net_detection_callback_test.h"
36 #include "net_manager_center.h"
37 #include "netsys_controller.h"
38 #include "net_http_proxy_tracker.h"
39 #include "net_interface_callback_stub.h"
40
41 namespace OHOS {
42 namespace NetManagerStandard {
43 namespace {
44 using namespace testing::ext;
45 constexpr uint32_t TEST_TIMEOUTMS = 1000;
46 constexpr int32_t TEST_NETID = 3;
47 constexpr int32_t TEST_SOCKETFD = 2;
48 const int32_t NET_ID = 2;
49 const int32_t SOCKET_FD = 2;
50 constexpr const char *TEST_IDENT = "testIdent";
51 constexpr const char *TEST_HOST = "testHost";
52 constexpr const char *TEST_PROXY_HOST = "testHttpProxy";
53 constexpr const char *TEST_IPV4_ADDR = "127.0.0.1";
54 constexpr const char *TEST_IPV6_ADDR = "240C:1:1:1::1";
55 constexpr const char *TEST_DOMAIN1 = ".com";
56 constexpr const char *TEST_DOMAIN2 = "test.com";
57 constexpr const char *TEST_DOMAIN3 = "testcom";
58 constexpr const char *TEST_DOMAIN4 = "com.test";
59 constexpr const char *TEST_DOMAIN5 = "test.co.uk";
60 constexpr const char *TEST_DOMAIN6 = "test.com.com";
61 constexpr const char *TEST_DOMAIN7 = "test1.test2.test3.test4.test5.com";
62 constexpr const char *TEST_DOMAIN8 = "http://www.example.com";
63 constexpr const char *TEST_DOMAIN9 = "https://www.example.com";
64 constexpr const char *TEST_DOMAIN10 = "httpd://www.example.com";
65 constexpr const char *TEST_LONG_HOST =
66 "0123456789qwertyuiopasdfghjklzxcvbnm[]:;<>?!@#$%^&()AEFFEqwdqwrtfasfj4897qwe465791qwr87tq4fq7t8qt4654qwr";
67 constexpr const char *TEST_LONG_EXCLUSION_LIST =
68 "www.test0.com,www.test1.com,www.test2.com,www.test3.com,www.test4.com,www.test5.com,www.test6.com,www.test7.com,"
69 "www.test8.com,www.test9.com,www.test10.com,www.test11.com,www.test12.com,www.test12.com,www.test12.com,www.test13."
70 "com,www.test14.com,www.test15.com,www.test16.com,www.test17.com,www.test18.com,www.test19.com,www.test20.com";
71 constexpr const char *NET_CONN_MANAGER_WORK_THREAD = "NET_CONN_MANAGER_WORK_THREAD";
72 constexpr int64_t TEST_UID = 1010;
73 constexpr uint32_t TEST_NOTEXISTSUPPLIER = 1000;
74
75 class NetSupplierTestCallback : public NetSupplierCallbackStub {
76 public:
RequestNetwork(const std::string & ident,const std::set<NetCap> & netCaps)77 inline int32_t RequestNetwork(const std::string &ident, const std::set<NetCap> &netCaps) override
78 {
79 return NETMANAGER_SUCCESS;
80 }
ReleaseNetwork(const std::string & ident,const std::set<NetCap> & netCaps)81 inline int32_t ReleaseNetwork(const std::string &ident, const std::set<NetCap> &netCaps) override
82 {
83 return NETMANAGER_SUCCESS;
84 }
85 };
86
87 class NetConnTestCallback : public NetConnCallbackStub {
88 public:
NetAvailable(sptr<NetHandle> & netHandle)89 inline int32_t NetAvailable(sptr<NetHandle> &netHandle) override
90 {
91 return 0;
92 }
NetCapabilitiesChange(sptr<NetHandle> & netHandle,const sptr<NetAllCapabilities> & netAllCap)93 inline int32_t NetCapabilitiesChange(sptr<NetHandle> &netHandle, const sptr<NetAllCapabilities> &netAllCap) override
94 {
95 return 0;
96 }
NetConnectionPropertiesChange(sptr<NetHandle> & netHandle,const sptr<NetLinkInfo> & info)97 inline int32_t NetConnectionPropertiesChange(sptr<NetHandle> &netHandle, const sptr<NetLinkInfo> &info) override
98 {
99 return 0;
100 }
NetLost(sptr<NetHandle> & netHandle)101 inline int32_t NetLost(sptr<NetHandle> &netHandle) override
102 {
103 return 0;
104 }
NetUnavailable()105 inline int32_t NetUnavailable() override
106 {
107 return 0;
108 }
NetBlockStatusChange(sptr<NetHandle> & netHandle,bool blocked)109 inline int32_t NetBlockStatusChange(sptr<NetHandle> &netHandle, bool blocked) override
110 {
111 return 0;
112 }
113 };
114
115 class TestDnsService : public DnsBaseService {
116 public:
GetAddressesByName(const std::string & hostName,int32_t netId,std::vector<INetAddr> & addrInfo)117 int32_t GetAddressesByName(const std::string &hostName, int32_t netId,
118 std::vector<INetAddr> &addrInfo) override
119 {
120 if (netId == TEST_NOTEXISTSUPPLIER) {
121 return NETMANAGER_ERROR;
122 } else if (netId == TEST_NETID) {
123 INetAddr netAddr;
124 netAddr.type_ = INetAddr::IPV4;
125 addrInfo.push_back(netAddr);
126 }
127 return NETSYS_SUCCESS;
128 }
129 };
130
131 sptr<INetConnCallback> g_callback = new (std::nothrow) NetConnTestCallback();
132 sptr<INetDetectionCallback> g_detectionCallback = new (std::nothrow) NetDetectionCallbackTest();
133 uint32_t g_supplierId = 0;
134 uint32_t g_vpnSupplierId = 0;
135 } // namespace
136
137 class NetConnServiceTest : public testing::Test {
138 public:
139 static void SetUpTestCase();
140 static void TearDownTestCase();
141 void SetUp();
142 void TearDown();
143 };
144
SetUpTestCase()145 void NetConnServiceTest::SetUpTestCase()
146 {
147 NetConnService::GetInstance()->OnStart();
148 if (NetConnService::GetInstance()->state_ != NetConnService::STATE_RUNNING) {
149 NetConnService::GetInstance()->netConnEventRunner_ =
150 AppExecFwk::EventRunner::Create(NET_CONN_MANAGER_WORK_THREAD);
151 ASSERT_NE(NetConnService::GetInstance()->netConnEventRunner_, nullptr);
152 NetConnService::GetInstance()->netConnEventHandler_ =
153 std::make_shared<NetConnEventHandler>(NetConnService::GetInstance()->netConnEventRunner_);
154 NetConnService::GetInstance()->serviceIface_ = std::make_unique<NetConnServiceIface>().release();
155 NetManagerCenter::GetInstance().RegisterConnService(NetConnService::GetInstance()->serviceIface_);
156 NetConnService::GetInstance()->netScore_ = std::make_unique<NetScore>();
157 ASSERT_NE(NetConnService::GetInstance()->netScore_, nullptr);
158 NetHttpProxyTracker httpProxyTracker;
159 httpProxyTracker.ReadFromSettingsData(NetConnService::GetInstance()->globalHttpProxy_);
160 NetConnService::GetInstance()->SendHttpProxyChangeBroadcast(NetConnService::GetInstance()->globalHttpProxy_);
161 }
162 }
163
TearDownTestCase()164 void NetConnServiceTest::TearDownTestCase() {}
165
SetUp()166 void NetConnServiceTest::SetUp() {}
167
TearDown()168 void NetConnServiceTest::TearDown() {}
169
170 HWTEST_F(NetConnServiceTest, SystemReadyTest001, TestSize.Level1)
171 {
172 if (!NetConnService::GetInstance()->registerToService_) {
173 NetConnService::GetInstance()->state_ = NetConnService::STATE_RUNNING;
174 }
175
176 NetConnService::GetInstance()->OnStart();
177 int32_t ret = NetConnService::GetInstance()->SystemReady();
178 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
179 }
180
181 HWTEST_F(NetConnServiceTest, SetInternetPermissionTest001, TestSize.Level1)
182 {
183 uint8_t allow = 1;
184 int32_t ret = NetConnService::GetInstance()->SetInternetPermission(TEST_UID, allow);
185 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
186 }
187
188 HWTEST_F(NetConnServiceTest, GetDefaultNetTest000, TestSize.Level1)
189 {
190 int32_t netId = 0;
191 auto ret = NetConnService::GetInstance()->GetDefaultNet(netId);
192 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
193 }
194
195 HWTEST_F(NetConnServiceTest, RegisterNetSupplierTest001, TestSize.Level1)
196 {
197 std::set<NetCap> netCaps;
198 netCaps.insert(NetCap::NET_CAPABILITY_MMS);
199 netCaps.insert(NetCap::NET_CAPABILITY_INTERNET);
200 int32_t ret = NetConnService::GetInstance()->RegisterNetSupplier(NetBearType::BEARER_DEFAULT, TEST_IDENT,
201 netCaps, g_supplierId);
202 EXPECT_EQ(ret, NET_CONN_ERR_NET_TYPE_NOT_FOUND);
203
204 ret = NetConnService::GetInstance()->RegisterNetSupplier(NetBearType::BEARER_ETHERNET, TEST_IDENT,
205 netCaps, g_supplierId);
206 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
207
208 ret = NetConnService::GetInstance()->RegisterNetSupplier(NetBearType::BEARER_VPN, TEST_IDENT,
209 netCaps, g_vpnSupplierId);
210 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
211 }
212
213 HWTEST_F(NetConnServiceTest, RegisterNetSupplierCallbackTest001, TestSize.Level1)
214 {
215 sptr<INetSupplierCallback> callback = new (std::nothrow) NetSupplierTestCallback();
216 ASSERT_NE(callback, nullptr);
217 std::set<NetCap> netCaps;
218 auto ret = NetConnService::GetInstance()->RegisterNetSupplierCallback(g_supplierId, callback);
219 EXPECT_EQ(ret, NETSYS_SUCCESS);
220 }
221
222 HWTEST_F(NetConnServiceTest, UpdateNetSupplierInfoTest001, TestSize.Level1)
223 {
224 sptr<NetSupplierInfo> netSupplierInfo = nullptr;
225 auto ret = NetConnService::GetInstance()->UpdateNetSupplierInfo(g_supplierId, netSupplierInfo);
226 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
227
228 netSupplierInfo = new (std::nothrow) NetSupplierInfo();
229 ASSERT_NE(netSupplierInfo, nullptr);
230 ret = NetConnService::GetInstance()->UpdateNetSupplierInfo(TEST_NOTEXISTSUPPLIER, netSupplierInfo);
231 EXPECT_EQ(ret, NET_CONN_ERR_NO_SUPPLIER);
232
233 netSupplierInfo->isAvailable_ = true;
234 netSupplierInfo->uid_ = TEST_UID;
235 ret = NetConnService::GetInstance()->UpdateNetSupplierInfo(g_vpnSupplierId, netSupplierInfo);
236 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
237
238 netSupplierInfo->isAvailable_ = false;
239 ret = NetConnService::GetInstance()->UpdateNetSupplierInfo(g_vpnSupplierId, netSupplierInfo);
240 EXPECT_EQ(ret, NETSYS_SUCCESS);
241 }
242
243 HWTEST_F(NetConnServiceTest, UpdateNetLinkInfoTest001, TestSize.Level1)
244 {
245 sptr<NetLinkInfo> netLinkInfo = nullptr;
246 auto ret = NetConnService::GetInstance()->UpdateNetLinkInfo(g_supplierId, netLinkInfo);
247 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
248
249 netLinkInfo = new (std::nothrow) NetLinkInfo();
250 ret = NetConnService::GetInstance()->UpdateNetLinkInfo(TEST_NOTEXISTSUPPLIER, netLinkInfo);
251 EXPECT_EQ(ret, NET_CONN_ERR_NO_SUPPLIER);
252
253 ASSERT_NE(netLinkInfo, nullptr);
254 netLinkInfo->httpProxy_.SetHost(TEST_HOST);
255 ret = NetConnService::GetInstance()->UpdateNetLinkInfo(g_supplierId, netLinkInfo);
256 EXPECT_EQ(ret, NETSYS_SUCCESS);
257 }
258
259 HWTEST_F(NetConnServiceTest, RegisterNetConnCallbackTest001, TestSize.Level1)
260 {
261 auto ret = NetConnService::GetInstance()->RegisterNetConnCallback(g_callback);
262 EXPECT_EQ(ret, NETSYS_SUCCESS);
263 }
264
265 HWTEST_F(NetConnServiceTest, UnregisterNetConnCallbackTest001, TestSize.Level1)
266 {
267 sptr<INetConnCallback> netCallback = new (std::nothrow) NetConnTestCallback();
268 auto ret = NetConnService::GetInstance()->UnregisterNetConnCallback(netCallback);
269 EXPECT_EQ(ret, NET_CONN_ERR_CALLBACK_NOT_FOUND);
270
271 ret = NetConnService::GetInstance()->UnregisterNetConnCallback(g_callback);
272 EXPECT_EQ(ret, NETSYS_SUCCESS);
273 }
274
275 HWTEST_F(NetConnServiceTest, RegisterNetConnCallbackTest002, TestSize.Level1)
276 {
277 sptr<NetSpecifier> netSpecifier = new (std::nothrow) NetSpecifier();
278 ASSERT_NE(netSpecifier, nullptr);
279 auto ret = NetConnService::GetInstance()->RegisterNetConnCallback(netSpecifier, g_callback,
280 TEST_TIMEOUTMS);
281 EXPECT_EQ(ret, NETSYS_SUCCESS);
282 }
283
284 HWTEST_F(NetConnServiceTest, RegisterNetDetectionCallbackTest001, TestSize.Level1)
285 {
286 sptr<INetDetectionCallback> callback_ = nullptr;
287 auto ret = NetConnService::GetInstance()->RegisterNetDetectionCallback(TEST_NETID, callback_);
288 EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
289
290 ret = NetConnService::GetInstance()->RegisterNetDetectionCallback(TEST_NETID, g_detectionCallback);
291 EXPECT_EQ(ret, NET_CONN_ERR_NETID_NOT_FOUND);
292
293 ret = NetConnService::GetInstance()->RegisterNetDetectionCallback(MIN_NET_ID, g_detectionCallback);
294 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
295 }
296
297 HWTEST_F(NetConnServiceTest, UnRegisterNetDetectionCallbackTest001, TestSize.Level1)
298 {
299 auto ret = NetConnService::GetInstance()->UnRegisterNetDetectionCallback(MIN_NET_ID, g_detectionCallback);
300 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
301 }
302
303 HWTEST_F(NetConnServiceTest, UpdateNetStateForTestTest001, TestSize.Level1)
304 {
305 int32_t netState = 0;
306 sptr<NetSpecifier> netSpecifier = nullptr;
307 auto ret = NetConnService::GetInstance()->UpdateNetStateForTest(netSpecifier, netState);
308 EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
309
310 netSpecifier = new (std::nothrow) NetSpecifier();
311 ret = NetConnService::GetInstance()->UpdateNetStateForTest(netSpecifier, netState);
312 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
313 }
314
315 HWTEST_F(NetConnServiceTest, GetAllNetsTest001, TestSize.Level1)
316 {
317 std::list<int32_t> netIdList;
318 auto ret = NetConnService::GetInstance()->GetAllNets(netIdList);
319 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
320 }
321
322 HWTEST_F(NetConnServiceTest, GetSpecificUidNetTest001, TestSize.Level1)
323 {
324 int32_t defaultNetId = 5;
325 auto ret = NetConnService::GetInstance()->GetDefaultNet(defaultNetId);
326 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
327 EXPECT_NE(defaultNetId, 0);
328
329 std::list<int32_t> netIdList;
330 ret = NetConnService::GetInstance()->GetSpecificNet(BEARER_VPN, netIdList);
331 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
332 EXPECT_GE(netIdList.size(), 0);
333
334 int32_t netID = 0;
335 NetConnService::GetInstance()->GetSpecificUidNet(TEST_NOTEXISTSUPPLIER, netID);
336 EXPECT_EQ(netID, defaultNetId);
337
338 NetConnService::GetInstance()->GetSpecificUidNet(TEST_UID, netID);
339 EXPECT_EQ(netID, *netIdList.begin());
340 }
341
342 HWTEST_F(NetConnServiceTest, GetConnectionPropertiesTest001, TestSize.Level1)
343 {
344 NetLinkInfo info;
345 auto ret = NetConnService::GetInstance()->GetConnectionProperties(TEST_NETID, info);
346 EXPECT_EQ(ret, NET_CONN_ERR_INVALID_NETWORK);
347
348 int32_t defaultNetId = 0;
349 ret = NetConnService::GetInstance()->GetDefaultNet(defaultNetId);
350
351 ret = NetConnService::GetInstance()->GetConnectionProperties(defaultNetId, info);
352 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
353 }
354
355 HWTEST_F(NetConnServiceTest, GetAddressesByNameTest001, TestSize.Level1)
356 {
357 std::vector<INetAddr> addrList;
358 auto ret = NetConnService::GetInstance()->GetAddressesByName(TEST_HOST, TEST_NETID, addrList);
359 EXPECT_EQ(ret, NETMANAGER_ERROR);
360 }
361
362 HWTEST_F(NetConnServiceTest, GetAddressByNameTest001, TestSize.Level1)
363 {
364 int32_t netId = 0;
365 auto ret = NetConnService::GetInstance()->GetDefaultNet(netId);
366 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
367 EXPECT_NE(netId, 0);
368
369 INetAddr addr;
370 ret = NetConnService::GetInstance()->GetAddressByName(TEST_HOST, netId, addr);
371 EXPECT_EQ(ret, NETMANAGER_ERROR);
372
373 sptr<TestDnsService> dnsService = new (std::nothrow) TestDnsService();
374 NetManagerCenter::GetInstance().RegisterDnsService(dnsService);
375
376 ret = NetConnService::GetInstance()->GetAddressByName(TEST_HOST, netId, addr);
377 EXPECT_EQ(ret, NET_CONN_ERR_NO_ADDRESS);
378
379 ret = NetConnService::GetInstance()->GetAddressByName(TEST_HOST, TEST_NETID, addr);
380 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
381 }
382
383 HWTEST_F(NetConnServiceTest, BindSocketTest001, TestSize.Level1)
384 {
385 auto ret = NetConnService::GetInstance()->BindSocket(TEST_SOCKETFD, TEST_NETID);
386 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
387 }
388
389 HWTEST_F(NetConnServiceTest, NetDetectionTest001, TestSize.Level1)
390 {
391 auto ret = NetConnService::GetInstance()->NetDetection(TEST_NETID);
392 EXPECT_EQ(ret, NET_CONN_ERR_NETID_NOT_FOUND);
393
394 ret = NetConnService::GetInstance()->NetDetection(MIN_NET_ID);
395 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
396 }
397
398 HWTEST_F(NetConnServiceTest, GetNetIdByIdentifierTest001, TestSize.Level1)
399 {
400 std::list<int32_t> netIdList;
401 auto ret = NetConnService::GetInstance()->GetNetIdByIdentifier("", netIdList);
402 EXPECT_EQ(ret, NETMANAGER_ERR_INVALID_PARAMETER);
403
404 ret = NetConnService::GetInstance()->GetNetIdByIdentifier(TEST_IDENT, netIdList);
405 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
406 }
407
408 HWTEST_F(NetConnServiceTest, GetDefaultNetTest001, TestSize.Level1)
409 {
410 int32_t netId = 0;
411 auto ret = NetConnService::GetInstance()->GetDefaultNet(netId);
412 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
413 }
414
415 HWTEST_F(NetConnServiceTest, HasDefaultNetTest001, TestSize.Level1)
416 {
417 bool bFlag = false;
418 auto ret = NetConnService::GetInstance()->HasDefaultNet(bFlag);
419 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
420 EXPECT_TRUE(bFlag);
421
422 ret = DelayedSingleton<NetConnService>::GetInstance()->HasDefaultNet(bFlag);
423 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
424 EXPECT_FALSE(bFlag);
425 }
426
427 HWTEST_F(NetConnServiceTest, GetNetCapabilitiesTest001, TestSize.Level1)
428 {
429 int32_t netId = 0;
430 int32_t ret = NetConnService::GetInstance()->GetDefaultNet(netId);
431 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
432
433 NetAllCapabilities netAllCap;
434 ret = NetConnService::GetInstance()->GetNetCapabilities(TEST_NETID, netAllCap);
435 ASSERT_EQ(ret, NET_CONN_ERR_INVALID_NETWORK);
436
437 ret = NetConnService::GetInstance()->GetNetCapabilities(netId, netAllCap);
438 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
439 }
440
441 HWTEST_F(NetConnServiceTest, SetAirplaneModeTest001, TestSize.Level1)
442 {
443 auto ret = NetConnService::GetInstance()->SetAirplaneMode(true);
444 ASSERT_EQ(ret, NETMANAGER_ERR_INTERNAL);
445 }
446
447 HWTEST_F(NetConnServiceTest, SetAirplaneModeTest002, TestSize.Level1)
448 {
449 auto ret = NetConnService::GetInstance()->SetAirplaneMode(false);
450 ASSERT_EQ(ret, NETMANAGER_ERR_INTERNAL);
451 }
452
453 HWTEST_F(NetConnServiceTest, IsDefaultNetMeteredTest001, TestSize.Level1)
454 {
455 bool bRes = false;
456 auto ret = NetConnService::GetInstance()->IsDefaultNetMetered(bRes);
457 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
458
459 ret = DelayedSingleton<NetConnService>::GetInstance()->IsDefaultNetMetered(bRes);
460 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
461 EXPECT_TRUE(bRes);
462 }
463
464 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest001, TestSize.Level1)
465 {
466 HttpProxy httpProxy = {TEST_PROXY_HOST, 0, {}};
467 auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
468 ASSERT_EQ(ret, NETMANAGER_ERR_INTERNAL);
469 }
470
471 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest002, TestSize.Level1)
472 {
473 HttpProxy httpProxy = {TEST_DOMAIN1, 8080, {}};
474 auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
475 ASSERT_TRUE(ret == NETMANAGER_ERR_INTERNAL);
476 }
477
478 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest003, TestSize.Level1)
479 {
480 HttpProxy httpProxy = {TEST_DOMAIN2, 8080, {}};
481 auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
482 ASSERT_TRUE(ret == NETMANAGER_ERR_INTERNAL);
483 }
484
485 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest004, TestSize.Level1)
486 {
487 HttpProxy httpProxy = {TEST_DOMAIN3, 8080, {}};
488 auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
489 ASSERT_TRUE(ret == NETMANAGER_ERR_INTERNAL);
490 }
491
492 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest005, TestSize.Level1)
493 {
494 HttpProxy httpProxy = {TEST_DOMAIN4, 8080, {}};
495 auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
496 ASSERT_TRUE(ret == NETMANAGER_ERR_INTERNAL);
497 }
498
499 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest006, TestSize.Level1)
500 {
501 HttpProxy httpProxy = {TEST_DOMAIN5, 8080, {}};
502 auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
503 ASSERT_TRUE(ret == NETMANAGER_ERR_INTERNAL);
504 }
505
506 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest007, TestSize.Level1)
507 {
508 HttpProxy httpProxy = {TEST_DOMAIN6, 8080, {}};
509 auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
510 ASSERT_TRUE(ret == NETMANAGER_ERR_INTERNAL);
511 }
512
513 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest008, TestSize.Level1)
514 {
515 HttpProxy httpProxy = {TEST_DOMAIN7, 8080, {}};
516 auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
517 ASSERT_TRUE(ret == NETMANAGER_ERR_INTERNAL);
518 }
519
520 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest009, TestSize.Level1)
521 {
522 HttpProxy httpProxy = {TEST_DOMAIN8, 8080, {}};
523 auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
524 ASSERT_TRUE(ret == NETMANAGER_ERR_INTERNAL);
525 }
526
527 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest010, TestSize.Level1)
528 {
529 HttpProxy httpProxy = {TEST_DOMAIN9, 8080, {}};
530 auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
531 ASSERT_TRUE(ret == NETMANAGER_ERR_INTERNAL);
532 }
533
534 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest011, TestSize.Level1)
535 {
536 HttpProxy httpProxy = {TEST_DOMAIN10, 8080, {}};
537 auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
538 ASSERT_TRUE(ret == NETMANAGER_ERR_INTERNAL);
539 }
540
541 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest012, TestSize.Level1)
542 {
543 HttpProxy httpProxy = {TEST_IPV4_ADDR, 8080, {}};
544 auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
545 ASSERT_TRUE(ret == NETMANAGER_ERR_INTERNAL);
546 }
547
548 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest013, TestSize.Level1)
549 {
550 HttpProxy httpProxy = {TEST_IPV6_ADDR, 8080, {}};
551 auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
552 ASSERT_TRUE(ret == NETMANAGER_ERR_INTERNAL);
553 }
554
555 HWTEST_F(NetConnServiceTest, SetGlobalHttpProxyTest014, TestSize.Level1)
556 {
557 HttpProxy httpProxy = {TEST_LONG_HOST, 8080, {TEST_LONG_EXCLUSION_LIST}};
558 auto ret = NetConnService::GetInstance()->SetGlobalHttpProxy(httpProxy);
559 ASSERT_EQ(ret, NETMANAGER_ERR_INTERNAL);
560 }
561
562 HWTEST_F(NetConnServiceTest, GetGlobalHttpProxyTest001, TestSize.Level1)
563 {
564 HttpProxy getGlobalHttpProxy;
565 int32_t ret = NetConnService::GetInstance()->GetGlobalHttpProxy(getGlobalHttpProxy);
566 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
567 }
568
569 HWTEST_F(NetConnServiceTest, GetDefaultHttpProxyTest001, TestSize.Level1)
570 {
571 int32_t bindNetId = 0;
572 HttpProxy defaultHttpProxy;
573 int32_t ret = NetConnService::GetInstance()->GetDefaultHttpProxy(bindNetId, defaultHttpProxy);
574 ASSERT_TRUE(ret == NET_CONN_SUCCESS);
575 }
576
577 HWTEST_F(NetConnServiceTest, GetDefaultHttpProxyTest002, TestSize.Level1)
578 {
579 int32_t bindNetId = NET_ID;
580 HttpProxy defaultHttpProxy;
581 int32_t ret = NetConnService::GetInstance()->GetDefaultHttpProxy(bindNetId, defaultHttpProxy);
582 ASSERT_TRUE(ret == NET_CONN_SUCCESS);
583 }
584
585 HWTEST_F(NetConnServiceTest, GetTest001, TestSize.Level1)
586 {
587 std::list<int32_t> netIdList;
588 int32_t ret = NetConnService::GetInstance()->GetSpecificNet(BEARER_CELLULAR, netIdList);
589 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
590
591 ret = NetConnService::GetInstance()->GetSpecificNet(BEARER_DEFAULT, netIdList);
592 EXPECT_EQ(ret, NET_CONN_ERR_NET_TYPE_NOT_FOUND);
593
594 ret = NetConnService::GetInstance()->RestrictBackgroundChanged(false);
595 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
596
597 ret = NetConnService::GetInstance()->RestrictBackgroundChanged(false);
598 EXPECT_EQ(ret, NET_CONN_ERR_NET_NO_RESTRICT_BACKGROUND);
599
600 NetConnService::GetInstance()->HandleDetectionResult(TEST_NOTEXISTSUPPLIER, true);
601 NetConnService::GetInstance()->HandleDetectionResult(g_supplierId, true);
602
603 std::vector<std::u16string> args;
604 args.emplace_back(u"dummy data");
605 ret = NetConnService::GetInstance()->Dump(SOCKET_FD, args);
606 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
607
608 ret = DelayedSingleton<NetConnService>::GetInstance()->Dump(SOCKET_FD, args);
609 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
610 }
611
612 HWTEST_F(NetConnServiceTest, OnNetActivateTimeOutTest001, TestSize.Level1)
613 {
614 NetConnService::GetInstance()->OnNetActivateTimeOut(NET_ID);
615 if (NetConnService::GetInstance()->netActivates_.size() > 0) {
616 uint32_t nNetID = NetConnService::GetInstance()->netActivates_.begin()->first;
617 NetConnService::GetInstance()->OnNetActivateTimeOut(nNetID);
618 for (auto iterSupplier = NetConnService::GetInstance()->netSuppliers_.begin();
619 iterSupplier != NetConnService::GetInstance()->netSuppliers_.end(); ++iterSupplier) {
620 if (iterSupplier->second == nullptr) {
621 continue;
622 }
623 EXPECT_EQ(iterSupplier->second->requestList_.find(nNetID), iterSupplier->second->requestList_.end());
624 }
625 }
626 }
627
628 HWTEST_F(NetConnServiceTest, GetIfaceNamesTest001, TestSize.Level1)
629 {
630 std::list<std::string> ifaceNames;
631 auto ret = NetConnService::GetInstance()->GetIfaceNames(BEARER_DEFAULT, ifaceNames);
632 EXPECT_EQ(ret, NET_CONN_ERR_NET_TYPE_NOT_FOUND);
633
634 ret = NetConnService::GetInstance()->GetIfaceNames(BEARER_VPN, ifaceNames);
635 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
636 }
637
638 HWTEST_F(NetConnServiceTest, GetIfaceNameByTypeTest001, TestSize.Level1)
639 {
640 std::string ifaceName;
641 auto ret = NetConnService::GetInstance()->GetIfaceNameByType(BEARER_DEFAULT, TEST_IDENT, ifaceName);
642 EXPECT_EQ(ret, NET_CONN_ERR_NET_TYPE_NOT_FOUND);
643
644 ret = NetConnService::GetInstance()->GetIfaceNameByType(BEARER_BLUETOOTH, TEST_IDENT, ifaceName);
645 EXPECT_EQ(ret, NET_CONN_ERR_NO_SUPPLIER);
646
647 ret = NetConnService::GetInstance()->GetIfaceNameByType(BEARER_VPN, TEST_IDENT, ifaceName);
648 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
649 }
650
651 HWTEST_F(NetConnServiceTest, SetAppNetTest001, TestSize.Level1)
652 {
653 auto ret = NetConnService::GetInstance()->SetAppNet(TEST_NETID);
654 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
655 }
656
657 HWTEST_F(NetConnServiceTest, RegisterNetInterfaceCallbackTest001, TestSize.Level1)
658 {
659 sptr<INetInterfaceStateCallback> callback = nullptr;
660 auto ret = NetConnService::GetInstance()->RegisterNetInterfaceCallback(callback);
661 EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
662
663 callback = new (std::nothrow) NetInterfaceStateCallbackStub();
664 ret = NetConnService::GetInstance()->RegisterNetInterfaceCallback(callback);
665 EXPECT_EQ(ret, NETMANAGER_ERR_LOCAL_PTR_NULL);
666
667 NetConnService::GetInstance()->interfaceStateCallback_ =
668 new (std::nothrow) NetConnService::NetInterfaceStateCallback();
669 ASSERT_NE(NetConnService::GetInstance()->interfaceStateCallback_, nullptr);
670 NetsysController::GetInstance().RegisterCallback(NetConnService::GetInstance()->interfaceStateCallback_);
671
672 ret = NetConnService::GetInstance()->RegisterNetInterfaceCallback(callback);
673 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
674 }
675
676 HWTEST_F(NetConnServiceTest, GetNetInterfaceConfigurationTest001, TestSize.Level1)
677 {
678 NetInterfaceConfiguration config;
679 auto ret = NetConnService::GetInstance()->GetNetInterfaceConfiguration("wlan0", config);
680 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
681 }
682 } // namespace NetManagerStandard
683 } // namespace OHOS