1 /*
2 * Copyright (c) 2022-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 <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 "common_notify_callback_test.h"
30 #include "dns_config_client.h"
31 #include "net_stats_constants.h"
32 #include "netsys_native_service.h"
33
34 namespace OHOS {
35 namespace NetsysNative {
36 namespace {
37 using namespace NetManagerStandard;
38 using namespace testing::ext;
39 static constexpr uint32_t TEST_UID = 1;
40 static constexpr uint64_t TEST_COOKIE = 1;
41 static constexpr uint32_t TEST_STATS_TYPE1 = 0;
42 #define DTEST_LOG std::cout << __func__ << ":" << __LINE__ << ":"
43 } // namespace
44
45 class NetsysNativeServiceTest : public testing::Test {
46 public:
47 static void SetUpTestCase();
48 static void TearDownTestCase();
49 void SetUp();
50 void TearDown();
51 static inline auto instance_ = std::make_shared<NetsysNativeService>(COMM_NETSYS_NATIVE_SYS_ABILITY_ID);
52 };
53
SetUpTestCase()54 void NetsysNativeServiceTest::SetUpTestCase() {}
55
TearDownTestCase()56 void NetsysNativeServiceTest::TearDownTestCase() {}
57
SetUp()58 void NetsysNativeServiceTest::SetUp() {}
59
TearDown()60 void NetsysNativeServiceTest::TearDown() {}
61
62 HWTEST_F(NetsysNativeServiceTest, DumpTest001, TestSize.Level1)
63 {
64 NetsysNativeService service;
65 service.state_ = NetsysNativeService::ServiceRunningState::STATE_RUNNING;
66 service.OnStart();
67 instance_->Init();
68 int32_t testFd = 11;
69 int32_t ret = instance_->Dump(testFd, {});
70 EXPECT_LE(ret, NETMANAGER_SUCCESS);
71 }
72
73 HWTEST_F(NetsysNativeServiceTest, SetResolverConfigTest001, TestSize.Level1)
74 {
75 uint16_t testNetId = 154;
76 uint16_t baseTimeoutMsec = 200;
77 uint8_t retryCount = 3;
78 int32_t ret = instance_->SetResolverConfig(testNetId, baseTimeoutMsec, retryCount, {}, {});
79 EXPECT_EQ(ret, 0);
80 }
81
82 HWTEST_F(NetsysNativeServiceTest, GetResolverConfigTest001, TestSize.Level1)
83 {
84 uint16_t testNetId = 154;
85 uint16_t baseTimeoutMsec = 200;
86 uint8_t retryCount = 3;
87 std::vector<std::string> servers;
88 std::vector<std::string> domains;
89 int32_t ret = instance_->GetResolverConfig(testNetId, servers, domains, baseTimeoutMsec, retryCount);
90 EXPECT_EQ(ret, 0);
91 }
92
93 HWTEST_F(NetsysNativeServiceTest, CreateNetworkCacheTest001, TestSize.Level1)
94 {
95 uint16_t testNetId = 154;
96 int32_t ret = instance_->CreateNetworkCache(testNetId);
97 EXPECT_EQ(ret, 0);
98 }
99
100 HWTEST_F(NetsysNativeServiceTest, DestroyNetworkCacheTest001, TestSize.Level1)
101 {
102 uint16_t testNetId = 154;
103 int32_t ret = instance_->DestroyNetworkCache(testNetId);
104 EXPECT_LE(ret, NETMANAGER_SUCCESS);
105 }
106
107 HWTEST_F(NetsysNativeServiceTest, NetworkAddRouteTest001, TestSize.Level1)
108 {
109 uint16_t testNetId = 154;
110 std::string interfaceName = "eth1";
111 std::string destination = "";
112 std::string nextHop = "";
113 int32_t ret = instance_->NetworkAddRoute(testNetId, interfaceName, destination, nextHop);
114 EXPECT_LE(ret, NETMANAGER_SUCCESS);
115 }
116
117 HWTEST_F(NetsysNativeServiceTest, NetworkAddRouteParcelTest001, TestSize.Level1)
118 {
119 uint16_t testNetId = 154;
120 RouteInfoParcel routeInfo;
121 int32_t ret = instance_->NetworkAddRouteParcel(testNetId, routeInfo);
122 EXPECT_LE(ret, NETMANAGER_SUCCESS);
123 }
124
125 HWTEST_F(NetsysNativeServiceTest, NetworkRemoveRouteParcelTest001, TestSize.Level1)
126 {
127 uint16_t testNetId = 154;
128 RouteInfoParcel routeInfo;
129 int32_t ret = instance_->NetworkRemoveRouteParcel(testNetId, routeInfo);
130 EXPECT_LE(ret, NETMANAGER_SUCCESS);
131 }
132
133 HWTEST_F(NetsysNativeServiceTest, NetworkSetDefaultTest001, TestSize.Level1)
134 {
135 uint16_t testNetId = 154;
136 int32_t ret = instance_->NetworkSetDefault(testNetId);
137 EXPECT_GE(ret, NETMANAGER_SUCCESS);
138 }
139
140 HWTEST_F(NetsysNativeServiceTest, NetworkGetDefaultTest001, TestSize.Level1)
141 {
142 int32_t ret = instance_->NetworkGetDefault();
143 EXPECT_LE(ret, 154);
144 }
145
146 HWTEST_F(NetsysNativeServiceTest, NetworkClearDefaultTest001, TestSize.Level1)
147 {
148 int32_t ret = instance_->NetworkClearDefault();
149 EXPECT_LE(ret, NETMANAGER_SUCCESS);
150 }
151
152 HWTEST_F(NetsysNativeServiceTest, GetProcSysNetTest001, TestSize.Level1)
153 {
154 int32_t ipversion = 45;
155 int32_t which = 14;
156 std::string ifname = "testifname";
157 std::string paramete = "testparamete";
158 std::string value = "testvalue";
159 int32_t ret = instance_->GetProcSysNet(ipversion, which, ifname, paramete, value);
160 EXPECT_LE(ret, NETMANAGER_SUCCESS);
161 }
162
163 HWTEST_F(NetsysNativeServiceTest, SetProcSysNetTest001, TestSize.Level1)
164 {
165 int32_t ipversion = 45;
166 int32_t which = 14;
167 std::string ifname = "testifname";
168 std::string paramete = "testparamete";
169 std::string value = "testvalue";
170 int32_t ret = instance_->SetProcSysNet(ipversion, which, ifname, paramete, value);
171 EXPECT_LE(ret, NETMANAGER_SUCCESS);
172 }
173
174 HWTEST_F(NetsysNativeServiceTest, SetInterfaceMtu001, TestSize.Level1)
175 {
176 std::string testName = "test0";
177 int32_t mtu = 1500;
178 int32_t ret = instance_->SetInterfaceMtu(testName, mtu);
179 EXPECT_NE(ret, 0);
180 std::string eth0Name = "eth0";
181 auto ifaceList = NetsysController::GetInstance().InterfaceGetList();
182 bool eth0NotExist = std::find(ifaceList.begin(), ifaceList.end(), eth0Name) == ifaceList.end();
183 if (eth0NotExist) {
184 return;
185 }
186 ret = instance_->SetInterfaceMtu(eth0Name, mtu);
187 EXPECT_EQ(ret, 0);
188 }
189
190 HWTEST_F(NetsysNativeServiceTest, SetTcpBufferSizes001, TestSize.Level1)
191 {
192 std::string tcpBufferSizes = "524288,1048576,2097152,262144,524288,1048576";
193 int32_t ret = instance_->SetTcpBufferSizes(tcpBufferSizes);
194 EXPECT_EQ(ret, 0);
195 }
196
197 HWTEST_F(NetsysNativeServiceTest, GetInterfaceMtu001, TestSize.Level1)
198 {
199 std::string testName = "test0";
200 int32_t ret = instance_->GetInterfaceMtu(testName);
201 EXPECT_NE(ret, 0);
202 std::string eth0Name = "eth0";
203 ret = instance_->GetInterfaceMtu(eth0Name);
204 EXPECT_NE(ret, 0);
205 }
206
207 HWTEST_F(NetsysNativeServiceTest, RegisterNotifyCallback001, TestSize.Level1)
208 {
209 sptr<INotifyCallback> callback = new (std::nothrow) NotifyCallbackTest();
210 int32_t ret = instance_->RegisterNotifyCallback(callback);
211 EXPECT_EQ(ret, 0);
212
213 ret = instance_->UnRegisterNotifyCallback(callback);
214 EXPECT_EQ(ret, 0);
215 }
216
217 HWTEST_F(NetsysNativeServiceTest, NetworkRemoveRouteTest001, TestSize.Level1)
218 {
219 uint16_t testNetId = 154;
220 std::string interfaceName = "eth1";
221 std::string destination = "";
222 std::string nextHop = "";
223 int32_t ret = instance_->NetworkRemoveRoute(testNetId, interfaceName, destination, nextHop);
224 EXPECT_NE(ret, 0);
225 }
226
227 HWTEST_F(NetsysNativeServiceTest, NetworkCreatePhysicalTest001, TestSize.Level1)
228 {
229 int32_t netId = 1000;
230 int32_t permission = 0;
231 int32_t ret = instance_->NetworkCreatePhysical(netId, permission);
232 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
233 }
234
235 HWTEST_F(NetsysNativeServiceTest, AddInterfaceAddressTest001, TestSize.Level1)
236 {
237 std::string iFName = "test0";
238 std::string addrStr = "192.168.22.33";
239 int32_t prefixLength = 24;
240 int32_t ret = instance_->AddInterfaceAddress(iFName, addrStr, prefixLength);
241 EXPECT_NE(ret, NETMANAGER_SUCCESS);
242 }
243
244 HWTEST_F(NetsysNativeServiceTest, DelInterfaceAddressTest001, TestSize.Level1)
245 {
246 std::string iFName = "test0";
247 std::string addrStr = "192.168.22.33";
248 int32_t prefixLength = 24;
249 int32_t ret = instance_->DelInterfaceAddress(iFName, addrStr, prefixLength);
250 EXPECT_NE(ret, NETMANAGER_SUCCESS);
251 }
252
253 HWTEST_F(NetsysNativeServiceTest, InterfaceSetIpAddressTest001, TestSize.Level1)
254 {
255 std::string iFName = "test0";
256 std::string addrStr = "192.168.22.33";
257 int32_t ret = instance_->InterfaceSetIpAddress(iFName, addrStr);
258 EXPECT_NE(ret, NETMANAGER_SUCCESS);
259 }
260
261 HWTEST_F(NetsysNativeServiceTest, InterfaceSetIffUpTest001, TestSize.Level1)
262 {
263 std::string iFName = "test0";
264 int32_t ret = instance_->InterfaceSetIffUp(iFName);
265 EXPECT_NE(ret, NETMANAGER_SUCCESS);
266 }
267
268 HWTEST_F(NetsysNativeServiceTest, NetworkAddInterfaceTest001, TestSize.Level1)
269 {
270 int32_t netId = 1000;
271 std::string iFName = "test0";
272 int32_t ret = instance_->NetworkAddInterface(netId, iFName, BEARER_DEFAULT);
273 EXPECT_NE(ret, NETMANAGER_SUCCESS);
274 }
275
276 HWTEST_F(NetsysNativeServiceTest, NetworkRemoveInterfaceTest001, TestSize.Level1)
277 {
278 int32_t netId = 1000;
279 std::string iFName = "test0";
280 int32_t ret = instance_->NetworkRemoveInterface(netId, iFName);
281 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
282 }
283
284 HWTEST_F(NetsysNativeServiceTest, NetworkDestroyTest001, TestSize.Level1)
285 {
286 int32_t netId = 1000;
287 int32_t ret = instance_->NetworkDestroy(netId);
288 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
289 }
290
291 HWTEST_F(NetsysNativeServiceTest, GetFwmarkForNetworkTest001, TestSize.Level1)
292 {
293 int32_t netId = 1000;
294 MarkMaskParcel markMaskParcel;
295 int32_t ret = instance_->GetFwmarkForNetwork(netId, markMaskParcel);
296 EXPECT_EQ(ret, ERR_NONE);
297 }
298
299 HWTEST_F(NetsysNativeServiceTest, SetInterfaceConfigTest001, TestSize.Level1)
300 {
301 InterfaceConfigurationParcel cfg;
302 cfg.ifName = "test0";
303 cfg.hwAddr = "0b:2c:43:d7:22:1s";
304 cfg.ipv4Addr = "192.168.133.12";
305 cfg.prefixLength = 24;
306 cfg.flags.push_back("up");
307 int32_t ret = instance_->SetInterfaceConfig(cfg);
308 EXPECT_EQ(ret, ERR_NONE);
309 }
310
311 HWTEST_F(NetsysNativeServiceTest, GetInterfaceConfigTest001, TestSize.Level1)
312 {
313 InterfaceConfigurationParcel cfg;
314 cfg.ifName = "eth0";
315 int32_t ret = instance_->GetInterfaceConfig(cfg);
316 EXPECT_EQ(ret, ERR_NONE);
317 }
318
319 HWTEST_F(NetsysNativeServiceTest, InterfaceGetListTest001, TestSize.Level1)
320 {
321 std::vector<std::string> ifaces;
322 int32_t ret = instance_->InterfaceGetList(ifaces);
323 EXPECT_EQ(ret, ERR_NONE);
324 }
325
326 HWTEST_F(NetsysNativeServiceTest, StartDhcpClientTest001, TestSize.Level1)
327 {
328 std::string iface = "test0";
329 bool bIpv6 = false;
330 int32_t ret = instance_->StartDhcpClient(iface, bIpv6);
331 EXPECT_EQ(ret, ERR_NONE);
332
333 ret = instance_->StopDhcpClient(iface, bIpv6);
334 EXPECT_EQ(ret, ERR_NONE);
335 }
336
337 HWTEST_F(NetsysNativeServiceTest, StartDhcpServiceTest001, TestSize.Level1)
338 {
339 std::string iface = "test0";
340 std::string ipv4addr = "192.168.133.12";
341 int32_t ret = instance_->StartDhcpService(iface, ipv4addr);
342 EXPECT_EQ(ret, ERR_NONE);
343
344 ret = instance_->StopDhcpService(iface);
345 EXPECT_EQ(ret, ERR_NONE);
346 }
347
348 HWTEST_F(NetsysNativeServiceTest, IpEnableForwardingTest001, TestSize.Level1)
349 {
350 std::string iface = "";
351 std::string eth0 = "eth0";
352 int32_t ret = instance_->IpEnableForwarding(iface);
353 EXPECT_EQ(ret, 0);
354 ret = instance_->IpDisableForwarding(iface);
355 EXPECT_EQ(ret, 0);
356
357 ret = instance_->EnableNat(eth0, eth0);
358 EXPECT_NE(ret, 0);
359 ret = instance_->DisableNat(eth0, eth0);
360 EXPECT_NE(ret, 0);
361
362 ret = instance_->IpfwdAddInterfaceForward(eth0, eth0);
363 EXPECT_NE(ret, 0);
364 ret = instance_->IpfwdRemoveInterfaceForward(eth0, eth0);
365 EXPECT_NE(ret, 0);
366 instance_->OnNetManagerRestart();
367 }
368
369 HWTEST_F(NetsysNativeServiceTest, NetsysNativeServiceTest001, TestSize.Level1)
370 {
371 std::string fromIface = "";
372 std::string toIface = "";
373
374 int32_t ret = instance_->IpfwdRemoveInterfaceForward(fromIface, toIface);
375 EXPECT_NE(ret, 0);
376
377 ret = instance_->BandwidthEnableDataSaver(true);
378 EXPECT_EQ(ret, 0);
379
380 ret = instance_->BandwidthSetIfaceQuota("testifname", 32);
381 EXPECT_EQ(ret, 0);
382
383 ret = instance_->BandwidthRemoveIfaceQuota("testifname");
384 EXPECT_EQ(ret, 0);
385
386 uint32_t uid = 1001;
387 ret = instance_->BandwidthAddDeniedList(uid);
388 EXPECT_EQ(ret, 0);
389
390 ret = instance_->BandwidthRemoveDeniedList(uid);
391 EXPECT_EQ(ret, 0);
392
393 ret = instance_->BandwidthAddAllowedList(uid);
394 EXPECT_EQ(ret, 0);
395
396 ret = instance_->BandwidthRemoveAllowedList(uid);
397 EXPECT_EQ(ret, 0);
398
399 uint32_t chain = 0;
400 std::vector<uint32_t> uids = {1001};
401 ret = instance_->FirewallSetUidsAllowedListChain(chain, uids);
402 EXPECT_NE(ret, 0);
403
404 ret = instance_->FirewallSetUidsDeniedListChain(chain, uids);
405 EXPECT_NE(ret, 0);
406
407 ret = instance_->FirewallEnableChain(chain, false);
408 EXPECT_NE(ret, 0);
409
410 uint32_t firewallRule = 0;
411 ret = instance_->FirewallSetUidRule(chain, {uid}, firewallRule);
412 EXPECT_NE(ret, 0);
413
414 uint16_t netid = 1000;
415 ret = instance_->ShareDnsSet(netid);
416 EXPECT_EQ(ret, 0);
417
418 ret = instance_->StartDnsProxyListen();
419 EXPECT_EQ(ret, 0);
420
421 ret = instance_->StopDnsProxyListen();
422 EXPECT_EQ(ret, 0);
423 }
424
425 HWTEST_F(NetsysNativeServiceTest, NetsysNativeServiceTest002, TestSize.Level1)
426 {
427 const std::string downIface = "testdownIface";
428 const std::string upIface = "testupIface";
429 NetworkSharingTraffic traffic;
430 int ret = instance_->GetNetworkSharingTraffic(downIface, upIface, traffic);
431 EXPECT_NE(ret, 0);
432 }
433
434 HWTEST_F(NetsysNativeServiceTest, NetsysNativeServiceState001, TestSize.Level1)
435 {
436 const std::string iface = "wlan0";
437 const uint32_t appID = 303030;
438
439 uint64_t stats = 0;
440 int ret = instance_->GetTotalStats(stats, 0);
441 EXPECT_EQ(ret, 0);
442
443 ret = instance_->GetUidStats(stats, 0, appID);
444 EXPECT_NE(ret, 0);
445
446 ret = instance_->GetIfaceStats(stats, 5, iface);
447 EXPECT_EQ(ret, NetStatsResultCode::STATS_ERR_READ_BPF_FAIL);
448
449 std::vector<OHOS::NetManagerStandard::NetStatsInfo> statsInfo;
450 ret = instance_->GetAllStatsInfo(statsInfo);
451 EXPECT_EQ(ret, 0);
452 }
453
454 HWTEST_F(NetsysNativeServiceTest, GetAddrInfoTest001, TestSize.Level1)
455 {
456 std::string hostName;
457 std::string serverName;
458 AddrInfo hints;
459 uint16_t netId = 1031;
460 std::vector<AddrInfo> res;
461 int32_t ret = instance_->GetAddrInfo(hostName, serverName, hints, netId, res);
462 DTEST_LOG << ret << std::endl;
463 EXPECT_EQ(ret, NETMANAGER_ERROR);
464 }
465
466 HWTEST_F(NetsysNativeServiceTest, SetInternetPermissionTest001, TestSize.Level1)
467 {
468 uint32_t uid = 0;
469 uint8_t allow = 1;
470 uint8_t isBroker = 0;
471 int32_t ret = instance_->SetInternetPermission(uid, allow, isBroker);
472 EXPECT_EQ(ret, NETMANAGER_ERROR);
473 }
474
475 HWTEST_F(NetsysNativeServiceTest, ShareDnsSetTest001, TestSize.Level1)
476 {
477 uint16_t netid = 10034;
478 auto backup = std::move(instance_->netsysService_);
479 instance_->netsysService_ = nullptr;
480 auto ret = instance_->ShareDnsSet(netid);
481 instance_->netsysService_ = std::move(backup);
482 EXPECT_EQ(ret, NETMANAGER_ERROR);
483 }
484
485 HWTEST_F(NetsysNativeServiceTest, StartDnsProxyListenTest001, TestSize.Level1)
486 {
487 auto backup = std::move(instance_->netsysService_);
488 instance_->netsysService_ = nullptr;
489 auto ret = instance_->StartDnsProxyListen();
490 instance_->netsysService_ = std::move(backup);
491 EXPECT_EQ(ret, NETMANAGER_ERROR);
492 }
493
494 HWTEST_F(NetsysNativeServiceTest, StopDnsProxyListenTest001, TestSize.Level1)
495 {
496 auto backup = std::move(instance_->netsysService_);
497 instance_->netsysService_ = nullptr;
498 auto ret = instance_->StopDnsProxyListen();
499 instance_->netsysService_ = std::move(backup);
500 EXPECT_EQ(ret, NETMANAGER_ERROR);
501 }
502
503 HWTEST_F(NetsysNativeServiceTest, GetNetworkSharingTrafficTest001, TestSize.Level1)
504 {
505 std::string downIface = "dface";
506 std::string upIface = "uface";
507 NetworkSharingTraffic traffic;
508 auto backup = std::move(instance_->sharingManager_);
509 instance_->sharingManager_ = nullptr;
510 auto ret = instance_->GetNetworkSharingTraffic(downIface, upIface, traffic);
511 instance_->sharingManager_ = std::move(backup);
512 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
513 }
514
515 HWTEST_F(NetsysNativeServiceTest, OnAddRemoveSystemAbilityTest001, TestSize.Level1)
516 {
517 instance_->hasSARemoved_ = false;
518 instance_->OnAddSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, {});
519 ASSERT_TRUE(instance_->hasSARemoved_);
520 instance_->OnAddSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, {});
521 ASSERT_TRUE(instance_->hasSARemoved_);
522 instance_->hasSARemoved_ = false;
523 instance_->OnAddSystemAbility(-1, {});
524 ASSERT_FALSE(instance_->hasSARemoved_);
525 }
526
527 HWTEST_F(NetsysNativeServiceTest, GetTotalStatsTest001, TestSize.Level1)
528 {
529 uint64_t stats = 0;
530 uint32_t type = 1;
531 auto ret = instance_->GetTotalStats(stats, type);
532 EXPECT_EQ(ret, NetManagerStandard::NETSYS_SUCCESS);
533 auto backup = std::move(instance_->bpfStats_);
534 ret = instance_->GetTotalStats(stats, type);
535 instance_->bpfStats_ = std::move(backup);
536 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
537 }
538
539 HWTEST_F(NetsysNativeServiceTest, GetUidStatsTest001, TestSize.Level1)
540 {
541 uint64_t stats = 5;
542 uint32_t uid = 99;
543 uint32_t type = 1;
544 auto ret = instance_->GetUidStats(stats, uid, type);
545 EXPECT_EQ(stats, 0);
546 auto backup = std::move(instance_->bpfStats_);
547 ret = instance_->GetUidStats(stats, uid, type);
548 instance_->bpfStats_ = std::move(backup);
549 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
550 }
551
552 HWTEST_F(NetsysNativeServiceTest, GetIfaceStatsTest002, TestSize.Level1)
553 {
554 uint64_t stats = 0;
555 uint32_t type = 1;
556 const std::string &iface = "eth0";
557 auto ret = instance_->GetIfaceStats(stats, type, iface);
558 EXPECT_EQ(stats, 0);
559 auto backup = std::move(instance_->bpfStats_);
560 ret = instance_->GetIfaceStats(stats, type, iface);
561 instance_->bpfStats_ = std::move(backup);
562 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
563 }
564
565 HWTEST_F(NetsysNativeServiceTest, GetAllStatsInfoTest001, TestSize.Level1)
566 {
567 std::vector<OHOS::NetManagerStandard::NetStatsInfo> stats;
568 auto ret = instance_->GetAllStatsInfo(stats);
569 EXPECT_GE(stats.size(), 0);
570 auto backup = std::move(instance_->bpfStats_);
571 ret = instance_->GetAllStatsInfo(stats);
572 instance_->bpfStats_ = std::move(backup);
573 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
574 }
575
576 HWTEST_F(NetsysNativeServiceTest, DeleteStatsInfo001, TestSize.Level1)
577 {
578 int32_t ret = instance_->DeleteStatsInfo(TEST_UID);
579 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
580 }
581
582 HWTEST_F(NetsysNativeServiceTest, GetAllSimStatsInfo001, TestSize.Level1)
583 {
584 std::vector<OHOS::NetManagerStandard::NetStatsInfo> stats;
585 int32_t ret = instance_->GetAllSimStatsInfo(stats);
586 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
587 }
588
589 HWTEST_F(NetsysNativeServiceTest, DeleteSimStatsInfo001, TestSize.Level1)
590 {
591 int32_t ret = instance_->DeleteSimStatsInfo(TEST_UID);
592 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
593 }
594
595 HWTEST_F(NetsysNativeServiceTest, SetIptablesCommandForResTest001, TestSize.Level1)
596 {
597 std::string iptableCmd = "-Sabbbb";
598 std::string iptableOutput = "";
599 IptablesType ipType = IptablesType::IPTYPE_IPV4;
600 auto ret = instance_->SetIptablesCommandForRes(iptableCmd, iptableOutput, ipType);
601 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
602 }
603
604 HWTEST_F(NetsysNativeServiceTest, SetIptablesCommandForResTest002, TestSize.Level1)
605 {
606 std::string iptableCmd = "Sabbbb";
607 std::string iptableOutput = "";
608 IptablesType ipType = IptablesType::IPTYPE_IPV4;
609 auto ret = instance_->SetIptablesCommandForRes(iptableCmd, iptableOutput, ipType);
610 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INVALID_PARAMETER);
611 }
612
613 HWTEST_F(NetsysNativeServiceTest, SetIptablesCommandForResTest003, TestSize.Level1)
614 {
615 instance_->notifyCallback_ = nullptr;
616 instance_->OnNetManagerRestart();
617 instance_->manager_ = nullptr;
618 instance_->OnNetManagerRestart();
619 instance_->netsysService_ = nullptr;
620 instance_->OnNetManagerRestart();
621 std::string iptableCmd = "-Sabbbb";
622 std::string iptableOutput = "";
623 IptablesType ipType = IptablesType::IPTYPE_IPV4;
624 auto backup = std::move(instance_->iptablesWrapper_);
625 auto ret = instance_->SetIptablesCommandForRes(iptableCmd, iptableOutput, ipType);
626 instance_->iptablesWrapper_ = std::move(backup);
627 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
628 }
629
630 HWTEST_F(NetsysNativeServiceTest, StaticArpTest001, TestSize.Level1)
631 {
632 std::string ipAddr = "192.168.1.100";
633 std::string macAddr = "aa:bb:cc:dd:ee:ff";
634 std::string ifName = "wlan0";
635 if (instance_->netsysService_ == nullptr) {
636 instance_->Init();
637 return;
638 }
639 int32_t ret = instance_->AddStaticArp(ipAddr, macAddr, ifName);
640 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
641
642 ret = instance_->DelStaticArp(ipAddr, macAddr, ifName);
643 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
644 }
645
646 HWTEST_F(NetsysNativeServiceTest, GetCookieStatsTest001, TestSize.Level1)
647 {
648 uint64_t stats = 0;
649 int32_t ret = instance_->GetCookieStats(stats, TEST_STATS_TYPE1, TEST_COOKIE);
650 EXPECT_NE(ret, NETMANAGER_SUCCESS);
651 }
652
653 HWTEST_F(NetsysNativeServiceTest, GetCookieStatsTest002, TestSize.Level1)
654 {
655 uint64_t stats = 0;
656 auto ret = instance_->GetCookieStats(stats, TEST_STATS_TYPE1, TEST_COOKIE);
657 EXPECT_EQ(stats, 0);
658 auto backup = std::move(instance_->bpfStats_);
659 ret = instance_->GetCookieStats(stats, TEST_STATS_TYPE1, TEST_COOKIE);
660 instance_->bpfStats_ = std::move(backup);
661 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
662 }
663
664 HWTEST_F(NetsysNativeServiceTest, NetsysNativeServiceBranchTest001, TestSize.Level1)
665 {
666 int32_t netId = 0;
667 int32_t ret = instance_->NetworkCreateVirtual(netId, false);
668 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
669
670 int32_t systemAbilityId = 0;
671 std::string deviceId = "";
672 instance_->OnRemoveSystemAbility(systemAbilityId, deviceId);
673 systemAbilityId = COMM_NET_CONN_MANAGER_SYS_ABILITY_ID;
674 instance_->OnRemoveSystemAbility(systemAbilityId, deviceId);
675
676 std::vector<UidRange> uidRanges;
677 ret = instance_->NetworkAddUids(netId, uidRanges);
678 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
679
680 ret = instance_->NetworkDelUids(netId, uidRanges);
681 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
682
683 NetDiagPingOption pingOption;
684 sptr<INetDiagCallback> callback = nullptr;
685 ret = instance_->NetDiagPingHost(pingOption, callback);
686 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INVALID_PARAMETER);
687
688 pingOption.destination_ = "test";
689 ret = instance_->NetDiagPingHost(pingOption, callback);
690 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
691
692 std::list<NetDiagRouteTable> routeTables;
693 ret = instance_->NetDiagGetRouteTable(routeTables);
694 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
695
696 NetDiagProtocolType socketType = NetDiagProtocolType::PROTOCOL_TYPE_ALL;
697 NetDiagSocketsInfo socketsInfo;
698 ret = instance_->NetDiagGetSocketsInfo(socketType, socketsInfo);
699 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
700
701 std::list<NetDiagIfaceConfig> configs;
702 std::string ifaceName = "test";
703 ret = instance_->NetDiagGetInterfaceConfig(configs, ifaceName);
704 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
705
706 NetDiagIfaceConfig ifConfig;
707 ret = instance_->NetDiagUpdateInterfaceConfig(ifConfig, ifaceName, false);
708 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
709
710 ret = instance_->NetDiagSetInterfaceActiveState(ifaceName, false);
711 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
712 }
713
714 HWTEST_F(NetsysNativeServiceTest, NetsysNativeServiceBranchTest002, TestSize.Level1)
715 {
716 NetDiagPingOption pingOption;
717 sptr<INetDiagCallback> callback = nullptr;
718 instance_->netDiagWrapper = nullptr;
719 int32_t ret = instance_->NetDiagPingHost(pingOption, callback);
720 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
721
722 std::list<NetDiagRouteTable> routeTables;
723 ret = instance_->NetDiagGetRouteTable(routeTables);
724 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
725
726 NetDiagProtocolType socketType = NetDiagProtocolType::PROTOCOL_TYPE_ALL;
727 NetDiagSocketsInfo socketsInfo;
728 ret = instance_->NetDiagGetSocketsInfo(socketType, socketsInfo);
729 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
730
731 std::list<NetDiagIfaceConfig> configs;
732 std::string ifaceName = "test";
733 ret = instance_->NetDiagGetInterfaceConfig(configs, ifaceName);
734 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
735
736 NetDiagIfaceConfig ifConfig;
737 ret = instance_->NetDiagUpdateInterfaceConfig(ifConfig, ifaceName, false);
738 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
739
740 ret = instance_->NetDiagSetInterfaceActiveState(ifaceName, false);
741 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
742 }
743
744 HWTEST_F(NetsysNativeServiceTest, NetsysNativeServiceBranchTest003, TestSize.Level1)
745 {
746 sptr<INetDnsResultCallback> dnsResultCallback = nullptr;
747 uint32_t timeStep = 0;
748 int32_t ret = instance_->RegisterDnsResultCallback(dnsResultCallback, timeStep);
749 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
750
751 ret = instance_->UnregisterDnsResultCallback(dnsResultCallback);
752 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
753
754 sptr<INetDnsHealthCallback> healthCallback = nullptr;
755 ret = instance_->RegisterDnsHealthCallback(healthCallback);
756 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
757
758 ret = instance_->UnregisterDnsHealthCallback(healthCallback);
759 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
760 }
761
762 HWTEST_F(NetsysNativeServiceTest, GetNetworkSharingTypeTest001, TestSize.Level1)
763 {
764 uint32_t type = 0;
765 int32_t ret = instance_->UpdateNetworkSharingType(type, true);
766 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
767 std::set<uint32_t> sharingTypeIsOn;
768 ret = instance_->GetNetworkSharingType(sharingTypeIsOn);
769 EXPECT_EQ(sharingTypeIsOn.size(), 1);
770
771 ret = instance_->UpdateNetworkSharingType(type, false);
772 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
773 sharingTypeIsOn.clear();
774 ret = instance_->GetNetworkSharingType(sharingTypeIsOn);
775 EXPECT_EQ(sharingTypeIsOn.size(), 0);
776 }
777
778 HWTEST_F(NetsysNativeServiceTest, UpdateNetworkSharingTypeTest001, TestSize.Level1)
779 {
780 uint32_t type = 0;
781 int32_t ret = instance_->UpdateNetworkSharingType(type, true);
782 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
783
784 ret = instance_->UpdateNetworkSharingType(type, false);
785 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
786 }
787
788 HWTEST_F(NetsysNativeServiceTest, SetIpv6PrivacyExtensionsTest001, TestSize.Level1)
789 {
790 uint32_t on = 0;
791 std::string interface = "wlan0";
792 int32_t ret = instance_->SetIpv6PrivacyExtensions(interface, on);
793 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
794 ret = instance_->SetEnableIpv6(interface, on);
795 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
796 }
797
798 HWTEST_F(NetsysNativeServiceTest, SetNetworkAccessPolicyTest001, TestSize.Level1)
799 {
800 uint32_t uid = 0;
801 NetworkAccessPolicy netAccessPolicy;
802 netAccessPolicy.wifiAllow = false;
803 netAccessPolicy.cellularAllow = false;
804 bool reconfirmFlag = true;
805 bool isBroker = false;
806 int32_t ret = instance_->SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag, isBroker);
807 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
808 }
809
810 HWTEST_F(NetsysNativeServiceTest, DeleteNetworkAccessPolicyTest001, TestSize.Level1)
811 {
812 uint32_t uid = 0;
813 int32_t ret = instance_->DeleteNetworkAccessPolicy(uid);
814 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
815 }
816
817 HWTEST_F(NetsysNativeServiceTest, NotifyNetBearerTypeChangeTest001, TestSize.Level1)
818 {
819 std::set<NetManagerStandard::NetBearType> bearerTypes;
820 bearerTypes.insert(NetManagerStandard::NetBearType::BEARER_CELLULAR);
821 int32_t ret = instance_->NotifyNetBearerTypeChange(bearerTypes);
822 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
823 }
824
825 HWTEST_F(NetsysNativeServiceTest, CreateVnic001, TestSize.Level1)
826 {
827 uint16_t mtu = 1500;
828 std::string tunAddr = "192.168.1.100";
829 int32_t prefix = 24;
830 std::set<int32_t> uids;
831 int32_t ret = instance_->CreateVnic(mtu, tunAddr, prefix, uids);
832 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
833 }
834
835 HWTEST_F(NetsysNativeServiceTest, DestroyVnic001, TestSize.Level1)
836 {
837 int32_t ret = instance_->DestroyVnic();
838 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
839 }
840
841 /**
842 * @tc.name: SetNicTrafficAllowed001
843 * @tc.desc: Test NetsysNativeService SetNicTrafficAllowed.
844 * @tc.type: FUNC
845 */
846 HWTEST_F(NetsysNativeServiceTest, SetNicTrafficAllowed001, TestSize.Level1)
847 {
848 std::vector<std::string> ifaceName = {"wlan0", "aaa"};
849 auto ret = instance_->SetNicTrafficAllowed(ifaceName, false);
850 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
851 }
852
853 /**
854 * @tc.name: SetNicTrafficAllowed002
855 * @tc.desc: Test NetsysNativeService SetNicTrafficAllowed.
856 * @tc.type: FUNC
857 */
858 HWTEST_F(NetsysNativeServiceTest, SetNicTrafficAllowed002, TestSize.Level1)
859 {
860 std::vector<std::string> ifaceName = {"wlan0", "aaa"};
861 auto ret = instance_->SetNicTrafficAllowed(ifaceName, true);
862 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
863 }
864
865 /**
866 * @tc.name: SetNicTrafficAllowed003
867 * @tc.desc: Test NetsysNativeService SetNicTrafficAllowed.
868 * @tc.type: FUNC
869 */
870 HWTEST_F(NetsysNativeServiceTest, SetNicTrafficAllowed003, TestSize.Level1)
871 {
872 std::vector<std::string> ifaceName = {"wlan0"};
873 auto ret = instance_->SetNicTrafficAllowed(ifaceName, false);
874 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
875 }
876
877 /**
878 * @tc.name: SetNicTrafficAllowed004
879 * @tc.desc: Test NetsysNativeService SetNicTrafficAllowed.
880 * @tc.type: FUNC
881 */
882 HWTEST_F(NetsysNativeServiceTest, SetNicTrafficAllowed004, TestSize.Level1)
883 {
884 std::vector<std::string> ifaceName = {"wlan0"};
885 auto ret = instance_->SetNicTrafficAllowed(ifaceName, true);
886 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
887 }
888
889 /**
890 * @tc.name: SetNicTrafficAllowed005
891 * @tc.desc: Test NetsysNativeService SetNicTrafficAllowed.
892 * @tc.type: FUNC
893 */
894 HWTEST_F(NetsysNativeServiceTest, SetNicTrafficAllowed005, TestSize.Level1)
895 {
896 std::vector<std::string> ifaceName = {};
897 auto ret = instance_->SetNicTrafficAllowed(ifaceName, false);
898 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
899 }
900
901 /**
902 * @tc.name: SetNicTrafficAllowed006
903 * @tc.desc: Test NetsysNativeService SetNicTrafficAllowed.
904 * @tc.type: FUNC
905 */
906 HWTEST_F(NetsysNativeServiceTest, SetNicTrafficAllowed006, TestSize.Level1)
907 {
908 std::vector<std::string> ifaceName = {};
909 auto ret = instance_->SetNicTrafficAllowed(ifaceName, true);
910 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
911 }
912 } // namespace NetsysNative
913 } // namespace OHOS
914