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_client.h"
27 #include "net_conn_constants.h"
28 #include "net_manager_constants.h"
29 #include "net_stats_constants.h"
30 #include "netsys_controller.h"
31 #include "netsys_controller_service_impl.h"
32
33 namespace OHOS {
34 namespace NetManagerStandard {
35 namespace {
36 using namespace testing::ext;
37 } // namespace
38 static constexpr uint32_t TEST_UID = 1;
39 static constexpr uint64_t TEST_COOKIE = 1;
40 static constexpr uint32_t TEST_STATS_TYPE1 = 0;
41 static constexpr uint32_t TEST_STATS_TYPE2 = 2;
42
43 class NetsysControllerServiceImplTest : public testing::Test {
44 public:
45 static void SetUpTestCase();
46
47 static void TearDownTestCase();
48
49 void SetUp();
50
51 void TearDown();
52
53 static inline std::shared_ptr<NetsysControllerServiceImpl> instance_ = nullptr;
54
55 private:
56 void AddExtMockApi();
57 };
58
SetUpTestCase()59 void NetsysControllerServiceImplTest::SetUpTestCase()
60 {
61 instance_ = std::make_shared<NetsysControllerServiceImpl>();
62 if (instance_) {
63 instance_->mockNetsysClient_.mockApi_.clear();
64 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKCREATEPHYSICAL_API);
65 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKDESTROY_API);
66 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKADDINTERFACE_API);
67 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKREMOVEINTERFACE_API);
68 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKADDROUTE_API);
69 instance_->mockNetsysClient_.mockApi_.insert(MOCK_NETWORKREMOVEROUTE_API);
70 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETINTERFACEDOWN_API);
71 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETINTERFACEUP_API);
72 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACEGETMTU_API);
73 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACESETMTU_API);
74 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACEADDADDRESS_API);
75 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACEDELADDRESS_API);
76 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETRESOLVERCONFIG_API);
77 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETRESOLVERICONFIG_API);
78 instance_->mockNetsysClient_.mockApi_.insert(MOCK_CREATENETWORKCACHE_API);
79 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETDEFAULTNETWORK_API);
80 instance_->mockNetsysClient_.mockApi_.insert(MOCK_CLEARDEFAULTNETWORK_API);
81 instance_->mockNetsysClient_.mockApi_.insert(MOCK_STARTDHCPCLIENT_API);
82 instance_->mockNetsysClient_.mockApi_.insert(MOCK_STOPDHCPCLIENT_API);
83 instance_->mockNetsysClient_.mockApi_.insert(MOCK_REGISTERNOTIFYCALLBACK_API);
84 instance_->mockNetsysClient_.mockApi_.insert(MOCK_STARTDHCPSERVICE_API);
85 instance_->mockNetsysClient_.mockApi_.insert(MOCK_STOPDHCPSERVICE_API);
86 instance_->mockNetsysClient_.mockApi_.insert(MOCK_CLOSESOCKETSUID_API);
87 }
88 }
89
AddExtMockApi()90 void NetsysControllerServiceImplTest::AddExtMockApi()
91 {
92 if (instance_) {
93 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETCELLULARRXBYTES_API);
94 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETCELLULARTXBYTES_API);
95 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETALLRXBYTES_API);
96 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETALLTXBYTES_API);
97 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETUIDRXBYTES_API);
98 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETUIDTXBYTES_API);
99 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETIFACERXBYTES_API);
100 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETIFACETXBYTES_API);
101 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACEGETLIST_API);
102 instance_->mockNetsysClient_.mockApi_.insert(MOCK_UIDGETLIST_API);
103 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETIFACERXPACKETS_API);
104 instance_->mockNetsysClient_.mockApi_.insert(MOCK_GETIFACETXPACKETS_API);
105 instance_->mockNetsysClient_.mockApi_.insert(MOCK_BINDSOCKET_API);
106 instance_->mockNetsysClient_.mockApi_.insert(MOCK_REGISTERNETSYSNOTIFYCALLBACK_API);
107 instance_->mockNetsysClient_.mockApi_.insert(MOCK_BINDNETWORKSERVICEVPN_API);
108 instance_->mockNetsysClient_.mockApi_.insert(MOCK_ENABLEVIRTUALNETIFACECARD_API);
109 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETIPADDRESS_API);
110 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SETBLOCKING_API);
111 instance_->mockNetsysClient_.mockApi_.insert(MOCK_SHAREDNSSET_API);
112 instance_->mockNetsysClient_.mockApi_.insert(MOCK_INTERFACECLEARADDRS_API);
113 instance_->mockNetsysClient_.mockApi_.insert(MOCK_FLUSHDNSCACHE_API);
114 }
115 }
116
TearDownTestCase()117 void NetsysControllerServiceImplTest::TearDownTestCase() {}
118
SetUp()119 void NetsysControllerServiceImplTest::SetUp() {}
120
TearDown()121 void NetsysControllerServiceImplTest::TearDown() {}
122
123 HWTEST_F(NetsysControllerServiceImplTest, NoRegisterMockApi, TestSize.Level1)
124 {
125 uint16_t baseTimeoutMsec = 0;
126 uint8_t retryCount = 0;
127 std::string testName = "eth0";
128 std::vector<std::string> servers;
129 std::vector<std::string> domains;
130 sptr<NetsysControllerCallback> callback = nullptr;
131
132 auto ret = instance_->NetworkCreatePhysical(0, 0);
133 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
134
135 ret = instance_->NetworkDestroy(0);
136 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
137
138 ret = instance_->NetworkAddInterface(0, testName, BEARER_DEFAULT);
139 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
140
141 ret = instance_->NetworkRemoveInterface(0, testName);
142 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
143
144 ret = instance_->NetworkAddRoute(0, testName, testName, testName);
145 EXPECT_EQ(ret, -1);
146
147 ret = instance_->NetworkRemoveRoute(0, testName, testName, testName);
148 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
149
150 ret = instance_->SetInterfaceDown(testName);
151 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
152
153 ret = instance_->SetInterfaceUp(testName);
154 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
155
156 ret = instance_->GetInterfaceMtu(testName);
157 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
158
159 ret = instance_->SetInterfaceMtu(testName, 1);
160 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
161
162 ret = instance_->AddInterfaceAddress(testName, testName, 1);
163 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
164
165 ret = instance_->DelInterfaceAddress(testName, testName, 1);
166 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
167
168 ret = instance_->SetResolverConfig(0, 0, 0, servers, domains);
169 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
170
171 ret = instance_->GetResolverConfig(0, servers, domains, baseTimeoutMsec, retryCount);
172 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
173
174 ret = instance_->RegisterCallback(callback);
175 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
176 }
177
178 HWTEST_F(NetsysControllerServiceImplTest, RunRegisterMockApi, TestSize.Level1)
179 {
180 std::string testName = "wlan0";
181
182 auto ret = instance_->GetCellularRxBytes();
183 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
184
185 instance_->ClearInterfaceAddrs(testName);
186 ret = instance_->GetCellularTxBytes();
187 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
188
189 ret = instance_->GetAllRxBytes();
190 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
191
192 ret = instance_->GetAllTxBytes();
193 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
194
195 ret = instance_->GetUidRxBytes(20010038);
196 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
197
198 ret = instance_->GetUidTxBytes(20010038);
199 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
200
201 ret = instance_->GetIfaceRxBytes(testName);
202 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
203
204 ret = instance_->GetIfaceTxBytes(testName);
205 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
206
207 ret = instance_->GetIfaceRxPackets(testName);
208 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
209
210 ret = instance_->GetIfaceTxPackets(testName);
211 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
212
213 ret = instance_->CreateNetworkCache(0);
214 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
215
216 ret = instance_->SetDefaultNetWork(0);
217 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
218
219 ret = instance_->ClearDefaultNetWorkNetId();
220 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
221
222 ret = instance_->StartDhcpClient(testName, false);
223 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
224
225 ret = instance_->StopDhcpClient(testName, false);
226 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
227
228 ret = instance_->StartDhcpService(testName, testName);
229 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
230
231 ret = instance_->StopDhcpService(testName);
232 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
233
234 auto list = instance_->InterfaceGetList();
235 EXPECT_GT(list.size(), static_cast<uint32_t>(0));
236
237 list = instance_->UidGetList();
238 EXPECT_EQ(list.size(), static_cast<uint32_t>(0));
239 }
240
241 HWTEST_F(NetsysControllerServiceImplTest, ServiceImplTest, TestSize.Level1)
242 {
243 std::vector<UidRange> uidRanges;
244 UidRange uidRang(1, 2);
245 uidRanges.emplace_back(uidRang);
246 int32_t ifaceFd = 5;
247 std::string ipAddr = "172.17.5.245";
248 NetsysNotifyCallback Callback;
249 Callback.NetsysResponseInterfaceAdd = nullptr;
250 Callback.NetsysResponseInterfaceRemoved = nullptr;
251
252 auto ret = instance_->NetworkCreateVirtual(5, false);
253 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
254
255 ret = instance_->NetworkAddUids(5, uidRanges);
256 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
257
258 ret = instance_->NetworkDelUids(5, uidRanges);
259 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
260
261 auto ret32 = instance_->BindSocket(1, 2);
262 EXPECT_EQ(ret32, NetManagerStandard::NETMANAGER_SUCCESS);
263
264 ret32 = instance_->RegisterNetsysNotifyCallback(Callback);
265 EXPECT_EQ(ret32, NetManagerStandard::NETMANAGER_SUCCESS);
266
267 ret32 = instance_->BindNetworkServiceVpn(5);
268 EXPECT_TRUE(ret32 == NetsysContrlResultCode::NETSYS_ERR_VPN || ret == NetManagerStandard::NETMANAGER_SUCCESS);
269
270 ifreq ifRequest;
271 ret32 = instance_->EnableVirtualNetIfaceCard(5, ifRequest, ifaceFd);
272 EXPECT_EQ(ret32, NetsysContrlResultCode::NETSYS_ERR_VPN);
273
274 ret32 = instance_->SetIpAddress(5, ipAddr, 23, ifRequest);
275 EXPECT_EQ(ret32, NetsysContrlResultCode::NETSYS_ERR_VPN);
276
277 ret32 = instance_->SetBlocking(5, false);
278 EXPECT_EQ(ret32, NetManagerStandard::NETMANAGER_SUCCESS);
279 }
280
281 HWTEST_F(NetsysControllerServiceImplTest, SetInternetPermission, TestSize.Level1)
282 {
283 uint32_t uid = 0;
284 uint8_t allow = 0;
285
286 auto ret = instance_->SetInternetPermission(uid, allow);
287 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
288
289 std::string tcpBufferSizes = "524288,1048576,2097152,262144,524288,1048576";
290 ret = instance_->SetTcpBufferSizes(tcpBufferSizes);
291 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
292 }
293
294 HWTEST_F(NetsysControllerServiceImplTest, ServiceImplTest002, TestSize.Level1)
295 {
296 std::string ipAddr = "192.168.1.100";
297 std::string macAddr = "aa:bb:cc:dd:ee:ff";
298 std::string ifName = "wlan0";
299 auto ret = instance_->AddStaticArp(ipAddr, macAddr, ifName);
300 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
301
302 ret = instance_->DelStaticArp(ipAddr, macAddr, ifName);
303 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
304 }
305
306 HWTEST_F(NetsysControllerServiceImplTest, AddStaticIpv6AddrTest001, TestSize.Level1)
307 {
308 std::string ipAddr = "2001:0db8:85a3:0000:0000:8a2e:0370:7334";
309 std::string macAddr = "aa:bb:cc:dd:ee:ff";
310 std::string ifName = "chba0";
311 auto ret = instance_->AddStaticIpv6Addr(ipAddr, macAddr, ifName);
312
313 ret = instance_->DelStaticIpv6Addr(ipAddr, macAddr, ifName);
314 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
315 }
316
317 HWTEST_F(NetsysControllerServiceImplTest, DelStaticIpv6AddrTest001, TestSize.Level1)
318 {
319 std::string ipAddr = "2001:0db8:85a3:0000:0000:8a2e:0370:7334";
320 std::string macAddr = "aa:bb:cc:dd:ee:ff";
321 std::string ifName = "chba0";
322 auto ret = instance_->AddStaticIpv6Addr(ipAddr, macAddr, ifName);
323 ret = instance_->DelStaticIpv6Addr(ipAddr, macAddr, ifName);
324 EXPECT_TRUE(ret == NetManagerStandard::NETMANAGER_SUCCESS || ret == NETMANAGER_ERR_OPERATION_FAILED);
325 }
326
327 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest001, TestSize.Level1)
328 {
329 instance_->mockNetsysClient_.mockApi_.clear();
330 int32_t netId = 0;
331 int32_t permission = 0;
332 auto ret = instance_->NetworkCreatePhysical(netId, permission);
333 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
334
335 ret = instance_->NetworkDestroy(netId);
336 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
337
338 std::string testName = "eth0";
339 ret = instance_->NetworkRemoveInterface(netId, testName);
340 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
341
342 OHOS::nmd::InterfaceConfigurationParcel cfg = {};
343 ret = instance_->GetInterfaceConfig(cfg);
344 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
345
346 ret = instance_->SetInterfaceConfig(cfg);
347 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
348
349 ret = instance_->SetInterfaceDown(testName);
350 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
351
352 uint16_t baseTimeoutMsec = 0;
353 uint8_t retryCount = 0;
354 std::vector<std::string> servers = {};
355 std::vector<std::string> domains = {};
356 ret = instance_->SetResolverConfig(netId, baseTimeoutMsec, retryCount, servers, domains);
357 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
358
359 ret = instance_->GetResolverConfig(netId, servers, domains, baseTimeoutMsec, retryCount);
360 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
361
362 ret = instance_->CreateNetworkCache(netId);
363 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
364
365 ret = instance_->DestroyNetworkCache(netId);
366 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
367
368 ret = instance_->GetCellularRxBytes();
369 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
370
371 ret = instance_->SetInterfaceUp(testName);
372 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
373
374 std::string ifName = "";
375 instance_->ClearInterfaceAddrs(ifName);
376 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
377
378 ret = instance_->GetCellularTxBytes();
379 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
380
381 ret = instance_->GetAllRxBytes();
382 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
383
384 ret = instance_->GetAllTxBytes();
385 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
386 }
387
388 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest002, TestSize.Level1)
389 {
390 instance_->mockNetsysClient_.mockApi_.clear();
391 int32_t netId = 0;
392 std::string interfaceName = "";
393 auto ret = instance_->GetIfaceRxBytes(interfaceName);
394 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
395
396 ret = instance_->GetIfaceTxBytes(interfaceName);
397 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
398
399 std::vector<std::string> ifList = {};
400 EXPECT_TRUE(instance_->InterfaceGetList() != ifList);
401 EXPECT_FALSE(instance_->UidGetList() != ifList);
402
403 ret = instance_->GetIfaceRxPackets(interfaceName);
404 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
405
406 ret = instance_->GetIfaceTxPackets(interfaceName);
407 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
408
409 ret = instance_->SetDefaultNetWork(netId);
410 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
411
412 ret = instance_->ClearDefaultNetWorkNetId();
413 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
414
415 int32_t socketFd = 0;
416 ret = instance_->BindSocket(socketFd, netId);
417 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
418
419 std::string testString = "";
420 ret = instance_->IpEnableForwarding(testString);
421 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
422
423 ret = instance_->IpDisableForwarding(testString);
424 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
425
426 ret = instance_->ShareDnsSet(netId);
427 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
428
429 ret = instance_->StartDnsProxyListen();
430 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
431
432 ret = instance_->StopDnsProxyListen();
433 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
434
435 NetsysNotifyCallback callback = {};
436 ret = instance_->RegisterNetsysNotifyCallback(callback);
437 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
438
439 uint32_t uid = 0;
440 ret = instance_->GetUidRxBytes(uid);
441 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
442
443 ret = instance_->GetUidTxBytes(uid);
444 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
445
446 ret = instance_->GetUidOnIfaceRxBytes(uid, interfaceName);
447 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
448
449 ret = instance_->GetUidOnIfaceTxBytes(uid, interfaceName);
450 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
451 }
452
453 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest003, TestSize.Level1)
454 {
455 instance_->mockNetsysClient_.mockApi_.clear();
456
457 int32_t mtu = 0;
458 std::string testName = "eth0";
459 auto ret = instance_->SetInterfaceMtu(testName, mtu);
460 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
461
462 int32_t prefixLength = 0;
463 ret = instance_->AddInterfaceAddress(testName, "", prefixLength);
464 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
465
466 ret = instance_->GetInterfaceMtu(testName);
467 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
468
469 ret = instance_->DelInterfaceAddress(testName, "", prefixLength);
470 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
471
472 ret = instance_->InterfaceSetIpAddress(testName, "");
473 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
474
475 uint16_t netId = 0;
476 std::string hostName = "";
477 std::string serverName = "";
478 AddrInfo hints = {};
479 std::vector<AddrInfo> res = {};
480 ret = instance_->GetAddrInfo(hostName, serverName, hints, netId, res);
481 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
482
483 nmd::NetworkSharingTraffic traffic = {};
484 ret = instance_->GetNetworkSharingTraffic(hostName, serverName, traffic);
485 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
486
487 ret = instance_->NetworkAddInterface(netId, testName, BEARER_DEFAULT);
488 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
489
490 ret = instance_->NetworkAddRoute(netId, testName, "", "");
491 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
492
493 ret = instance_->NetworkRemoveRoute(netId, testName, "", "");
494 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
495
496 std::string testString = "";
497 ret = instance_->EnableNat(testString, testString);
498 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
499
500 ret = instance_->DisableNat(testString, testString);
501 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
502
503 ret = instance_->IpfwdAddInterfaceForward(testString, testString);
504 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
505
506 ret = instance_->IpfwdRemoveInterfaceForward(testString, testString);
507 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
508
509 int32_t socketFd = 0;
510 ret = instance_->BindNetworkServiceVpn(socketFd);
511 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
512 }
513
514 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest004, TestSize.Level1)
515 {
516 instance_->mockNetsysClient_.mockApi_.clear();
517 struct ifreq ifRequest = {};
518 int32_t ifaceFd = 0;
519 int32_t socketFd = 0;
520 auto ret = instance_->EnableVirtualNetIfaceCard(socketFd, ifRequest, ifaceFd);
521 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
522
523 int32_t prefixLen = 0;
524 ret = instance_->SetIpAddress(socketFd, "", prefixLen, ifRequest);
525 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
526
527 ret = instance_->BandwidthEnableDataSaver(false);
528 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
529
530 int64_t bytes = 0;
531 std::string ifName = "";
532 ret = instance_->BandwidthSetIfaceQuota(ifName, bytes);
533 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
534
535 ret = instance_->BandwidthRemoveIfaceQuota(ifName);
536 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
537
538 ret = instance_->RegisterCallback(nullptr);
539 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
540
541 std::vector<uint32_t> uidsParam = {};
542 uint32_t chain = 0;
543 ret = instance_->FirewallSetUidsAllowedListChain(chain, uidsParam);
544 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
545
546 ret = instance_->FirewallSetUidsDeniedListChain(chain, uidsParam);
547 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
548
549 ret = instance_->FirewallEnableChain(chain, false);
550 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
551
552 std::string cmd = "";
553 std::string respond = "";
554 NetsysNative::IptablesType ipType = NetsysNative::IptablesType::IPTYPE_IPV4;
555 ret = instance_->SetIptablesCommandForRes(cmd, respond, ipType);
556 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
557
558 ret = instance_->SetIpCommandForRes(cmd, respond);
559 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
560
561 OHOS::NetsysNative::NetDiagPingOption pingOption;
562 ret = instance_->NetDiagPingHost(pingOption, nullptr);
563 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
564
565 std::string interfaceName = "";
566 uint64_t stats = 0;
567 uint32_t type = 0;
568 ret = instance_->GetIfaceStats(stats, type, interfaceName);
569 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
570 }
571
572 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest005, TestSize.Level1)
573 {
574 instance_->mockNetsysClient_.mockApi_.clear();
575 uint32_t firewallRule = 0;
576 uint32_t chain = 0;
577 std::vector<uint32_t> uidsParam = {};
578 int32_t ret = instance_->FirewallSetUidRule(chain, uidsParam, firewallRule);
579 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
580
581 ret = instance_->ClearFirewallAllRules();
582 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
583
584 int32_t socketFd = 0;
585 ret = instance_->SetBlocking(socketFd, false);
586 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
587
588 std::string iface = "";
589 ret = instance_->StartDhcpClient(iface, false);
590 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
591
592 ret = instance_->StopDhcpClient(iface, false);
593 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
594
595 uint32_t uid = 0;
596 ret = instance_->BandwidthAddDeniedList(uid);
597 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
598
599 ret = instance_->BandwidthRemoveDeniedList(uid);
600 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
601
602 ret = instance_->BandwidthAddAllowedList(uid);
603 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
604
605 ret = instance_->BandwidthRemoveAllowedList(uid);
606 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
607
608 std::string ipv4addr = "";
609 ret = instance_->StartDhcpService(iface, ipv4addr);
610 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
611
612 ret = instance_->StopDhcpService(iface);
613 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
614 uint64_t stats = 0;
615 uint32_t type = 0;
616 ret = instance_->GetTotalStats(stats, type);
617 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
618
619 ret = instance_->GetUidStats(stats, type, uid);
620 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
621
622 ret = instance_->DeleteStatsInfo(TEST_UID);
623 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
624
625 ret = instance_->DeleteSimStatsInfo(TEST_UID);
626 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
627
628 std::vector<OHOS::NetManagerStandard::NetStatsInfo> statsInfo = {};
629 ret = instance_->GetAllStatsInfo(statsInfo);
630 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
631
632 std::list<OHOS::NetsysNative::NetDiagRouteTable> routeTables;
633 ret = instance_->NetDiagGetRouteTable(routeTables);
634 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
635 }
636
637 HWTEST_F(NetsysControllerServiceImplTest, GetAllSimStatsInfo001, TestSize.Level1)
638 {
639 std::vector<OHOS::NetManagerStandard::NetStatsInfo> statsInfo = {};
640 auto ret = instance_->GetAllSimStatsInfo(statsInfo);
641 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
642 }
643
644 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest006, TestSize.Level1)
645 {
646 instance_->mockNetsysClient_.mockApi_.clear();
647 OHOS::NetsysNative::NetDiagProtocolType socketType = OHOS::NetsysNative::NetDiagProtocolType::PROTOCOL_TYPE_ALL;
648 OHOS::NetsysNative::NetDiagSocketsInfo socketsInfo;
649 int32_t ret = instance_->NetDiagGetSocketsInfo(socketType, socketsInfo);
650 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
651
652 std::list<OHOS::NetsysNative::NetDiagIfaceConfig> configsList;
653 std::string ifaceName = "";
654 ret = instance_->NetDiagGetInterfaceConfig(configsList, ifaceName);
655 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
656
657 OHOS::NetsysNative::NetDiagIfaceConfig config;
658 ret = instance_->NetDiagUpdateInterfaceConfig(config, ifaceName, false);
659 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
660
661 ret = instance_->NetDiagSetInterfaceActiveState(ifaceName, false);
662 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
663 }
664
665 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest007, TestSize.Level1)
666 {
667 AddExtMockApi();
668 auto result = instance_->GetCellularRxBytes();
669 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
670
671 std::string testName = "wlan0";
672 instance_->ClearInterfaceAddrs(testName);
673 result = instance_->GetCellularTxBytes();
674 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
675
676 std::string interfaceName = "";
677 result = instance_->GetIfaceTxPackets(interfaceName);
678 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
679
680 int32_t socketFd = 0;
681 int32_t netId = 0;
682 result = instance_->BindSocket(socketFd, netId);
683 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
684
685 result = instance_->ShareDnsSet(netId);
686 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
687
688 result = instance_->GetIfaceRxBytes(interfaceName);
689 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
690
691 result = instance_->GetIfaceTxBytes(interfaceName);
692 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
693
694 result = instance_->GetIfaceRxPackets(interfaceName);
695 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
696
697 uint32_t uid = 0;
698 result = instance_->GetUidOnIfaceRxBytes(uid, interfaceName);
699 EXPECT_NE(result, NetManagerStandard::NETMANAGER_SUCCESS);
700
701 result = instance_->GetUidOnIfaceTxBytes(uid, interfaceName);
702 EXPECT_NE(result, NetManagerStandard::NETMANAGER_SUCCESS);
703
704 result = instance_->GetUidRxBytes(uid);
705 EXPECT_NE(result, NetManagerStandard::NETMANAGER_SUCCESS);
706
707 std::vector<std::string> ifList = {};
708 EXPECT_FALSE(instance_->UidGetList() != ifList);
709
710 result = instance_->GetUidTxBytes(uid);
711 EXPECT_NE(result, NetManagerStandard::NETMANAGER_SUCCESS);
712 }
713
714 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest008, TestSize.Level1)
715 {
716 AddExtMockApi();
717 NetsysNotifyCallback callback = {};
718 int32_t result = instance_->RegisterNetsysNotifyCallback(callback);
719 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
720
721 int32_t socketFd = 0;
722 result = instance_->BindNetworkServiceVpn(socketFd);
723 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
724
725 int32_t ifaceFd = 0;
726 struct ifreq ifRequest = {};
727 result = instance_->EnableVirtualNetIfaceCard(socketFd, ifRequest, ifaceFd);
728 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
729
730 int32_t prefixLen = 0;
731 result = instance_->SetIpAddress(socketFd, "", prefixLen, ifRequest);
732 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
733
734 result = instance_->SetBlocking(socketFd, false);
735 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
736
737 uint16_t netId = 0;
738 result = instance_->FlushDnsCache(netId);
739 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
740 }
741
742 HWTEST_F(NetsysControllerServiceImplTest, GetCookieStatsTest001, TestSize.Level1)
743 {
744 uint64_t stats = 0;
745 auto ret = instance_->GetCookieStats(stats, TEST_STATS_TYPE1, TEST_COOKIE);
746 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
747
748 ret = instance_->GetCookieStats(stats, TEST_STATS_TYPE2, TEST_COOKIE);
749 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
750 }
751
752 HWTEST_F(NetsysControllerServiceImplTest, GetNetworkSharingTypeTest001, TestSize.Level1)
753 {
754 std::set<uint32_t> sharingTypeIsOn;
755 auto ret = instance_->GetNetworkSharingType(sharingTypeIsOn);
756 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
757 }
758
759 HWTEST_F(NetsysControllerServiceImplTest, UpdateNetworkSharingTypeTest001, TestSize.Level1)
760 {
761 uint64_t type = 0;
762 bool isOpen = true;
763 auto ret = instance_->UpdateNetworkSharingType(type, isOpen);
764 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
765 }
766
767 HWTEST_F(NetsysControllerServiceImplTest, NetsysControllerServiceImplBranchTest009, TestSize.Level1)
768 {
769 uint32_t timeStep = 0;
770 sptr<OHOS::NetManagerStandard::NetsysDnsReportCallback> reportCallback = nullptr;
771 auto ret = instance_->RegisterDnsResultCallback(reportCallback, timeStep);
772 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
773
774 ret = instance_->UnregisterDnsResultCallback(reportCallback);
775 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
776
777 sptr<NetsysNative::INetDnsHealthCallback> healthCallback = nullptr;
778 ret = instance_->RegisterDnsHealthCallback(healthCallback);
779 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
780
781 ret = instance_->UnregisterDnsHealthCallback(healthCallback);
782 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
783
784 sptr<OHOS::NetManagerStandard::NetsysDnsQueryReportCallback> queryCallback = nullptr;
785 ret = instance_->RegisterDnsQueryResultCallback(queryCallback);
786 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
787
788 ret = instance_->UnregisterDnsQueryResultCallback(queryCallback);
789 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
790 }
791
792 HWTEST_F(NetsysControllerServiceImplTest, SetIpv6PrivacyExtensionsTest001, TestSize.Level1)
793 {
794 std::string interface = "wlan0";
795 uint32_t on = 1;
796 int32_t ret = instance_->SetIpv6PrivacyExtensions(interface, on);
797 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
798
799 ret = instance_->SetEnableIpv6(interface, on);
800 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
801 }
802
803 HWTEST_F(NetsysControllerServiceImplTest, SetNetworkAccessPolicy001, TestSize.Level1)
804 {
805 uint32_t uid = 0;
806 NetworkAccessPolicy netAccessPolicy;
807 netAccessPolicy.wifiAllow = false;
808 netAccessPolicy.cellularAllow = false;
809 bool reconfirmFlag = true;
810 auto ret = instance_->SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag);
811 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
812 }
813
814 HWTEST_F(NetsysControllerServiceImplTest, NotifyNetBearerTypeChange001, TestSize.Level1)
815 {
816 std::set<NetManagerStandard::NetBearType> bearTypes;
817 bearTypes.insert(NetManagerStandard::NetBearType::BEARER_CELLULAR);
818 auto ret = instance_->NotifyNetBearerTypeChange(bearTypes);
819 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
820 }
821
822 HWTEST_F(NetsysControllerServiceImplTest, DeleteNetworkAccessPolicy001, TestSize.Level1)
823 {
824 uint32_t uid = 0;
825 auto ret = instance_->DeleteNetworkAccessPolicy(uid);
826 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
827 }
828
829 HWTEST_F(NetsysControllerServiceImplTest, CloseSocketsUid001, TestSize.Level1)
830 {
831 std::string ipAddr = "";
832 uint32_t uid = 1000;
833 int32_t result = instance_->CloseSocketsUid(ipAddr, uid);
834 EXPECT_EQ(result, NetManagerStandard::NETMANAGER_SUCCESS);
835 }
836
837 HWTEST_F(NetsysControllerServiceImplTest, SetBrokerUidAccessPolicyMapTest001, TestSize.Level1)
838 {
839 std::unordered_map<uint32_t, uint32_t> params;
840 int32_t ret = instance_->SetBrokerUidAccessPolicyMap(params);
841 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
842 }
843
844 HWTEST_F(NetsysControllerServiceImplTest, SetBrokerUidAccessPolicyMapTest002, TestSize.Level1)
845 {
846 std::unordered_map<uint32_t, uint32_t> params;
847 params.emplace(TEST_UID, TEST_UID);
848 int32_t ret = instance_->SetBrokerUidAccessPolicyMap(params);
849 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
850 }
851
852 HWTEST_F(NetsysControllerServiceImplTest, DelBrokerUidAccessPolicyMapTest001, TestSize.Level1)
853 {
854 int32_t ret = instance_->DelBrokerUidAccessPolicyMap(TEST_UID);
855 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
856 }
857
858 HWTEST_F(NetsysControllerServiceImplTest, DeleteIncreaseTrafficMapTest002, TestSize.Level1)
859 {
860 SafeMap<std::string, std::string> ifaceNameIdentMap_;
861 NetConnClient::GetInstance().GetIfaceNameIdentMaps(NetBearType::BEARER_CELLULAR, ifaceNameIdentMap_);
862 int32_t ret = instance_->DeleteIncreaseTrafficMap(12);
863 EXPECT_TRUE(ret == NetManagerStandard::NETMANAGER_SUCCESS || ret == NetManagerStandard::NETMANAGER_ERROR);
864 ret = instance_->DeleteIncreaseTrafficMap(10);
865 EXPECT_TRUE(ret == NetManagerStandard::NETMANAGER_SUCCESS || ret == NetManagerStandard::NETMANAGER_ERROR);
866 ret = instance_->DeleteIncreaseTrafficMap(13);
867 }
868
869 #ifdef FEATURE_WEARABLE_DISTRIBUTED_NET_ENABLE
870 HWTEST_F(NetsysControllerServiceImplTest, DisableWearableDistributedNetForward, TestSize.Level1)
871 {
872 auto ret = instance_->EnableWearableDistributedNetForward(8001, 8002);
873 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
874
875 ret = instance_->DisableWearableDistributedNetForward();
876 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
877 }
878 #endif
879
880 HWTEST_F(NetsysControllerServiceImplTest, DelInterfaceAddressTest001, TestSize.Level1)
881 {
882 std::string ifName = "eth0";
883 std::string ipAddr = "";
884 int32_t prefixLength = 123;
885 std::string netCapabilities = "";
886 int32_t ret = instance_->DelInterfaceAddress(ifName, ipAddr, prefixLength, netCapabilities);
887 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
888 }
889
890 HWTEST_F(NetsysControllerServiceImplTest, SetNetStateTrafficMapTest001, TestSize.Level1)
891 {
892 uint8_t flag = 1;
893 uint64_t availableTraffic = 1;
894 int32_t ret = instance_->SetNetStateTrafficMap(flag, availableTraffic);
895 EXPECT_TRUE(ret == 300 || ret == 0);
896 }
897
898 HWTEST_F(NetsysControllerServiceImplTest, GetNetStateTrafficMapTest001, TestSize.Level1)
899 {
900 uint8_t flag = 1;
901 uint64_t availableTraffic = 1;
902 int32_t ret = instance_->GetNetStateTrafficMap(flag, availableTraffic);
903 EXPECT_TRUE(ret == 3 || ret == 0);
904 }
905
906 HWTEST_F(NetsysControllerServiceImplTest, ClearIncreaseTrafficMapTest001, TestSize.Level1)
907 {
908 int32_t ret = instance_->ClearIncreaseTrafficMap();
909 EXPECT_TRUE(ret == 3 || ret == 0);
910 }
911
912 HWTEST_F(NetsysControllerServiceImplTest, UpdateIfIndexMapTest001, TestSize.Level1)
913 {
914 int8_t key = 1;
915 uint64_t index = 1;
916 int32_t ret = instance_->UpdateIfIndexMap(key, index);
917 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
918 }
919
920 HWTEST_F(NetsysControllerServiceImplTest, RegisterNetsysTrafficCallbackTest001, TestSize.Level1)
921 {
922 sptr<NetsysNative::INetsysTrafficCallback> callback;
923 int32_t ret = instance_->RegisterNetsysTrafficCallback(callback);
924 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
925 }
926
927 HWTEST_F(NetsysControllerServiceImplTest, UnRegisterNetsysTrafficCallbackTest001, TestSize.Level1)
928 {
929 sptr<NetsysNative::INetsysTrafficCallback> callback;
930 int32_t ret = instance_->UnRegisterNetsysTrafficCallback(callback);
931 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
932 }
933
934 HWTEST_F(NetsysControllerServiceImplTest, SetDnsCacheTest001, TestSize.Level1)
935 {
936 uint16_t netId = 101;
937 std::string testHost = "test";
938 AddrInfo info;
939 int32_t ret = instance_->SetDnsCache(netId, testHost, info);
940 EXPECT_TRUE(ret == NetManagerStandard::NETMANAGER_SUCCESS || ret == 400);
941 }
942
943 #ifdef FEATURE_ENTERPRISE_ROUTE_CUSTOM
944 HWTEST_F(NetsysControllerTest, UpdateEnterpriseRouteTest001, TestSize.Level1)
945 {
946 uint32_t uid = 20000138;
947 std::string ifname = "wlan0";
948 bool add = true;
949 auto ret = NetsysController::GetInstance().UpdateEnterpriseRoute(ifname, uid, add);
950 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
951 }
952
953 HWTEST_F(NetsysControllerTest, UpdateEnterpriseRouteTest002, TestSize.Level1)
954 {
955 uint32_t uid = 0;
956 std::string ifname = "wlan0";
957 bool add = true;
958 auto ret = NetsysController::GetInstance().UpdateEnterpriseRoute(ifname, uid, add);
959 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
960 }
961
962 HWTEST_F(NetsysControllerTest, UpdateEnterpriseRouteTest003, TestSize.Level1)
963 {
964 uint32_t uid = 20000138;
965 std::string ifname = "notexist";
966 bool add = true;
967 auto ret = NetsysController::GetInstance().UpdateEnterpriseRoute(ifname, uid, add);
968 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_PARAMETER_ERROR);
969 }
970 #endif
971
972 HWTEST_F(NetsysControllerServiceImplTest, FlushDnsCache001, TestSize.Level1)
973 {
974 uint16_t netId = 101;
975 int32_t ret = instance_->FlushDnsCache(netId);
976 EXPECT_TRUE(ret == NetManagerStandard::NETMANAGER_SUCCESS || ret == 400);
977 }
978 } // namespace NetManagerStandard
979 } // namespace OHOS
980