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 <algorithm>
17 #include <gtest/gtest.h>
18 #include <string>
19
20 #include "interface_manager.h"
21 #include "netsys_controller.h"
22 #include "system_ability_definition.h"
23
24 #ifdef GTEST_API_
25 #define private public
26 #define protected public
27 #endif
28
29 #include "dns_config_client.h"
30 #include "net_manager_constants.h"
31 #include "netsys_native_service.h"
32 #include "notify_callback_stub.h"
33
34 namespace OHOS {
35 namespace NetsysNative {
36 namespace {
37 using namespace NetManagerStandard;
38 using namespace testing::ext;
39 #define DTEST_LOG std::cout << __func__ << ":" << __LINE__ << ":"
40 class TestNotifyCallback : public NotifyCallbackStub {
41 public:
42 TestNotifyCallback() = default;
~TestNotifyCallback()43 ~TestNotifyCallback() override {};
OnInterfaceAddressUpdated(const std::string & addr,const std::string & ifName,int flags,int scope)44 int32_t OnInterfaceAddressUpdated(const std::string &addr, const std::string &ifName, int flags,
45 int scope) override
46 {
47 return 0;
48 }
49
OnInterfaceAddressRemoved(const std::string & addr,const std::string & ifName,int flags,int scope)50 int32_t OnInterfaceAddressRemoved(const std::string &addr, const std::string &ifName, int flags,
51 int scope) override
52 {
53 return 0;
54 }
55
OnInterfaceAdded(const std::string & ifName)56 int32_t OnInterfaceAdded(const std::string &ifName) override
57 {
58 return 0;
59 }
60
OnInterfaceRemoved(const std::string & ifName)61 int32_t OnInterfaceRemoved(const std::string &ifName) override
62 {
63 return 0;
64 }
65
OnInterfaceChanged(const std::string & ifName,bool up)66 int32_t OnInterfaceChanged(const std::string &ifName, bool up) override
67 {
68 return 0;
69 }
70
OnInterfaceLinkStateChanged(const std::string & ifName,bool up)71 int32_t OnInterfaceLinkStateChanged(const std::string &ifName, bool up) override
72 {
73 return 0;
74 }
75
OnRouteChanged(bool updated,const std::string & route,const std::string & gateway,const std::string & ifName)76 int32_t OnRouteChanged(bool updated, const std::string &route, const std::string &gateway,
77 const std::string &ifName) override
78 {
79 return 0;
80 }
81
OnDhcpSuccess(sptr<OHOS::NetsysNative::DhcpResultParcel> & dhcpResult)82 int32_t OnDhcpSuccess(sptr<OHOS::NetsysNative::DhcpResultParcel> &dhcpResult) override
83 {
84 return 0;
85 }
86
OnBandwidthReachedLimit(const std::string & limitName,const std::string & iface)87 int32_t OnBandwidthReachedLimit(const std::string &limitName, const std::string &iface) override
88 {
89 return 0;
90 }
91 };
92 } // namespace
93
94 class NetsysNativeServiceTest : public testing::Test {
95 public:
96 static void SetUpTestCase();
97 static void TearDownTestCase();
98 void SetUp();
99 void TearDown();
100 static inline auto instance_ = std::make_shared<NetsysNativeService>(COMM_NETSYS_NATIVE_SYS_ABILITY_ID);
101 };
102
SetUpTestCase()103 void NetsysNativeServiceTest::SetUpTestCase() {}
104
TearDownTestCase()105 void NetsysNativeServiceTest::TearDownTestCase() {}
106
SetUp()107 void NetsysNativeServiceTest::SetUp() {}
108
TearDown()109 void NetsysNativeServiceTest::TearDown() {}
110
111 HWTEST_F(NetsysNativeServiceTest, DumpTest001, TestSize.Level1)
112 {
113 NetsysNativeService service;
114 service.state_ = NetsysNativeService::ServiceRunningState::STATE_RUNNING;
115 service.OnStart();
116 instance_->Init();
117 int32_t testFd = 11;
118 int32_t ret = instance_->Dump(testFd, {});
119 EXPECT_LE(ret, NETMANAGER_SUCCESS);
120 }
121
122 HWTEST_F(NetsysNativeServiceTest, SetResolverConfigTest001, TestSize.Level1)
123 {
124 uint16_t testNetId = 154;
125 uint16_t baseTimeoutMsec = 200;
126 uint8_t retryCount = 3;
127 int32_t ret = instance_->SetResolverConfig(testNetId, baseTimeoutMsec, retryCount, {}, {});
128 EXPECT_EQ(ret, 0);
129 }
130
131 HWTEST_F(NetsysNativeServiceTest, GetResolverConfigTest001, TestSize.Level1)
132 {
133 uint16_t testNetId = 154;
134 uint16_t baseTimeoutMsec = 200;
135 uint8_t retryCount = 3;
136 std::vector<std::string> servers;
137 std::vector<std::string> domains;
138 int32_t ret = instance_->GetResolverConfig(testNetId, servers, domains, baseTimeoutMsec, retryCount);
139 EXPECT_EQ(ret, 0);
140 }
141
142 HWTEST_F(NetsysNativeServiceTest, CreateNetworkCacheTest001, TestSize.Level1)
143 {
144 uint16_t testNetId = 154;
145 int32_t ret = instance_->CreateNetworkCache(testNetId);
146 EXPECT_EQ(ret, 0);
147 }
148
149 HWTEST_F(NetsysNativeServiceTest, DestroyNetworkCacheTest001, TestSize.Level1)
150 {
151 uint16_t testNetId = 154;
152 int32_t ret = instance_->DestroyNetworkCache(testNetId);
153 EXPECT_LE(ret, NETMANAGER_SUCCESS);
154 }
155
156 HWTEST_F(NetsysNativeServiceTest, NetworkAddRouteTest001, TestSize.Level1)
157 {
158 uint16_t testNetId = 154;
159 std::string interfaceName = "eth1";
160 std::string destination = "";
161 std::string nextHop = "";
162 int32_t ret = instance_->NetworkAddRoute(testNetId, interfaceName, destination, nextHop);
163 EXPECT_LE(ret, NETMANAGER_SUCCESS);
164 }
165
166 HWTEST_F(NetsysNativeServiceTest, NetworkAddRouteParcelTest001, TestSize.Level1)
167 {
168 uint16_t testNetId = 154;
169 RouteInfoParcel routeInfo;
170 int32_t ret = instance_->NetworkAddRouteParcel(testNetId, routeInfo);
171 EXPECT_LE(ret, NETMANAGER_SUCCESS);
172 }
173
174 HWTEST_F(NetsysNativeServiceTest, NetworkRemoveRouteParcelTest001, TestSize.Level1)
175 {
176 uint16_t testNetId = 154;
177 RouteInfoParcel routeInfo;
178 int32_t ret = instance_->NetworkRemoveRouteParcel(testNetId, routeInfo);
179 EXPECT_LE(ret, NETMANAGER_SUCCESS);
180 }
181
182 HWTEST_F(NetsysNativeServiceTest, NetworkSetDefaultTest001, TestSize.Level1)
183 {
184 uint16_t testNetId = 154;
185 int32_t ret = instance_->NetworkSetDefault(testNetId);
186 EXPECT_GE(ret, NETMANAGER_SUCCESS);
187 }
188
189 HWTEST_F(NetsysNativeServiceTest, NetworkGetDefaultTest001, TestSize.Level1)
190 {
191 int32_t ret = instance_->NetworkGetDefault();
192 EXPECT_LE(ret, 154);
193 }
194
195 HWTEST_F(NetsysNativeServiceTest, NetworkClearDefaultTest001, TestSize.Level1)
196 {
197 int32_t ret = instance_->NetworkClearDefault();
198 EXPECT_LE(ret, NETMANAGER_SUCCESS);
199 }
200
201 HWTEST_F(NetsysNativeServiceTest, GetProcSysNetTest001, TestSize.Level1)
202 {
203 int32_t ipversion = 45;
204 int32_t which = 14;
205 std::string ifname = "testifname";
206 std::string paramete = "testparamete";
207 std::string value = "testvalue";
208 int32_t ret = instance_->GetProcSysNet(ipversion, which, ifname, paramete, value);
209 EXPECT_LE(ret, NETMANAGER_SUCCESS);
210 }
211
212 HWTEST_F(NetsysNativeServiceTest, SetProcSysNetTest001, TestSize.Level1)
213 {
214 int32_t ipversion = 45;
215 int32_t which = 14;
216 std::string ifname = "testifname";
217 std::string paramete = "testparamete";
218 std::string value = "testvalue";
219 int32_t ret = instance_->SetProcSysNet(ipversion, which, ifname, paramete, value);
220 EXPECT_LE(ret, NETMANAGER_SUCCESS);
221 }
222
223 HWTEST_F(NetsysNativeServiceTest, SetInterfaceMtu001, TestSize.Level1)
224 {
225 std::string testName = "test0";
226 int32_t mtu = 1500;
227 int32_t ret = instance_->SetInterfaceMtu(testName, mtu);
228 EXPECT_NE(ret, 0);
229 std::string eth0Name = "eth0";
230 auto ifaceList = NetsysController::GetInstance().InterfaceGetList();
231 bool eth0NotExist = std::find(ifaceList.begin(), ifaceList.end(), eth0Name) == ifaceList.end();
232 if (eth0NotExist) {
233 return;
234 }
235 ret = instance_->SetInterfaceMtu(eth0Name, mtu);
236 EXPECT_EQ(ret, 0);
237 }
238
239 HWTEST_F(NetsysNativeServiceTest, GetInterfaceMtu001, TestSize.Level1)
240 {
241 std::string testName = "test0";
242 int32_t ret = instance_->GetInterfaceMtu(testName);
243 EXPECT_NE(ret, 0);
244 std::string eth0Name = "eth0";
245 ret = instance_->GetInterfaceMtu(eth0Name);
246 EXPECT_NE(ret, 0);
247 }
248
249 HWTEST_F(NetsysNativeServiceTest, RegisterNotifyCallback001, TestSize.Level1)
250 {
251 sptr<INotifyCallback> callback = new (std::nothrow) TestNotifyCallback();
252 int32_t ret = instance_->RegisterNotifyCallback(callback);
253 EXPECT_EQ(ret, 0);
254
255 ret = instance_->UnRegisterNotifyCallback(callback);
256 EXPECT_EQ(ret, 0);
257 }
258
259 HWTEST_F(NetsysNativeServiceTest, NetworkRemoveRouteTest001, TestSize.Level1)
260 {
261 uint16_t testNetId = 154;
262 std::string interfaceName = "eth1";
263 std::string destination = "";
264 std::string nextHop = "";
265 int32_t ret = instance_->NetworkRemoveRoute(testNetId, interfaceName, destination, nextHop);
266 EXPECT_NE(ret, 0);
267 }
268
269 HWTEST_F(NetsysNativeServiceTest, NetworkCreatePhysicalTest001, TestSize.Level1)
270 {
271 int32_t netId = 1000;
272 int32_t permission = 0;
273 int32_t ret = instance_->NetworkCreatePhysical(netId, permission);
274 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
275 }
276
277 HWTEST_F(NetsysNativeServiceTest, AddInterfaceAddressTest001, TestSize.Level1)
278 {
279 std::string iFName = "test0";
280 std::string addrStr = "192.168.22.33";
281 int32_t prefixLength = 24;
282 int32_t ret = instance_->AddInterfaceAddress(iFName, addrStr, prefixLength);
283 EXPECT_NE(ret, NETMANAGER_SUCCESS);
284 }
285
286 HWTEST_F(NetsysNativeServiceTest, DelInterfaceAddressTest001, TestSize.Level1)
287 {
288 std::string iFName = "test0";
289 std::string addrStr = "192.168.22.33";
290 int32_t prefixLength = 24;
291 int32_t ret = instance_->DelInterfaceAddress(iFName, addrStr, prefixLength);
292 EXPECT_NE(ret, NETMANAGER_SUCCESS);
293 }
294
295 HWTEST_F(NetsysNativeServiceTest, InterfaceSetIpAddressTest001, TestSize.Level1)
296 {
297 std::string iFName = "test0";
298 std::string addrStr = "192.168.22.33";
299 int32_t ret = instance_->InterfaceSetIpAddress(iFName, addrStr);
300 EXPECT_NE(ret, NETMANAGER_SUCCESS);
301 }
302
303 HWTEST_F(NetsysNativeServiceTest, InterfaceSetIffUpTest001, TestSize.Level1)
304 {
305 std::string iFName = "test0";
306 int32_t ret = instance_->InterfaceSetIffUp(iFName);
307 EXPECT_NE(ret, NETMANAGER_SUCCESS);
308 }
309
310 HWTEST_F(NetsysNativeServiceTest, NetworkAddInterfaceTest001, TestSize.Level1)
311 {
312 int32_t netId = 1000;
313 std::string iFName = "test0";
314 int32_t ret = instance_->NetworkAddInterface(netId, iFName);
315 EXPECT_NE(ret, NETMANAGER_SUCCESS);
316 }
317
318 HWTEST_F(NetsysNativeServiceTest, NetworkRemoveInterfaceTest001, TestSize.Level1)
319 {
320 int32_t netId = 1000;
321 std::string iFName = "test0";
322 int32_t ret = instance_->NetworkRemoveInterface(netId, iFName);
323 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
324 }
325
326 HWTEST_F(NetsysNativeServiceTest, NetworkDestroyTest001, TestSize.Level1)
327 {
328 int32_t netId = 1000;
329 int32_t ret = instance_->NetworkDestroy(netId);
330 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
331 }
332
333 HWTEST_F(NetsysNativeServiceTest, GetFwmarkForNetworkTest001, TestSize.Level1)
334 {
335 int32_t netId = 1000;
336 MarkMaskParcel markMaskParcel;
337 int32_t ret = instance_->GetFwmarkForNetwork(netId, markMaskParcel);
338 EXPECT_EQ(ret, ERR_NONE);
339 }
340
341 HWTEST_F(NetsysNativeServiceTest, SetInterfaceConfigTest001, TestSize.Level1)
342 {
343 InterfaceConfigurationParcel cfg;
344 cfg.ifName = "test0";
345 cfg.hwAddr = "0b:2c:43:d7:22:1s";
346 cfg.ipv4Addr = "192.168.133.12";
347 cfg.prefixLength = 24;
348 cfg.flags.push_back("up");
349 int32_t ret = instance_->SetInterfaceConfig(cfg);
350 EXPECT_EQ(ret, ERR_NONE);
351 }
352
353 HWTEST_F(NetsysNativeServiceTest, GetInterfaceConfigTest001, TestSize.Level1)
354 {
355 InterfaceConfigurationParcel cfg;
356 cfg.ifName = "eth0";
357 int32_t ret = instance_->GetInterfaceConfig(cfg);
358 EXPECT_EQ(ret, ERR_NONE);
359 }
360
361 HWTEST_F(NetsysNativeServiceTest, InterfaceGetListTest001, TestSize.Level1)
362 {
363 std::vector<std::string> ifaces;
364 int32_t ret = instance_->InterfaceGetList(ifaces);
365 EXPECT_EQ(ret, ERR_NONE);
366 }
367
368 HWTEST_F(NetsysNativeServiceTest, StartDhcpClientTest001, TestSize.Level1)
369 {
370 std::string iface = "test0";
371 bool bIpv6 = false;
372 int32_t ret = instance_->StartDhcpClient(iface, bIpv6);
373 EXPECT_EQ(ret, ERR_NONE);
374
375 ret = instance_->StopDhcpClient(iface, bIpv6);
376 EXPECT_EQ(ret, ERR_NONE);
377 }
378
379 HWTEST_F(NetsysNativeServiceTest, StartDhcpServiceTest001, TestSize.Level1)
380 {
381 std::string iface = "test0";
382 std::string ipv4addr = "192.168.133.12";
383 int32_t ret = instance_->StartDhcpService(iface, ipv4addr);
384 EXPECT_EQ(ret, ERR_NONE);
385
386 ret = instance_->StopDhcpService(iface);
387 EXPECT_EQ(ret, ERR_NONE);
388 }
389
390 HWTEST_F(NetsysNativeServiceTest, IpEnableForwardingTest001, TestSize.Level1)
391 {
392 std::string iface = "";
393 std::string eth0 = "eth0";
394 int32_t ret = instance_->IpEnableForwarding(iface);
395 EXPECT_EQ(ret, 0);
396 ret = instance_->IpDisableForwarding(iface);
397 EXPECT_EQ(ret, 0);
398
399 ret = instance_->EnableNat(eth0, eth0);
400 EXPECT_NE(ret, 0);
401 ret = instance_->DisableNat(eth0, eth0);
402 EXPECT_NE(ret, 0);
403
404 ret = instance_->IpfwdAddInterfaceForward(eth0, eth0);
405 EXPECT_NE(ret, 0);
406 ret = instance_->IpfwdRemoveInterfaceForward(eth0, eth0);
407 EXPECT_NE(ret, 0);
408 instance_->OnNetManagerRestart();
409 }
410
411 HWTEST_F(NetsysNativeServiceTest, NetsysNativeServiceTest001, TestSize.Level1)
412 {
413 std::string fromIface = "";
414 std::string toIface = "";
415
416 int32_t ret = instance_->IpfwdRemoveInterfaceForward(fromIface, toIface);
417 EXPECT_NE(ret, 0);
418
419 ret = instance_->BandwidthEnableDataSaver(true);
420 EXPECT_EQ(ret, 0);
421
422 ret = instance_->BandwidthSetIfaceQuota("testifname", 32);
423 EXPECT_EQ(ret, 0);
424
425 ret = instance_->BandwidthRemoveIfaceQuota("testifname");
426 EXPECT_EQ(ret, 0);
427
428 uint32_t uid = 1001;
429 ret = instance_->BandwidthAddDeniedList(uid);
430 EXPECT_EQ(ret, 0);
431
432 ret = instance_->BandwidthRemoveDeniedList(uid);
433 EXPECT_EQ(ret, 0);
434
435 ret = instance_->BandwidthAddAllowedList(uid);
436 EXPECT_EQ(ret, 0);
437
438 ret = instance_->BandwidthRemoveAllowedList(uid);
439 EXPECT_EQ(ret, 0);
440
441 uint32_t chain = 0;
442 std::vector<uint32_t> uids = {1001};
443 ret = instance_->FirewallSetUidsAllowedListChain(chain, uids);
444 EXPECT_NE(ret, 0);
445
446 ret = instance_->FirewallSetUidsDeniedListChain(chain, uids);
447 EXPECT_NE(ret, 0);
448
449 ret = instance_->FirewallEnableChain(chain, false);
450 EXPECT_NE(ret, 0);
451
452 uint32_t firewallRule = 0;
453 ret = instance_->FirewallSetUidRule(chain, {uid}, firewallRule);
454 EXPECT_NE(ret, 0);
455
456 uint16_t netid = 1000;
457 ret = instance_->ShareDnsSet(netid);
458 EXPECT_EQ(ret, 0);
459
460 ret = instance_->StartDnsProxyListen();
461 EXPECT_EQ(ret, 0);
462
463 ret = instance_->StopDnsProxyListen();
464 EXPECT_EQ(ret, 0);
465 }
466
467 HWTEST_F(NetsysNativeServiceTest, NetsysNativeServiceTest002, TestSize.Level1)
468 {
469 const std::string downIface = "testdownIface";
470 const std::string upIface = "testupIface";
471 NetworkSharingTraffic traffic;
472 int ret = instance_->GetNetworkSharingTraffic(downIface, upIface, traffic);
473 EXPECT_NE(ret, 0);
474 }
475
476 HWTEST_F(NetsysNativeServiceTest, NetsysNativeServiceState001, TestSize.Level1)
477 {
478 const std::string iface = "wlan0";
479 const uint32_t appID = 303030;
480
481 uint64_t stats = 0;
482 int ret = instance_->GetTotalStats(stats, 0);
483 EXPECT_EQ(ret, 0);
484
485 ret = instance_->GetUidStats(stats, 0, appID);
486 EXPECT_NE(ret, 0);
487
488 ret = instance_->GetIfaceStats(stats, 0, iface);
489 EXPECT_EQ(ret, 0);
490
491 std::vector<OHOS::NetManagerStandard::NetStatsInfo> statsInfo;
492 ret = instance_->GetAllStatsInfo(statsInfo);
493 EXPECT_EQ(ret, 0);
494 }
495
496 HWTEST_F(NetsysNativeServiceTest, GetAddrInfoTest001, TestSize.Level1)
497 {
498 std::string hostName;
499 std::string serverName;
500 AddrInfo hints;
501 uint16_t netId = 1031;
502 std::vector<AddrInfo> res;
503 instance_->netsysService_->dnsManager_->dnsGetAddrInfo_ = std::make_shared<DnsGetAddrInfo>();
504 int32_t ret = instance_->GetAddrInfo(hostName, serverName, hints, netId, res);
505 DTEST_LOG << ret << std::endl;
506 EXPECT_EQ(ret, EAI_NONAME);
507 }
508
509 HWTEST_F(NetsysNativeServiceTest, SetInternetPermissionTest001, TestSize.Level1)
510 {
511 uint32_t uid = 0;
512 uint8_t allow = 1;
513 int32_t ret = instance_->SetInternetPermission(uid, allow);
514 EXPECT_EQ(ret, NETMANAGER_ERROR);
515 }
516
517 HWTEST_F(NetsysNativeServiceTest, ShareDnsSetTest001, TestSize.Level1)
518 {
519 uint16_t netid = 10034;
520 auto backup = std::move(instance_->netsysService_);
521 instance_->netsysService_ = nullptr;
522 auto ret = instance_->ShareDnsSet(netid);
523 instance_->netsysService_ = std::move(backup);
524 EXPECT_EQ(ret, NETMANAGER_ERROR);
525 }
526
527 HWTEST_F(NetsysNativeServiceTest, StartDnsProxyListenTest001, TestSize.Level1)
528 {
529 auto backup = std::move(instance_->netsysService_);
530 instance_->netsysService_ = nullptr;
531 auto ret = instance_->StartDnsProxyListen();
532 instance_->netsysService_ = std::move(backup);
533 EXPECT_EQ(ret, NETMANAGER_ERROR);
534 }
535
536 HWTEST_F(NetsysNativeServiceTest, StopDnsProxyListenTest001, TestSize.Level1)
537 {
538 auto backup = std::move(instance_->netsysService_);
539 instance_->netsysService_ = nullptr;
540 auto ret = instance_->StopDnsProxyListen();
541 instance_->netsysService_ = std::move(backup);
542 EXPECT_EQ(ret, NETMANAGER_ERROR);
543 }
544
545 HWTEST_F(NetsysNativeServiceTest, GetNetworkSharingTrafficTest001, TestSize.Level1)
546 {
547 std::string downIface = "dface";
548 std::string upIface = "uface";
549 NetworkSharingTraffic traffic;
550 auto backup = std::move(instance_->sharingManager_);
551 instance_->sharingManager_ = nullptr;
552 auto ret = instance_->GetNetworkSharingTraffic(downIface, upIface, traffic);
553 instance_->sharingManager_ = std::move(backup);
554 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
555 }
556
557 HWTEST_F(NetsysNativeServiceTest, OnAddRemoveSystemAbilityTest001, TestSize.Level1)
558 {
559 instance_->hasSARemoved_ = false;
560 instance_->OnAddSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, {});
561 ASSERT_TRUE(instance_->hasSARemoved_);
562 instance_->OnAddSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, {});
563 ASSERT_TRUE(instance_->hasSARemoved_);
564 instance_->hasSARemoved_ = false;
565 instance_->OnAddSystemAbility(-1, {});
566 ASSERT_FALSE(instance_->hasSARemoved_);
567 }
568
569 HWTEST_F(NetsysNativeServiceTest, GetTotalStatsTest001, TestSize.Level1)
570 {
571 uint64_t stats = 0;
572 uint32_t type = 1;
573 auto ret = instance_->GetTotalStats(stats, type);
574 EXPECT_EQ(ret, NetManagerStandard::NETSYS_SUCCESS);
575 auto backup = std::move(instance_->bpfStats_);
576 ret = instance_->GetTotalStats(stats, type);
577 instance_->bpfStats_ = std::move(backup);
578 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
579 }
580
581 HWTEST_F(NetsysNativeServiceTest, GetUidStatsTest001, TestSize.Level1)
582 {
583 uint64_t stats = 5;
584 uint32_t uid = 99;
585 uint32_t type = 1;
586 auto ret = instance_->GetUidStats(stats, uid, type);
587 EXPECT_EQ(stats, 0);
588 auto backup = std::move(instance_->bpfStats_);
589 ret = instance_->GetUidStats(stats, uid, type);
590 instance_->bpfStats_ = std::move(backup);
591 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
592 }
593
594 HWTEST_F(NetsysNativeServiceTest, GetIfaceStatsTest002, TestSize.Level1)
595 {
596 uint64_t stats = 0;
597 uint32_t type = 1;
598 const std::string &iface = "eth0";
599 auto ret = instance_->GetIfaceStats(stats, type, iface);
600 EXPECT_EQ(stats, 0);
601 auto backup = std::move(instance_->bpfStats_);
602 ret = instance_->GetIfaceStats(stats, type, iface);
603 instance_->bpfStats_ = std::move(backup);
604 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
605 }
606
607 HWTEST_F(NetsysNativeServiceTest, GetAllStatsInfoTest001, TestSize.Level1)
608 {
609 std::vector<OHOS::NetManagerStandard::NetStatsInfo> stats;
610 auto ret = instance_->GetAllStatsInfo(stats);
611 EXPECT_GE(stats.size(), 0);
612 auto backup = std::move(instance_->bpfStats_);
613 ret = instance_->GetAllStatsInfo(stats);
614 instance_->bpfStats_ = std::move(backup);
615 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
616 }
617
618 HWTEST_F(NetsysNativeServiceTest, SetIptablesCommandForResTest001, TestSize.Level1)
619 {
620 std::string iptableCmd = "-Sabbbb";
621 std::string iptableOutput = "";
622 auto ret = instance_->SetIptablesCommandForRes(iptableCmd, iptableOutput);
623 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
624 }
625
626 HWTEST_F(NetsysNativeServiceTest, SetIptablesCommandForResTest002, TestSize.Level1)
627 {
628 std::string iptableCmd = "Sabbbb";
629 std::string iptableOutput = "";
630 auto ret = instance_->SetIptablesCommandForRes(iptableCmd, iptableOutput);
631 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INVALID_PARAMETER);
632 }
633
634 HWTEST_F(NetsysNativeServiceTest, SetIptablesCommandForResTest003, TestSize.Level1)
635 {
636 instance_->notifyCallback_ = nullptr;
637 instance_->OnNetManagerRestart();
638 instance_->manager_ = nullptr;
639 instance_->OnNetManagerRestart();
640 instance_->netsysService_ = nullptr;
641 instance_->OnNetManagerRestart();
642 std::string iptableCmd = "-Sabbbb";
643 std::string iptableOutput = "";
644 auto backup = std::move(instance_->iptablesWrapper_);
645 auto ret = instance_->SetIptablesCommandForRes(iptableCmd, iptableOutput);
646 instance_->iptablesWrapper_ = std::move(backup);
647 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
648 }
649 } // namespace NetsysNative
650 } // namespace OHOS
651