1 /*
2 * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <algorithm>
17 #include <cstring>
18 #include <gtest/gtest.h>
19 #include <iostream>
20
21 #ifdef GTEST_API_
22 #define private public
23 #define protected public
24 #endif
25
26 #include "net_conn_constants.h"
27 #include "net_manager_constants.h"
28 #include "net_stats_constants.h"
29 #include "netsys_controller.h"
30 #include "netsys_controller_service_impl.h"
31
32 namespace OHOS {
33 namespace NetManagerStandard {
34 namespace {
35 using namespace testing::ext;
36 } // namespace
37 static constexpr uint32_t TEST_UID = 1;
38 static constexpr uint64_t TEST_COOKIE = 1;
39 static constexpr uint32_t TEST_STATS_TYPE1 = 0;
40 static constexpr uint32_t TEST_STATS_TYPE2 = 2;
41
42 class NetsysControllerServiceImplTest : public testing::Test {
43 public:
44 static void SetUpTestCase();
45
46 static void TearDownTestCase();
47
48 void SetUp();
49
50 void TearDown();
51
52 static inline std::shared_ptr<NetsysControllerServiceImpl> instance_ = nullptr;
53
54 private:
55 void AddExtMockApi();
56 };
57
SetUpTestCase()58 void NetsysControllerServiceImplTest::SetUpTestCase()
59 {
60 instance_ = std::make_shared<NetsysControllerServiceImpl>();
61 if (instance_) {
62 instance_->mockNetsysClient_.mockApi_.clear();
63 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKCREATEPHYSICAL_API);
64 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKDESTROY_API);
65 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKADDINTERFACE_API);
66 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKREMOVEINTERFACE_API);
67 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKADDROUTE_API);
68 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKREMOVEROUTE_API);
69 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETINTERFACEDOWN_API);
70 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETINTERFACEUP_API);
71 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACEGETMTU_API);
72 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACESETMTU_API);
73 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACEADDADDRESS_API);
74 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACEDELADDRESS_API);
75 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETRESOLVERCONFIG_API);
76 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETRESOLVERICONFIG_API);
77 instance_->mockNetsysClient_.mockApi_.insert(MOCK_CREATENETWORKCACHE_API);
78 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETDEFAULTNETWORK_API);
79 instance_->mockNetsysClient_.mockApi_.insert(MOCK_CLEARDEFAULTNETWORK_API);
80 instance_->mockNetsysClient_.mockApi_.insert(MOCK_STARTDHCPCLIENT_API);
81 instance_->mockNetsysClient_.mockApi_.insert(MOCK_STOPDHCPCLIENT_API);
82 instance_->mockNetsysClient_.mockApi_.insert(MOCK_REGISTERNOTIFYCALLBACK_API);
83 instance_->mockNetsysClient_.mockApi_.insert(MOCK_STARTDHCPSERVICE_API);
84 instance_->mockNetsysClient_.mockApi_.insert(MOCK_STOPDHCPSERVICE_API);
85 instance_->mockNetsysClient_.mockApi_.insert(MOCK_CLOSESOCKETSUID_API);
86 }
87 }
88
AddExtMockApi()89 void NetsysControllerServiceImplTest::AddExtMockApi()
90 {
91 if (instance_) {
92 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETCELLULARRXBYTES_API);
93 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETCELLULARTXBYTES_API);
94 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETALLRXBYTES_API);
95 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETALLTXBYTES_API);
96 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETUIDRXBYTES_API);
97 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETUIDTXBYTES_API);
98 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETIFACERXBYTES_API);
99 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETIFACETXBYTES_API);
100 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACEGETLIST_API);
101 instance_->mockNetsysClient_.mockApi_.insert(MOCK_UIDGETLIST_API);
102 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETIFACERXPACKETS_API);
103 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETIFACETXPACKETS_API);
104 instance_->mockNetsysClient_.mockApi_.insert(MOCK_BINDSOCKET_API);
105 instance_->mockNetsysClient_.mockApi_.insert(MOCK_REGISTERNETSYSNOTIFYCALLBACK_API);
106 instance_->mockNetsysClient_.mockApi_.insert(MOCK_BINDNETWORKSERVICEVPN_API);
107 instance_->mockNetsysClient_.mockApi_.insert(MOCK_ENABLEVIRTUALNETIFACECARD_API);
108 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETIPADDRESS_API);
109 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETBLOCKING_API);
110 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SHAREDNSSET_API);
111 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACECLEARADDRS_API);
112 }
113 }
114
TearDownTestCase()115 void NetsysControllerServiceImplTest::TearDownTestCase() {}
116
SetUp()117 void NetsysControllerServiceImplTest::SetUp() {}
118
TearDown()119 void NetsysControllerServiceImplTest::TearDown() {}
120
121 HWTEST_F(NetsysControllerServiceImplTest, NoRegisterMockApi, TestSize.Level1)
122 {
123 uint16_t baseTimeoutMsec = 0;
124 uint8_t retryCount = 0;
125 std::string testName = "eth0";
126 std::vector<std::string> servers;
127 std::vector<std::string> domains;
128 sptr<NetsysControllerCallback> callback = nullptr;
129
130 auto ret = instance_->NetworkCreatePhysical(0, 0);
131 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
132
133 ret = instance_->NetworkDestroy(0);
134 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
135
136 ret = instance_->NetworkAddInterface(0, testName, BEARER_DEFAULT);
137 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
138
139 ret = instance_->NetworkRemoveInterface(0, testName);
140 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
141
142 ret = instance_->NetworkAddRoute(0, testName, testName, testName);
143 EXPECT_EQ(ret, -1);
144
145 ret = instance_->NetworkRemoveRoute(0, testName, testName, testName);
146 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
147
148 ret = instance_->SetInterfaceDown(testName);
149 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
150
151 ret = instance_->SetInterfaceUp(testName);
152 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
153
154 ret = instance_->GetInterfaceMtu(testName);
155 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
156
157 ret = instance_->SetInterfaceMtu(testName, 1);
158 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
159
160 ret = instance_->AddInterfaceAddress(testName, testName, 1);
161 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
162
163 ret = instance_->DelInterfaceAddress(testName, testName, 1);
164 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
165
166 ret = instance_->SetResolverConfig(0, 0, 0, servers, domains);
167 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
168
169 ret = instance_->GetResolverConfig(0, servers, domains, baseTimeoutMsec, retryCount);
170 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
171
172 ret = instance_->RegisterCallback(callback);
173 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
174 }
175
176 HWTEST_F(NetsysControllerServiceImplTest, RunRegisterMockApi, TestSize.Level1)
177 {
178 std::string testName = "wlan0";
179
180 auto ret = instance_->GetCellularRxBytes();
181 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
182
183 instance_->ClearInterfaceAddrs(testName);
184 ret = instance_->GetCellularTxBytes();
185 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
186
187 ret = instance_->GetAllRxBytes();
188 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
189
190 ret = instance_->GetAllTxBytes();
191 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
192
193 ret = instance_->GetUidRxBytes(20010038);
194 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
195
196 ret = instance_->GetUidTxBytes(20010038);
197 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
198
199 ret = instance_->GetIfaceRxBytes(testName);
200 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
201
202 ret = instance_->GetIfaceTxBytes(testName);
203 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
204
205 ret = instance_->GetIfaceRxPackets(testName);
206 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
207
208 ret = instance_->GetIfaceTxPackets(testName);
209 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
210
211 ret = instance_->CreateNetworkCache(0);
212 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
213
214 ret = instance_->SetDefaultNetWork(0);
215 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
216
217 ret = instance_->ClearDefaultNetWorkNetId();
218 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
219
220 ret = instance_->StartDhcpClient(testName, false);
221 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
222
223 ret = instance_->StopDhcpClient(testName, false);
224 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
225
226 ret = instance_->StartDhcpService(testName, testName);
227 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
228
229 ret = instance_->StopDhcpService(testName);
230 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
231
232 auto list = instance_->InterfaceGetList();
233 EXPECT_GT(list.size(), static_cast<uint32_t>(0));
234
235 list = instance_->UidGetList();
236 EXPECT_EQ(list.size(), static_cast<uint32_t>(0));
237 }
238
239 HWTEST_F(NetsysControllerServiceImplTest, ServiceImplTest, TestSize.Level1)
240 {
241 std::vector<UidRange> uidRanges;
242 UidRange uidRang(1, 2);
243 uidRanges.emplace_back(uidRang);
244 int32_t ifaceFd = 5;
245 std::string ipAddr = "172.17.5.245";
246 NetsysNotifyCallback Callback;
247 Callback.NetsysResponseInterfaceAdd = nullptr;
248 Callback.NetsysResponseInterfaceRemoved = nullptr;
249
250 auto ret = instance_->NetworkCreateVirtual(5, false);
251 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
252
253 ret = instance_->NetworkAddUids(5, uidRanges);
254 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
255
256 ret = instance_->NetworkDelUids(5, uidRanges);
257 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
258
259 auto ret32 = instance_->BindSocket(1, 2);
260 EXPECT_EQ(ret32, NetManagerStandard::NETMANAGER_SUCCESS);
261
262 ret32 = instance_->RegisterNetsysNotifyCallback(Callback);
263 EXPECT_EQ(ret32, NetManagerStandard::NETMANAGER_SUCCESS);
264
265 ret32 = instance_->BindNetworkServiceVpn(5);
266 EXPECT_NE(ret32, NetsysContrlResultCode::NETSYS_ERR_VPN);
267
268 ifreq ifRequest;
269 ret32 = instance_->EnableVirtualNetIfaceCard(5, ifRequest, ifaceFd);
270 EXPECT_EQ(ret32, NetsysContrlResultCode::NETSYS_ERR_VPN);
271
272 ret32 = instance_->SetIpAddress(5, ipAddr, 23, ifRequest);
273 EXPECT_EQ(ret32, NetsysContrlResultCode::NETSYS_ERR_VPN);
274
275 ret32 = instance_->SetBlocking(5, false);
276 EXPECT_EQ(ret32, NetManagerStandard::NETMANAGER_SUCCESS);
277 }
278
279 HWTEST_F(NetsysControllerServiceImplTest, SetInternetPermission, TestSize.Level1)
280 {
281 uint32_t uid = 0;
282 uint8_t allow = 0;
283
284 auto ret = instance_->SetInternetPermission(uid, allow);
285 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
286
287 std::string tcpBufferSizes = "524288,1048576,2097152,262144,524288,1048576";
288 ret = instance_->SetTcpBufferSizes(tcpBufferSizes);
289 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
290 }
291
292 HWTEST_F(NetsysControllerServiceImplTest, ServiceImplTest002, TestSize.Level1)
293 {
294 std::string ipAddr = "192.168.1.100";
295 std::string macAddr = "aa:bb:cc:dd:ee:ff";
296 std::string ifName = "wlan0";
297 auto ret = instance_->AddStaticArp(ipAddr, macAddr, ifName);
298 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
299
300 ret = instance_->DelStaticArp(ipAddr, macAddr, ifName);
301 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
302 }
303
304 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest001, TestSize.Level1)
305 {
306 instance_->mockNetsysClient_.mockApi_.clear();
307 int32_t netId = 0;
308 int32_t permission = 0;
309 auto ret = instance_->NetworkCreatePhysical(netId, permission);
310 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
311
312 ret = instance_->NetworkDestroy(netId);
313 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
314
315 std::string testName = "eth0";
316 ret = instance_->NetworkRemoveInterface(netId, testName);
317 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
318
319 OHOS::nmd::InterfaceConfigurationParcel cfg = {};
320 ret = instance_->GetInterfaceConfig(cfg);
321 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
322
323 ret = instance_->SetInterfaceConfig(cfg);
324 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
325
326 ret = instance_->SetInterfaceDown(testName);
327 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
328
329 uint16_t baseTimeoutMsec = 0;
330 uint8_t retryCount = 0;
331 std::vector<std::string> servers = {};
332 std::vector<std::string> domains = {};
333 ret = instance_->SetResolverConfig(netId, baseTimeoutMsec, retryCount, servers, domains);
334 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
335
336 ret = instance_->GetResolverConfig(netId, servers, domains, baseTimeoutMsec, retryCount);
337 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
338
339 ret = instance_->CreateNetworkCache(netId);
340 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
341
342 ret = instance_->DestroyNetworkCache(netId);
343 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
344
345 ret = instance_->GetCellularRxBytes();
346 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
347
348 ret = instance_->SetInterfaceUp(testName);
349 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
350
351 std::string ifName = "";
352 instance_->ClearInterfaceAddrs(ifName);
353 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
354
355 ret = instance_->GetCellularTxBytes();
356 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
357
358 ret = instance_->GetAllRxBytes();
359 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
360
361 ret = instance_->GetAllTxBytes();
362 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
363 }
364
365 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest002, TestSize.Level1)
366 {
367 instance_->mockNetsysClient_.mockApi_.clear();
368 int32_t netId = 0;
369 std::string interfaceName = "";
370 auto ret = instance_->GetIfaceRxBytes(interfaceName);
371 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
372
373 ret = instance_->GetIfaceTxBytes(interfaceName);
374 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
375
376 std::vector<std::string> ifList = {};
377 EXPECT_TRUE(instance_->InterfaceGetList() != ifList);
378 EXPECT_FALSE(instance_->UidGetList() != ifList);
379
380 ret = instance_->GetIfaceRxPackets(interfaceName);
381 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
382
383 ret = instance_->GetIfaceTxPackets(interfaceName);
384 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
385
386 ret = instance_->SetDefaultNetWork(netId);
387 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
388
389 ret = instance_->ClearDefaultNetWorkNetId();
390 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
391
392 int32_t socketFd = 0;
393 ret = instance_->BindSocket(socketFd, netId);
394 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
395
396 std::string testString = "";
397 ret = instance_->IpEnableForwarding(testString);
398 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
399
400 ret = instance_->IpDisableForwarding(testString);
401 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
402
403 ret = instance_->ShareDnsSet(netId);
404 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
405
406 ret = instance_->StartDnsProxyListen();
407 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
408
409 ret = instance_->StopDnsProxyListen();
410 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
411
412 NetsysNotifyCallback callback = {};
413 ret = instance_->RegisterNetsysNotifyCallback(callback);
414 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
415
416 uint32_t uid = 0;
417 ret = instance_->GetUidRxBytes(uid);
418 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
419
420 ret = instance_->GetUidTxBytes(uid);
421 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
422
423 ret = instance_->GetUidOnIfaceRxBytes(uid, interfaceName);
424 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
425
426 ret = instance_->GetUidOnIfaceTxBytes(uid, interfaceName);
427 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
428 }
429
430 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest003, TestSize.Level1)
431 {
432 instance_->mockNetsysClient_.mockApi_.clear();
433
434 int32_t mtu = 0;
435 std::string testName = "eth0";
436 auto ret = instance_->SetInterfaceMtu(testName, mtu);
437 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
438
439 int32_t prefixLength = 0;
440 ret = instance_->AddInterfaceAddress(testName, "", prefixLength);
441 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
442
443 ret = instance_->GetInterfaceMtu(testName);
444 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
445
446 ret = instance_->DelInterfaceAddress(testName, "", prefixLength);
447 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
448
449 ret = instance_->InterfaceSetIpAddress(testName, "");
450 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
451
452 uint16_t netId = 0;
453 std::string hostName = "";
454 std::string serverName = "";
455 AddrInfo hints = {};
456 std::vector<AddrInfo> res = {};
457 ret = instance_->GetAddrInfo(hostName, serverName, hints, netId, res);
458 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
459
460 nmd::NetworkSharingTraffic traffic = {};
461 ret = instance_->GetNetworkSharingTraffic(hostName, serverName, traffic);
462 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
463
464 ret = instance_->NetworkAddInterface(netId, testName, BEARER_DEFAULT);
465 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
466
467 ret = instance_->NetworkAddRoute(netId, testName, "", "");
468 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
469
470 ret = instance_->NetworkRemoveRoute(netId, testName, "", "");
471 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
472
473 std::string testString = "";
474 ret = instance_->EnableNat(testString, testString);
475 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
476
477 ret = instance_->DisableNat(testString, testString);
478 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
479
480 ret = instance_->IpfwdAddInterfaceForward(testString, testString);
481 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
482
483 ret = instance_->IpfwdRemoveInterfaceForward(testString, testString);
484 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
485
486 int32_t socketFd = 0;
487 ret = instance_->BindNetworkServiceVpn(socketFd);
488 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
489 }
490
491 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest004, TestSize.Level1)
492 {
493 instance_->mockNetsysClient_.mockApi_.clear();
494 struct ifreq ifRequest = {};
495 int32_t ifaceFd = 0;
496 int32_t socketFd = 0;
497 auto ret = instance_->EnableVirtualNetIfaceCard(socketFd, ifRequest, ifaceFd);
498 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
499
500 int32_t prefixLen = 0;
501 ret = instance_->SetIpAddress(socketFd, "", prefixLen, ifRequest);
502 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
503
504 ret = instance_->BandwidthEnableDataSaver(false);
505 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
506
507 int64_t bytes = 0;
508 std::string ifName = "";
509 ret = instance_->BandwidthSetIfaceQuota(ifName, bytes);
510 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
511
512 ret = instance_->BandwidthRemoveIfaceQuota(ifName);
513 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
514
515 ret = instance_->RegisterCallback(nullptr);
516 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
517
518 std::vector<uint32_t> uidsParam = {};
519 uint32_t chain = 0;
520 ret = instance_->FirewallSetUidsAllowedListChain(chain, uidsParam);
521 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
522
523 ret = instance_->FirewallSetUidsDeniedListChain(chain, uidsParam);
524 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
525
526 ret = instance_->FirewallEnableChain(chain, false);
527 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
528
529 std::string cmd = "";
530 std::string respond = "";
531 NetsysNative::IptablesType ipType = NetsysNative::IptablesType::IPTYPE_IPV4;
532 ret = instance_->SetIptablesCommandForRes(cmd, respond, ipType);
533 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
534
535 ret = instance_->SetIpCommandForRes(cmd, respond);
536 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
537
538 OHOS::NetsysNative::NetDiagPingOption pingOption;
539 ret = instance_->NetDiagPingHost(pingOption, nullptr);
540 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
541
542 std::string interfaceName = "";
543 uint64_t stats = 0;
544 uint32_t type = 0;
545 ret = instance_->GetIfaceStats(stats, type, interfaceName);
546 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
547 }
548
549 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest005, TestSize.Level1)
550 {
551 instance_->mockNetsysClient_.mockApi_.clear();
552 uint32_t firewallRule = 0;
553 uint32_t chain = 0;
554 std::vector<uint32_t> uidsParam = {};
555 int32_t ret = instance_->FirewallSetUidRule(chain, uidsParam, firewallRule);
556 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
557
558 ret = instance_->ClearFirewallAllRules();
559 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
560
561 int32_t socketFd = 0;
562 ret = instance_->SetBlocking(socketFd, false);
563 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
564
565 std::string iface = "";
566 ret = instance_->StartDhcpClient(iface, false);
567 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
568
569 ret = instance_->StopDhcpClient(iface, false);
570 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
571
572 uint32_t uid = 0;
573 ret = instance_->BandwidthAddDeniedList(uid);
574 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
575
576 ret = instance_->BandwidthRemoveDeniedList(uid);
577 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
578
579 ret = instance_->BandwidthAddAllowedList(uid);
580 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
581
582 ret = instance_->BandwidthRemoveAllowedList(uid);
583 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
584
585 std::string ipv4addr = "";
586 ret = instance_->StartDhcpService(iface, ipv4addr);
587 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
588
589 ret = instance_->StopDhcpService(iface);
590 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
591 uint64_t stats = 0;
592 uint32_t type = 0;
593 ret = instance_->GetTotalStats(stats, type);
594 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
595
596 ret = instance_->GetUidStats(stats, type, uid);
597 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
598
599 ret = instance_->DeleteStatsInfo(TEST_UID);
600 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
601
602 ret = instance_->DeleteSimStatsInfo(TEST_UID);
603 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
604
605 std::vector<OHOS::NetManagerStandard::NetStatsInfo> statsInfo = {};
606 ret = instance_->GetAllStatsInfo(statsInfo);
607 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
608
609 std::list<OHOS::NetsysNative::NetDiagRouteTable> routeTables;
610 ret = instance_->NetDiagGetRouteTable(routeTables);
611 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
612 }
613
614 HWTEST_F(NetsysControllerServiceImplTest, GetAllSimStatsInfo001, TestSize.Level1)
615 {
616 std::vector<OHOS::NetManagerStandard::NetStatsInfo> statsInfo = {};
617 auto ret = instance_->GetAllSimStatsInfo(statsInfo);
618 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
619 }
620
621 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest006, TestSize.Level1)
622 {
623 instance_->mockNetsysClient_.mockApi_.clear();
624 OHOS::NetsysNative::NetDiagProtocolType socketType = OHOS::NetsysNative::NetDiagProtocolType::PROTOCOL_TYPE_ALL;
625 OHOS::NetsysNative::NetDiagSocketsInfo socketsInfo;
626 int32_t ret = instance_->NetDiagGetSocketsInfo(socketType, socketsInfo);
627 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
628
629 std::list<OHOS::NetsysNative::NetDiagIfaceConfig> configsList;
630 std::string ifaceName = "";
631 ret = instance_->NetDiagGetInterfaceConfig(configsList, ifaceName);
632 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
633
634 OHOS::NetsysNative::NetDiagIfaceConfig config;
635 ret = instance_->NetDiagUpdateInterfaceConfig(config, ifaceName, false);
636 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
637
638 ret = instance_->NetDiagSetInterfaceActiveState(ifaceName, false);
639 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
640 }
641
642 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest007, TestSize.Level1)
643 {
644 AddExtMockApi();
645 auto result = instance_->GetCellularRxBytes();
646 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
647
648 std::string testName = "wlan0";
649 instance_->ClearInterfaceAddrs(testName);
650 result = instance_->GetCellularTxBytes();
651 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
652
653 std::string interfaceName = "";
654 result = instance_->GetIfaceTxPackets(interfaceName);
655 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
656
657 int32_t socketFd = 0;
658 int32_t netId = 0;
659 result = instance_->BindSocket(socketFd, netId);
660 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
661
662 result = instance_->ShareDnsSet(netId);
663 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
664
665 result = instance_->GetIfaceRxBytes(interfaceName);
666 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
667
668 result = instance_->GetIfaceTxBytes(interfaceName);
669 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
670
671 result = instance_->GetIfaceRxPackets(interfaceName);
672 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
673
674 uint32_t uid = 0;
675 result = instance_->GetUidOnIfaceRxBytes(uid, interfaceName);
676 EXPECT_NE(result, NetManagerStandard::NETMANAGER_SUCCESS);
677
678 result = instance_->GetUidOnIfaceTxBytes(uid, interfaceName);
679 EXPECT_NE(result, NetManagerStandard::NETMANAGER_SUCCESS);
680
681 result = instance_->GetUidRxBytes(uid);
682 EXPECT_NE(result, NetManagerStandard::NETMANAGER_SUCCESS);
683
684 std::vector<std::string> ifList = {};
685 EXPECT_FALSE(instance_->UidGetList() != ifList);
686
687 result = instance_->GetUidTxBytes(uid);
688 EXPECT_NE(result, NetManagerStandard::NETMANAGER_SUCCESS);
689 }
690
691 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest008, TestSize.Level1)
692 {
693 AddExtMockApi();
694 NetsysNotifyCallback callback = {};
695 int32_t result = instance_->RegisterNetsysNotifyCallback(callback);
696 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
697
698 int32_t socketFd = 0;
699 result = instance_->BindNetworkServiceVpn(socketFd);
700 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
701
702 int32_t ifaceFd = 0;
703 struct ifreq ifRequest = {};
704 result = instance_->EnableVirtualNetIfaceCard(socketFd, ifRequest, ifaceFd);
705 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
706
707 int32_t prefixLen = 0;
708 result = instance_->SetIpAddress(socketFd, "", prefixLen, ifRequest);
709 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
710
711 result = instance_->SetBlocking(socketFd, false);
712 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
713 }
714
715 HWTEST_F(NetsysControllerServiceImplTest, GetCookieStatsTest001, TestSize.Level1)
716 {
717 uint64_t stats = 0;
718 auto ret = instance_->GetCookieStats(stats, TEST_STATS_TYPE1, TEST_COOKIE);
719 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
720
721 ret = instance_->GetCookieStats(stats, TEST_STATS_TYPE2, TEST_COOKIE);
722 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
723 }
724
725 HWTEST_F(NetsysControllerServiceImplTest, GetNetworkSharingTypeTest001, TestSize.Level1)
726 {
727 std::set<uint32_t> sharingTypeIsOn;
728 auto ret = instance_->GetNetworkSharingType(sharingTypeIsOn);
729 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
730 }
731
732 HWTEST_F(NetsysControllerServiceImplTest, UpdateNetworkSharingTypeTest001, TestSize.Level1)
733 {
734 uint64_t type = 0;
735 bool isOpen = true;
736 auto ret = instance_->UpdateNetworkSharingType(type, isOpen);
737 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
738 }
739
740 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest009, TestSize.Level1)
741 {
742 uint32_t timeStep = 0;
743 sptr<OHOS::NetManagerStandard::NetsysDnsReportCallback> reportCallback = nullptr;
744 auto ret = instance_->RegisterDnsResultCallback(reportCallback, timeStep);
745 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
746
747 ret = instance_->UnregisterDnsResultCallback(reportCallback);
748 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
749
750 sptr<NetsysNative::INetDnsHealthCallback> healthCallback = nullptr;
751 ret = instance_->RegisterDnsHealthCallback(healthCallback);
752 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
753
754 ret = instance_->UnregisterDnsHealthCallback(healthCallback);
755 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
756 }
757
758 HWTEST_F(NetsysControllerServiceImplTest, SetIpv6PrivacyExtensionsTest001, TestSize.Level1)
759 {
760 std::string interface = "wlan0";
761 uint32_t on = 1;
762 int32_t ret = instance_->SetIpv6PrivacyExtensions(interface, on);
763 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
764
765 ret = instance_->SetEnableIpv6(interface, on);
766 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
767 }
768
769 HWTEST_F(NetsysControllerServiceImplTest, SetNetworkAccessPolicy001, TestSize.Level1)
770 {
771 uint32_t uid = 0;
772 NetworkAccessPolicy netAccessPolicy;
773 netAccessPolicy.wifiAllow = false;
774 netAccessPolicy.cellularAllow = false;
775 bool reconfirmFlag = true;
776 auto ret = instance_->SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag);
777 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
778 }
779
780 HWTEST_F(NetsysControllerServiceImplTest, NotifyNetBearerTypeChange001, TestSize.Level1)
781 {
782 std::set<NetManagerStandard::NetBearType> bearTypes;
783 bearTypes.insert(NetManagerStandard::NetBearType::BEARER_CELLULAR);
784 auto ret = instance_->NotifyNetBearerTypeChange(bearTypes);
785 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
786 }
787
788 HWTEST_F(NetsysControllerServiceImplTest, DeleteNetworkAccessPolicy001, TestSize.Level1)
789 {
790 uint32_t uid = 0;
791 auto ret = instance_->DeleteNetworkAccessPolicy(uid);
792 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
793 }
794
795 HWTEST_F(NetsysControllerServiceImplTest, CloseSocketsUid001, TestSize.Level1)
796 {
797 std::string ipAddr = "";
798 uint32_t uid = 1000;
799 int32_t result = instance_->CloseSocketsUid(ipAddr, uid);
800 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
801 }
802
803 HWTEST_F(NetsysControllerServiceImplTest, SetBrokerUidAccessPolicyMapTest001, TestSize.Level1)
804 {
805 std::unordered_map<uint32_t, uint32_t> params;
806 int32_t ret = instance_->SetBrokerUidAccessPolicyMap(params);
807 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
808 }
809
810 HWTEST_F(NetsysControllerServiceImplTest, SetBrokerUidAccessPolicyMapTest002, TestSize.Level1)
811 {
812 std::unordered_map<uint32_t, uint32_t> params;
813 params.emplace(TEST_UID, TEST_UID);
814 int32_t ret = instance_->SetBrokerUidAccessPolicyMap(params);
815 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
816 }
817
818 HWTEST_F(NetsysControllerServiceImplTest, DelBrokerUidAccessPolicyMapTest001, TestSize.Level1)
819 {
820 int32_t ret = instance_->DelBrokerUidAccessPolicyMap(TEST_UID);
821 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
822 }
823
824 #ifdef FEATURE_WEARABLE_DISTRIBUTED_NET_ENABLE
825 HWTEST_F(NetsysControllerServiceImplTest, DisableWearableDistributedNetForward, TestSize.Level1)
826 {
827 auto ret = instance_->EnableWearableDistributedNetForward(8001, 8002);
828 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
829
830 ret = instance_->DisableWearableDistributedNetForward();
831 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
832 }
833 #endif
834 } // namespace NetManagerStandard
835 } // namespace OHOS
836