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 }
86 }
87
AddExtMockApi()88 void NetsysControllerServiceImplTest::AddExtMockApi()
89 {
90 if (instance_) {
91 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETCELLULARRXBYTES_API);
92 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETCELLULARTXBYTES_API);
93 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETALLRXBYTES_API);
94 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETALLTXBYTES_API);
95 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETUIDRXBYTES_API);
96 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETUIDTXBYTES_API);
97 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETIFACERXBYTES_API);
98 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETIFACETXBYTES_API);
99 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACEGETLIST_API);
100 instance_->mockNetsysClient_.mockApi_.insert(MOCK_UIDGETLIST_API);
101 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETIFACERXPACKETS_API);
102 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETIFACETXPACKETS_API);
103 instance_->mockNetsysClient_.mockApi_.insert(MOCK_BINDSOCKET_API);
104 instance_->mockNetsysClient_.mockApi_.insert(MOCK_REGISTERNETSYSNOTIFYCALLBACK_API);
105 instance_->mockNetsysClient_.mockApi_.insert(MOCK_BINDNETWORKSERVICEVPN_API);
106 instance_->mockNetsysClient_.mockApi_.insert(MOCK_ENABLEVIRTUALNETIFACECARD_API);
107 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETIPADDRESS_API);
108 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETBLOCKING_API);
109 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SHAREDNSSET_API);
110 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACECLEARADDRS_API);
111 }
112 }
113
TearDownTestCase()114 void NetsysControllerServiceImplTest::TearDownTestCase() {}
115
SetUp()116 void NetsysControllerServiceImplTest::SetUp() {}
117
TearDown()118 void NetsysControllerServiceImplTest::TearDown() {}
119
120 HWTEST_F(NetsysControllerServiceImplTest, NoRegisterMockApi, TestSize.Level1)
121 {
122 uint16_t baseTimeoutMsec = 0;
123 uint8_t retryCount = 0;
124 std::string testName = "eth0";
125 std::vector<std::string> servers;
126 std::vector<std::string> domains;
127 sptr<NetsysControllerCallback> callback = nullptr;
128
129 auto ret = instance_->NetworkCreatePhysical(0, 0);
130 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
131
132 ret = instance_->NetworkDestroy(0);
133 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
134
135 ret = instance_->NetworkAddInterface(0, testName, BEARER_DEFAULT);
136 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
137
138 ret = instance_->NetworkRemoveInterface(0, testName);
139 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
140
141 ret = instance_->NetworkAddRoute(0, testName, testName, testName);
142 EXPECT_EQ(ret, -1);
143
144 ret = instance_->NetworkRemoveRoute(0, testName, testName, testName);
145 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
146
147 ret = instance_->SetInterfaceDown(testName);
148 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
149
150 ret = instance_->SetInterfaceUp(testName);
151 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
152
153 ret = instance_->GetInterfaceMtu(testName);
154 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
155
156 ret = instance_->SetInterfaceMtu(testName, 1);
157 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
158
159 ret = instance_->AddInterfaceAddress(testName, testName, 1);
160 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
161
162 ret = instance_->DelInterfaceAddress(testName, testName, 1);
163 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
164
165 ret = instance_->SetResolverConfig(0, 0, 0, servers, domains);
166 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
167
168 ret = instance_->GetResolverConfig(0, servers, domains, baseTimeoutMsec, retryCount);
169 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
170
171 ret = instance_->RegisterCallback(callback);
172 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
173 }
174
175 HWTEST_F(NetsysControllerServiceImplTest, RunRegisterMockApi, TestSize.Level1)
176 {
177 std::string testName = "wlan0";
178
179 auto ret = instance_->GetCellularRxBytes();
180 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
181
182 instance_->ClearInterfaceAddrs(testName);
183 ret = instance_->GetCellularTxBytes();
184 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
185
186 ret = instance_->GetAllRxBytes();
187 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
188
189 ret = instance_->GetAllTxBytes();
190 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
191
192 ret = instance_->GetUidRxBytes(20010038);
193 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
194
195 ret = instance_->GetUidTxBytes(20010038);
196 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
197
198 ret = instance_->GetIfaceRxBytes(testName);
199 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
200
201 ret = instance_->GetIfaceTxBytes(testName);
202 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
203
204 ret = instance_->GetIfaceRxPackets(testName);
205 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
206
207 ret = instance_->GetIfaceTxPackets(testName);
208 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
209
210 ret = instance_->CreateNetworkCache(0);
211 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
212
213 ret = instance_->SetDefaultNetWork(0);
214 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
215
216 ret = instance_->ClearDefaultNetWorkNetId();
217 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
218
219 ret = instance_->StartDhcpClient(testName, false);
220 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
221
222 ret = instance_->StopDhcpClient(testName, false);
223 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
224
225 ret = instance_->StartDhcpService(testName, testName);
226 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
227
228 ret = instance_->StopDhcpService(testName);
229 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
230
231 auto list = instance_->InterfaceGetList();
232 EXPECT_GT(list.size(), static_cast<uint32_t>(0));
233
234 list = instance_->UidGetList();
235 EXPECT_EQ(list.size(), static_cast<uint32_t>(0));
236 }
237
238 HWTEST_F(NetsysControllerServiceImplTest, ServiceImplTest, TestSize.Level1)
239 {
240 std::vector<UidRange> uidRanges;
241 UidRange uidRang(1, 2);
242 uidRanges.emplace_back(uidRang);
243 int32_t ifaceFd = 5;
244 std::string ipAddr = "172.17.5.245";
245 NetsysNotifyCallback Callback;
246 Callback.NetsysResponseInterfaceAdd = nullptr;
247 Callback.NetsysResponseInterfaceRemoved = nullptr;
248
249 auto ret = instance_->NetworkCreateVirtual(5, false);
250 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
251
252 ret = instance_->NetworkAddUids(5, uidRanges);
253 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
254
255 ret = instance_->NetworkDelUids(5, uidRanges);
256 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
257
258 auto ret32 = instance_->BindSocket(1, 2);
259 EXPECT_EQ(ret32, NetManagerStandard::NETMANAGER_SUCCESS);
260
261 ret32 = instance_->RegisterNetsysNotifyCallback(Callback);
262 EXPECT_EQ(ret32, NetManagerStandard::NETMANAGER_SUCCESS);
263
264 ret32 = instance_->BindNetworkServiceVpn(5);
265 EXPECT_EQ(ret32, NetsysContrlResultCode::NETSYS_ERR_VPN);
266
267 ifreq ifRequest;
268 ret32 = instance_->EnableVirtualNetIfaceCard(5, ifRequest, ifaceFd);
269 EXPECT_EQ(ret32, NetsysContrlResultCode::NETSYS_ERR_VPN);
270
271 ret32 = instance_->SetIpAddress(5, ipAddr, 23, ifRequest);
272 EXPECT_EQ(ret32, NetsysContrlResultCode::NETSYS_ERR_VPN);
273
274 ret32 = instance_->SetBlocking(5, false);
275 EXPECT_EQ(ret32, NetManagerStandard::NETMANAGER_SUCCESS);
276 }
277
278 HWTEST_F(NetsysControllerServiceImplTest, SetInternetPermission, TestSize.Level1)
279 {
280 uint32_t uid = 0;
281 uint8_t allow = 0;
282
283 auto ret = instance_->SetInternetPermission(uid, allow);
284 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
285
286 std::string tcpBufferSizes = "524288,1048576,2097152,262144,524288,1048576";
287 ret = instance_->SetTcpBufferSizes(tcpBufferSizes);
288 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
289 }
290
291 HWTEST_F(NetsysControllerServiceImplTest, ServiceImplTest002, TestSize.Level1)
292 {
293 std::string ipAddr = "192.168.1.100";
294 std::string macAddr = "aa:bb:cc:dd:ee:ff";
295 std::string ifName = "wlan0";
296 auto ret = instance_->AddStaticArp(ipAddr, macAddr, ifName);
297 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
298
299 ret = instance_->DelStaticArp(ipAddr, macAddr, ifName);
300 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
301 }
302
303 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest001, TestSize.Level1)
304 {
305 instance_->mockNetsysClient_.mockApi_.clear();
306 int32_t netId = 0;
307 int32_t permission = 0;
308 auto ret = instance_->NetworkCreatePhysical(netId, permission);
309 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
310
311 ret = instance_->NetworkDestroy(netId);
312 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
313
314 std::string testName = "eth0";
315 ret = instance_->NetworkRemoveInterface(netId, testName);
316 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
317
318 OHOS::nmd::InterfaceConfigurationParcel cfg = {};
319 ret = instance_->GetInterfaceConfig(cfg);
320 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
321
322 ret = instance_->SetInterfaceConfig(cfg);
323 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
324
325 ret = instance_->SetInterfaceDown(testName);
326 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
327
328 uint16_t baseTimeoutMsec = 0;
329 uint8_t retryCount = 0;
330 std::vector<std::string> servers = {};
331 std::vector<std::string> domains = {};
332 ret = instance_->SetResolverConfig(netId, baseTimeoutMsec, retryCount, servers, domains);
333 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
334
335 ret = instance_->GetResolverConfig(netId, servers, domains, baseTimeoutMsec, retryCount);
336 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
337
338 ret = instance_->CreateNetworkCache(netId);
339 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
340
341 ret = instance_->DestroyNetworkCache(netId);
342 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
343
344 ret = instance_->GetCellularRxBytes();
345 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
346
347 ret = instance_->SetInterfaceUp(testName);
348 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
349
350 std::string ifName = "";
351 instance_->ClearInterfaceAddrs(ifName);
352 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
353
354 ret = instance_->GetCellularTxBytes();
355 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
356
357 ret = instance_->GetAllRxBytes();
358 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
359
360 ret = instance_->GetAllTxBytes();
361 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
362 }
363
364 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest002, TestSize.Level1)
365 {
366 instance_->mockNetsysClient_.mockApi_.clear();
367 int32_t netId = 0;
368 std::string interfaceName = "";
369 auto ret = instance_->GetIfaceRxBytes(interfaceName);
370 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
371
372 ret = instance_->GetIfaceTxBytes(interfaceName);
373 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
374
375 std::vector<std::string> ifList = {};
376 EXPECT_TRUE(instance_->InterfaceGetList() != ifList);
377 EXPECT_FALSE(instance_->UidGetList() != ifList);
378
379 ret = instance_->GetIfaceRxPackets(interfaceName);
380 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
381
382 ret = instance_->GetIfaceTxPackets(interfaceName);
383 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
384
385 ret = instance_->SetDefaultNetWork(netId);
386 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
387
388 ret = instance_->ClearDefaultNetWorkNetId();
389 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
390
391 int32_t socketFd = 0;
392 ret = instance_->BindSocket(socketFd, netId);
393 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
394
395 std::string testString = "";
396 ret = instance_->IpEnableForwarding(testString);
397 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
398
399 ret = instance_->IpDisableForwarding(testString);
400 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
401
402 ret = instance_->ShareDnsSet(netId);
403 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
404
405 ret = instance_->StartDnsProxyListen();
406 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
407
408 ret = instance_->StopDnsProxyListen();
409 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
410
411 NetsysNotifyCallback callback = {};
412 ret = instance_->RegisterNetsysNotifyCallback(callback);
413 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
414
415 uint32_t uid = 0;
416 ret = instance_->GetUidRxBytes(uid);
417 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
418
419 ret = instance_->GetUidTxBytes(uid);
420 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
421
422 ret = instance_->GetUidOnIfaceRxBytes(uid, interfaceName);
423 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
424
425 ret = instance_->GetUidOnIfaceTxBytes(uid, interfaceName);
426 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
427 }
428
429 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest003, TestSize.Level1)
430 {
431 instance_->mockNetsysClient_.mockApi_.clear();
432
433 int32_t mtu = 0;
434 std::string testName = "eth0";
435 auto ret = instance_->SetInterfaceMtu(testName, mtu);
436 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
437
438 int32_t prefixLength = 0;
439 ret = instance_->AddInterfaceAddress(testName, "", prefixLength);
440 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
441
442 ret = instance_->GetInterfaceMtu(testName);
443 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
444
445 ret = instance_->DelInterfaceAddress(testName, "", prefixLength);
446 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
447
448 ret = instance_->InterfaceSetIpAddress(testName, "");
449 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
450
451 uint16_t netId = 0;
452 std::string hostName = "";
453 std::string serverName = "";
454 AddrInfo hints = {};
455 std::vector<AddrInfo> res = {};
456 ret = instance_->GetAddrInfo(hostName, serverName, hints, netId, res);
457 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
458
459 nmd::NetworkSharingTraffic traffic = {};
460 ret = instance_->GetNetworkSharingTraffic(hostName, serverName, traffic);
461 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
462
463 ret = instance_->NetworkAddInterface(netId, testName, BEARER_DEFAULT);
464 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
465
466 ret = instance_->NetworkAddRoute(netId, testName, "", "");
467 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
468
469 ret = instance_->NetworkRemoveRoute(netId, testName, "", "");
470 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
471
472 std::string testString = "";
473 ret = instance_->EnableNat(testString, testString);
474 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
475
476 ret = instance_->DisableNat(testString, testString);
477 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
478
479 ret = instance_->IpfwdAddInterfaceForward(testString, testString);
480 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
481
482 ret = instance_->IpfwdRemoveInterfaceForward(testString, testString);
483 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
484
485 int32_t socketFd = 0;
486 ret = instance_->BindNetworkServiceVpn(socketFd);
487 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
488 }
489
490 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest004, TestSize.Level1)
491 {
492 instance_->mockNetsysClient_.mockApi_.clear();
493 struct ifreq ifRequest = {};
494 int32_t ifaceFd = 0;
495 int32_t socketFd = 0;
496 auto ret = instance_->EnableVirtualNetIfaceCard(socketFd, ifRequest, ifaceFd);
497 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
498
499 int32_t prefixLen = 0;
500 ret = instance_->SetIpAddress(socketFd, "", prefixLen, ifRequest);
501 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
502
503 ret = instance_->BandwidthEnableDataSaver(false);
504 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
505
506 int64_t bytes = 0;
507 std::string ifName = "";
508 ret = instance_->BandwidthSetIfaceQuota(ifName, bytes);
509 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
510
511 ret = instance_->BandwidthRemoveIfaceQuota(ifName);
512 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
513
514 ret = instance_->RegisterCallback(nullptr);
515 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
516
517 std::vector<uint32_t> uidsParam = {};
518 uint32_t chain = 0;
519 ret = instance_->FirewallSetUidsAllowedListChain(chain, uidsParam);
520 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
521
522 ret = instance_->FirewallSetUidsDeniedListChain(chain, uidsParam);
523 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
524
525 ret = instance_->FirewallEnableChain(chain, false);
526 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
527
528 std::string cmd = "";
529 std::string respond = "";
530 NetsysNative::IptablesType ipType = NetsysNative::IptablesType::IPTYPE_IPV4;
531 ret = instance_->SetIptablesCommandForRes(cmd, respond, ipType);
532 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
533
534 OHOS::NetsysNative::NetDiagPingOption pingOption;
535 ret = instance_->NetDiagPingHost(pingOption, nullptr);
536 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
537
538 std::string interfaceName = "";
539 uint64_t stats = 0;
540 uint32_t type = 0;
541 ret = instance_->GetIfaceStats(stats, type, interfaceName);
542 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
543 }
544
545 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest005, TestSize.Level1)
546 {
547 instance_->mockNetsysClient_.mockApi_.clear();
548 uint32_t firewallRule = 0;
549 uint32_t chain = 0;
550 std::vector<uint32_t> uidsParam = {};
551 int32_t ret = instance_->FirewallSetUidRule(chain, uidsParam, firewallRule);
552 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
553
554 ret = instance_->ClearFirewallAllRules();
555 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
556
557 int32_t socketFd = 0;
558 ret = instance_->SetBlocking(socketFd, false);
559 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
560
561 std::string iface = "";
562 ret = instance_->StartDhcpClient(iface, false);
563 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
564
565 ret = instance_->StopDhcpClient(iface, false);
566 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
567
568 uint32_t uid = 0;
569 ret = instance_->BandwidthAddDeniedList(uid);
570 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
571
572 ret = instance_->BandwidthRemoveDeniedList(uid);
573 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
574
575 ret = instance_->BandwidthAddAllowedList(uid);
576 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
577
578 ret = instance_->BandwidthRemoveAllowedList(uid);
579 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
580
581 std::string ipv4addr = "";
582 ret = instance_->StartDhcpService(iface, ipv4addr);
583 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
584
585 ret = instance_->StopDhcpService(iface);
586 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
587 uint64_t stats = 0;
588 uint32_t type = 0;
589 ret = instance_->GetTotalStats(stats, type);
590 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
591
592 ret = instance_->GetUidStats(stats, type, uid);
593 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
594
595 ret = instance_->DeleteStatsInfo(TEST_UID);
596 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
597
598 ret = instance_->DeleteSimStatsInfo(TEST_UID);
599 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
600
601 std::vector<OHOS::NetManagerStandard::NetStatsInfo> statsInfo = {};
602 ret = instance_->GetAllStatsInfo(statsInfo);
603 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
604
605 std::list<OHOS::NetsysNative::NetDiagRouteTable> routeTables;
606 ret = instance_->NetDiagGetRouteTable(routeTables);
607 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
608 }
609
610 HWTEST_F(NetsysControllerServiceImplTest, GetAllSimStatsInfo001, TestSize.Level1)
611 {
612 std::vector<OHOS::NetManagerStandard::NetStatsInfo> statsInfo = {};
613 auto ret = instance_->GetAllSimStatsInfo(statsInfo);
614 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
615 }
616
617 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest006, TestSize.Level1)
618 {
619 instance_->mockNetsysClient_.mockApi_.clear();
620 OHOS::NetsysNative::NetDiagProtocolType socketType = OHOS::NetsysNative::NetDiagProtocolType::PROTOCOL_TYPE_ALL;
621 OHOS::NetsysNative::NetDiagSocketsInfo socketsInfo;
622 int32_t ret = instance_->NetDiagGetSocketsInfo(socketType, socketsInfo);
623 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
624
625 std::list<OHOS::NetsysNative::NetDiagIfaceConfig> configsList;
626 std::string ifaceName = "";
627 ret = instance_->NetDiagGetInterfaceConfig(configsList, ifaceName);
628 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
629
630 OHOS::NetsysNative::NetDiagIfaceConfig config;
631 ret = instance_->NetDiagUpdateInterfaceConfig(config, ifaceName, false);
632 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
633
634 ret = instance_->NetDiagSetInterfaceActiveState(ifaceName, false);
635 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
636 }
637
638 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest007, TestSize.Level1)
639 {
640 AddExtMockApi();
641 auto result = instance_->GetCellularRxBytes();
642 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
643
644 std::string testName = "wlan0";
645 instance_->ClearInterfaceAddrs(testName);
646 result = instance_->GetCellularTxBytes();
647 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
648
649 std::string interfaceName = "";
650 result = instance_->GetIfaceTxPackets(interfaceName);
651 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
652
653 int32_t socketFd = 0;
654 int32_t netId = 0;
655 result = instance_->BindSocket(socketFd, netId);
656 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
657
658 result = instance_->ShareDnsSet(netId);
659 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
660
661 result = instance_->GetIfaceRxBytes(interfaceName);
662 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
663
664 result = instance_->GetIfaceTxBytes(interfaceName);
665 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
666
667 result = instance_->GetIfaceRxPackets(interfaceName);
668 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
669
670 uint32_t uid = 0;
671 result = instance_->GetUidOnIfaceRxBytes(uid, interfaceName);
672 EXPECT_NE(result, NetManagerStandard::NETMANAGER_SUCCESS);
673
674 result = instance_->GetUidOnIfaceTxBytes(uid, interfaceName);
675 EXPECT_NE(result, NetManagerStandard::NETMANAGER_SUCCESS);
676
677 result = instance_->GetUidRxBytes(uid);
678 EXPECT_NE(result, NetManagerStandard::NETMANAGER_SUCCESS);
679
680 std::vector<std::string> ifList = {};
681 EXPECT_FALSE(instance_->UidGetList() != ifList);
682
683 result = instance_->GetUidTxBytes(uid);
684 EXPECT_NE(result, NetManagerStandard::NETMANAGER_SUCCESS);
685 }
686
687 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest008, TestSize.Level1)
688 {
689 AddExtMockApi();
690 NetsysNotifyCallback callback = {};
691 int32_t result = instance_->RegisterNetsysNotifyCallback(callback);
692 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
693
694 int32_t socketFd = 0;
695 result = instance_->BindNetworkServiceVpn(socketFd);
696 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
697
698 int32_t ifaceFd = 0;
699 struct ifreq ifRequest = {};
700 result = instance_->EnableVirtualNetIfaceCard(socketFd, ifRequest, ifaceFd);
701 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
702
703 int32_t prefixLen = 0;
704 result = instance_->SetIpAddress(socketFd, "", prefixLen, ifRequest);
705 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
706
707 result = instance_->SetBlocking(socketFd, false);
708 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
709 }
710
711 HWTEST_F(NetsysControllerServiceImplTest, GetNetworkSharingTypeTest001, TestSize.Level1)
712 {
713 std::set<uint32_t> sharingTypeIsOn;
714 auto ret = instance_->GetNetworkSharingType(sharingTypeIsOn);
715 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
716 }
717
718 HWTEST_F(NetsysControllerServiceImplTest, UpdateNetworkSharingTypeTest001, TestSize.Level1)
719 {
720 uint64_t type = 0;
721 bool isOpen = true;
722 auto ret = instance_->UpdateNetworkSharingType(type, isOpen);
723 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
724 }
725
726 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest009, TestSize.Level1)
727 {
728 uint32_t timeStep = 0;
729 sptr<OHOS::NetManagerStandard::NetsysDnsReportCallback> reportCallback = nullptr;
730 auto ret = instance_->RegisterDnsResultCallback(reportCallback, timeStep);
731 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
732
733 ret = instance_->UnregisterDnsResultCallback(reportCallback);
734 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
735
736 sptr<NetsysNative::INetDnsHealthCallback> healthCallback = nullptr;
737 ret = instance_->RegisterDnsHealthCallback(healthCallback);
738 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
739
740 ret = instance_->UnregisterDnsHealthCallback(healthCallback);
741 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
742 }
743
744 HWTEST_F(NetsysControllerServiceImplTest, SetIpv6PrivacyExtensionsTest001, TestSize.Level1)
745 {
746 std::string interface = "wlan0";
747 uint32_t on = 1;
748 int32_t ret = instance_->SetIpv6PrivacyExtensions(interface, on);
749 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
750
751 ret = instance_->SetEnableIpv6(interface, on);
752 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
753 }
754
755 HWTEST_F(NetsysControllerServiceImplTest, SetNetworkAccessPolicy001, TestSize.Level1)
756 {
757 uint32_t uid = 0;
758 NetworkAccessPolicy netAccessPolicy;
759 netAccessPolicy.wifiAllow = false;
760 netAccessPolicy.cellularAllow = false;
761 bool reconfirmFlag = true;
762 bool isBroker = false;
763 auto ret = instance_->SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag, isBroker);
764 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
765 }
766
767 HWTEST_F(NetsysControllerServiceImplTest, NotifyNetBearerTypeChange001, TestSize.Level1)
768 {
769 std::set<NetManagerStandard::NetBearType> bearTypes;
770 bearTypes.insert(NetManagerStandard::NetBearType::BEARER_CELLULAR);
771 auto ret = instance_->NotifyNetBearerTypeChange(bearTypes);
772 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
773 }
774
775 HWTEST_F(NetsysControllerServiceImplTest, DeleteNetworkAccessPolicy001, TestSize.Level1)
776 {
777 uint32_t uid = 0;
778 auto ret = instance_->DeleteNetworkAccessPolicy(uid);
779 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
780 }
781 } // namespace NetManagerStandard
782 } // namespace OHOS
783