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 <cstring>
18 #include <gtest/gtest.h>
19 #include <iostream>
20 #include <thread>
21 
22 #include "netmanager_base_test_security.h"
23 
24 #ifdef GTEST_API_
25 #define private public
26 #define protected public
27 #endif
28 
29 #include "bpf_def.h"
30 #include "bpf_mapper.h"
31 #include "bpf_path.h"
32 #include "common_net_diag_callback_test.h"
33 #include "common_netsys_controller_callback_test.h"
34 #include "netmanager_base_common_utils.h"
35 #include "net_conn_constants.h"
36 #include "net_diag_callback_stub.h"
37 #include "netnative_log_wrapper.h"
38 #include "netsys_controller.h"
39 #include "netsys_ipc_interface_code.h"
40 #include "netsys_net_diag_data.h"
41 
42 namespace OHOS {
43 namespace NetManagerStandard {
44 namespace {
45 using namespace testing::ext;
46 static constexpr const char *IFACE = "test0";
47 static constexpr const char *WLAN = "wlan0";
48 static constexpr const char *ETH0 = "eth0";
49 static constexpr const char *DESTINATION = "192.168.1.3/24";
50 static constexpr const char *NEXT_HOP = "192.168.1.1";
51 static constexpr const char *PARCEL_IPV4_ADDR = "192.168.55.121";
52 static constexpr const char *IP_ADDR = "172.17.5.245";
53 static constexpr const char *INTERFACE_NAME = "";
54 static constexpr const char *IF_NAME = "iface0";
55 static constexpr const char *TCP_BUFFER_SIZES = "524288,1048576,2097152,262144,524288,1048576";
56 static constexpr uint64_t TEST_COOKIE = 1;
57 static constexpr uint32_t TEST_STATS_TYPE1 = 0;
58 static constexpr uint32_t TEST_STATS_TYPE2 = 2;
59 static constexpr uint32_t IPC_ERR_FLATTEN_OBJECT = 3;
60 const int NET_ID = 2;
61 const int PERMISSION = 5;
62 const int PREFIX_LENGTH = 23;
63 const int TEST_MTU = 111;
64 uint16_t g_baseTimeoutMsec = 200;
65 uint8_t g_retryCount = 3;
66 const int32_t TEST_UID_32 = 1;
67 const int64_t TEST_UID = 1010;
68 const int32_t SOCKET_FD = 5;
69 const int32_t TEST_STATS_UID = 11111;
70 int g_ifaceFd = 5;
71 const int64_t BYTES = 2097152;
72 const uint32_t FIREWALL_RULE = 1;
73 bool g_isWaitAsync = false;
74 const int32_t ERR_INVALID_DATA = 5;
75 } // namespace
76 
77 class NetsysControllerTest : public testing::Test {
78 public:
79     static void SetUpTestCase();
80 
81     static void TearDownTestCase();
82 
83     void SetUp();
84 
85     void TearDown();
86 
87     static inline std::shared_ptr<NetsysController> instance_ = nullptr;
88 
89     sptr<NetsysNative::NetDiagCallbackStubTest> netDiagCallback = new NetsysNative::NetDiagCallbackStubTest();
90 };
91 
SetUpTestCase()92 void NetsysControllerTest::SetUpTestCase()
93 {
94     instance_ = std::make_shared<NetsysController>();
95 }
96 
TearDownTestCase()97 void NetsysControllerTest::TearDownTestCase() {}
98 
SetUp()99 void NetsysControllerTest::SetUp() {}
100 
TearDown()101 void NetsysControllerTest::TearDown() {}
102 
103 HWTEST_F(NetsysControllerTest, NetsysControllerTest001, TestSize.Level1)
104 {
105     int32_t ret = NetsysController::GetInstance().NetworkCreatePhysical(NET_ID, PERMISSION);
106     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
107 
108     ret = NetsysController::GetInstance().NetworkDestroy(NET_ID);
109     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
110 }
111 
112 HWTEST_F(NetsysControllerTest, NetsysControllerTest002, TestSize.Level1)
113 {
114     int32_t ret = NetsysController::GetInstance().NetworkAddInterface(NET_ID, WLAN, BEARER_DEFAULT);
115     EXPECT_EQ(ret, -1);
116 
117     ret = NetsysController::GetInstance().NetworkRemoveInterface(NET_ID, WLAN);
118     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
119 }
120 
121 HWTEST_F(NetsysControllerTest, NetsysControllerTest003, TestSize.Level1)
122 {
123     int32_t ret = NetsysController::GetInstance().NetworkAddRoute(NET_ID, ETH0, DESTINATION, NEXT_HOP);
124     EXPECT_LE(ret, 0);
125 
126     ret = NetsysController::GetInstance().NetworkRemoveRoute(NET_ID, ETH0, DESTINATION, NEXT_HOP);
127     EXPECT_LE(ret, 0);
128 }
129 
130 HWTEST_F(NetsysControllerTest, NetsysControllerTest004, TestSize.Level1)
131 {
132     OHOS::nmd::InterfaceConfigurationParcel parcel;
133     parcel.ifName = ETH0;
134     parcel.ipv4Addr = PARCEL_IPV4_ADDR;
135     int32_t ret = NetsysController::GetInstance().SetInterfaceConfig(parcel);
136     EXPECT_EQ(ret, 0);
137 
138     ret = NetsysController::GetInstance().GetInterfaceConfig(parcel);
139     EXPECT_EQ(ret, 0);
140 }
141 
142 HWTEST_F(NetsysControllerTest, NetsysControllerTest005, TestSize.Level1)
143 {
144     int32_t ret = NetsysController::GetInstance().SetInterfaceDown(ETH0);
145     EXPECT_EQ(ret, 0);
146 
147     ret = NetsysController::GetInstance().SetInterfaceUp(ETH0);
148     EXPECT_EQ(ret, 0);
149 
150     NetsysController::GetInstance().ClearInterfaceAddrs(ETH0);
151 }
152 
153 HWTEST_F(NetsysControllerTest, NetsysControllerTest006, TestSize.Level1)
154 {
155     int32_t ret = NetsysController::GetInstance().SetInterfaceMtu(ETH0, TEST_MTU);
156     EXPECT_EQ(ret, -1);
157 
158     ret = NetsysController::GetInstance().GetInterfaceMtu(ETH0);
159     EXPECT_EQ(ret, -1);
160 
161     ret = NetsysController::GetInstance().SetTcpBufferSizes(TCP_BUFFER_SIZES);
162     EXPECT_EQ(ret, 0);
163 }
164 
165 HWTEST_F(NetsysControllerTest, NetsysControllerTest007, TestSize.Level1)
166 {
167     auto ifaceList = NetsysController::GetInstance().InterfaceGetList();
168     bool eth0NotExist = std::find(ifaceList.begin(), ifaceList.end(), std::string(ETH0)) == ifaceList.end();
169     if (eth0NotExist) {
170         return;
171     }
172 
173     int32_t ret = NetsysController::GetInstance().AddInterfaceAddress(ETH0, IP_ADDR, PREFIX_LENGTH);
174     EXPECT_EQ(ret, 0);
175 
176     ret = NetsysController::GetInstance().DelInterfaceAddress(ETH0, IP_ADDR, PREFIX_LENGTH);
177     EXPECT_EQ(ret, 0);
178 }
179 
180 HWTEST_F(NetsysControllerTest, NetsysControllerTest008, TestSize.Level1)
181 {
182     int32_t ret = NetsysController::GetInstance().SetResolverConfig(NET_ID, g_baseTimeoutMsec, g_retryCount, {}, {});
183     EXPECT_EQ(ret, 0);
184 
185     std::vector<std::string> servers;
186     std::vector<std::string> domains;
187     ret = NetsysController::GetInstance().GetResolverConfig(NET_ID, servers, domains, g_baseTimeoutMsec, g_retryCount);
188     EXPECT_EQ(ret, 0);
189 }
190 
191 HWTEST_F(NetsysControllerTest, NetsysControllerTest009, TestSize.Level1)
192 {
193     int32_t ret = NetsysController::GetInstance().CreateNetworkCache(NET_ID);
194     EXPECT_EQ(ret, 0);
195 
196     ret = NetsysController::GetInstance().DestroyNetworkCache(NET_ID);
197     EXPECT_EQ(ret, 0);
198 }
199 
200 HWTEST_F(NetsysControllerTest, NetsysControllerTest010, TestSize.Level1)
201 {
202     nmd::NetworkSharingTraffic traffic;
203     int32_t ret = NetsysController::GetInstance().GetNetworkSharingTraffic(ETH0, ETH0, traffic);
204     EXPECT_EQ(ret, -1);
205 }
206 
207 HWTEST_F(NetsysControllerTest, NetsysControllerTest011, TestSize.Level1)
208 {
209     int32_t ret = NetsysController::GetInstance().GetCellularRxBytes();
210     EXPECT_EQ(ret, 0);
211 
212     ret = NetsysController::GetInstance().GetCellularTxBytes();
213     EXPECT_EQ(ret, 0);
214 
215     ret = NetsysController::GetInstance().GetAllRxBytes();
216     EXPECT_GE(ret, 0);
217 
218     ret = NetsysController::GetInstance().GetAllTxBytes();
219     EXPECT_GE(ret, 0);
220 
221     ret = NetsysController::GetInstance().GetUidRxBytes(TEST_UID);
222     EXPECT_EQ(ret, -1);
223 
224     ret = NetsysController::GetInstance().GetUidTxBytes(TEST_UID);
225     EXPECT_EQ(ret, -1);
226 
227     ret = NetsysController::GetInstance().GetUidOnIfaceRxBytes(TEST_UID, INTERFACE_NAME);
228     EXPECT_GE(ret, 0);
229 
230     ret = NetsysController::GetInstance().GetUidOnIfaceTxBytes(TEST_UID, INTERFACE_NAME);
231     EXPECT_GE(ret, 0);
232 
233     ret = NetsysController::GetInstance().GetIfaceRxBytes(INTERFACE_NAME);
234     EXPECT_EQ(ret, 0);
235 
236     ret = NetsysController::GetInstance().GetIfaceTxBytes(INTERFACE_NAME);
237     EXPECT_EQ(ret, 0);
238 }
239 
240 HWTEST_F(NetsysControllerTest, NetsysControllerTest012, TestSize.Level1)
241 {
242     std::vector<std::string> getList = NetsysController::GetInstance().InterfaceGetList();
243 
244     getList.clear();
245     getList = NetsysController::GetInstance().UidGetList();
246     EXPECT_EQ(getList.size(), 0);
247 
248     int64_t ret = NetsysController::GetInstance().GetIfaceRxPackets(INTERFACE_NAME);
249     EXPECT_EQ(ret, 0);
250 
251     ret = NetsysController::GetInstance().GetIfaceTxPackets(INTERFACE_NAME);
252     EXPECT_EQ(ret, 0);
253 
254     ret = NetsysController::GetInstance().SetDefaultNetWork(NET_ID);
255     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
256 
257     ret = NetsysController::GetInstance().ClearDefaultNetWorkNetId();
258     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
259 }
260 
261 HWTEST_F(NetsysControllerTest, NetsysControllerTest013, TestSize.Level1)
262 {
263     int32_t ret = NetsysController::GetInstance().BindSocket(SOCKET_FD, NET_ID);
264     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
265 
266     ret = NetsysController::GetInstance().IpEnableForwarding(INTERFACE_NAME);
267     EXPECT_EQ(ret, 0);
268 
269     ret = NetsysController::GetInstance().IpDisableForwarding(INTERFACE_NAME);
270     EXPECT_EQ(ret, 0);
271 
272     ret = NetsysController::GetInstance().EnableNat(ETH0, ETH0);
273     EXPECT_NE(ret, 0);
274 
275     ret = NetsysController::GetInstance().DisableNat(ETH0, ETH0);
276     EXPECT_NE(ret, 0);
277 
278     ret = NetsysController::GetInstance().IpfwdAddInterfaceForward(ETH0, ETH0);
279     EXPECT_NE(ret, 0);
280 
281     ret = NetsysController::GetInstance().IpfwdRemoveInterfaceForward(ETH0, ETH0);
282     EXPECT_NE(ret, 0);
283 }
284 
285 HWTEST_F(NetsysControllerTest, NetsysControllerTest014, TestSize.Level1)
286 {
287     int32_t ret = NetsysController::GetInstance().ShareDnsSet(NET_ID);
288     EXPECT_EQ(ret, 0);
289 
290     ret = NetsysController::GetInstance().StartDnsProxyListen();
291     EXPECT_EQ(ret, 0);
292 
293     ret = NetsysController::GetInstance().StopDnsProxyListen();
294     EXPECT_EQ(ret, 0);
295 
296     ret = NetsysController::GetInstance().BindNetworkServiceVpn(SOCKET_FD);
297     EXPECT_EQ(ret, 0);
298 
299     ifreq ifRequest;
300     ret = NetsysController::GetInstance().EnableVirtualNetIfaceCard(SOCKET_FD, ifRequest, g_ifaceFd);
301     EXPECT_EQ(ret, 0);
302 
303     ret = NetsysController::GetInstance().SetIpAddress(SOCKET_FD, IP_ADDR, PREFIX_LENGTH, ifRequest);
304     EXPECT_EQ(ret, 0);
305 
306     ret = NetsysController::GetInstance().SetBlocking(g_ifaceFd, true);
307     EXPECT_EQ(ret, 0);
308 
309     ret = NetsysController::GetInstance().SetBlocking(g_ifaceFd, false);
310     EXPECT_EQ(ret, 0);
311 
312     ret = NetsysController::GetInstance().StartDhcpClient(INTERFACE_NAME, true);
313     EXPECT_EQ(ret, 0);
314 
315     ret = NetsysController::GetInstance().StartDhcpClient(INTERFACE_NAME, false);
316     EXPECT_EQ(ret, 0);
317 
318     ret = NetsysController::GetInstance().StopDhcpClient(INTERFACE_NAME, true);
319     EXPECT_EQ(ret, 0);
320 
321     ret = NetsysController::GetInstance().StopDhcpClient(INTERFACE_NAME, false);
322     EXPECT_EQ(ret, 0);
323 
324     ret = NetsysController::GetInstance().StartDhcpService(INTERFACE_NAME, IP_ADDR);
325     EXPECT_EQ(ret, 0);
326 
327     ret = NetsysController::GetInstance().StopDhcpService(INTERFACE_NAME);
328     EXPECT_EQ(ret, 0);
329 }
330 
331 HWTEST_F(NetsysControllerTest, NetsysControllerTest015, TestSize.Level1)
332 {
333     NetsysController::GetInstance().BandwidthEnableDataSaver(false);
334     int32_t ret = NetsysController::GetInstance().BandwidthEnableDataSaver(true);
335     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
336 
337     ret = NetsysController::GetInstance().BandwidthSetIfaceQuota(IF_NAME, BYTES);
338     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
339 
340     ret = NetsysController::GetInstance().BandwidthSetIfaceQuota(WLAN, BYTES);
341     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
342 
343     ret = NetsysController::GetInstance().BandwidthRemoveIfaceQuota(IF_NAME);
344     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
345 
346     ret = NetsysController::GetInstance().BandwidthRemoveIfaceQuota(WLAN);
347     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
348 
349     ret = NetsysController::GetInstance().BandwidthAddDeniedList(TEST_UID);
350     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
351 
352     ret = NetsysController::GetInstance().BandwidthAddAllowedList(TEST_UID);
353     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
354 
355     ret = NetsysController::GetInstance().BandwidthRemoveDeniedList(TEST_UID);
356     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
357 
358     ret = NetsysController::GetInstance().BandwidthRemoveAllowedList(TEST_UID);
359     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
360 
361     std::vector<uint32_t> uids;
362     uids.push_back(TEST_UID);
363     ret = NetsysController::GetInstance().FirewallSetUidsAllowedListChain(TEST_UID, uids);
364     EXPECT_NE(ret, 0);
365     ret = NetsysController::GetInstance().FirewallSetUidsDeniedListChain(TEST_UID, uids);
366     EXPECT_NE(ret, 0);
367 
368     ret = NetsysController::GetInstance().FirewallEnableChain(TEST_UID, true);
369     EXPECT_NE(ret, 0);
370 
371     ret = NetsysController::GetInstance().FirewallSetUidRule(TEST_UID, {TEST_UID}, FIREWALL_RULE);
372     EXPECT_NE(ret, 0);
373 }
374 
375 HWTEST_F(NetsysControllerTest, NetsysControllerTest016, TestSize.Level1)
376 {
377     int32_t ret = NetsysController::GetInstance().InterfaceSetIpAddress("ifaceName", "192.168.x.x");
378     EXPECT_NE(ret, 0);
379 
380     ret = NetsysController::GetInstance().InterfaceSetIpAddress("ifaceName", "192.168.2.0");
381     EXPECT_EQ(ret, -1);
382 
383     ret = NetsysController::GetInstance().InterfaceSetIffUp("");
384     EXPECT_NE(ret, 0);
385 
386     ret = NetsysController::GetInstance().InterfaceSetIffUp("ifaceName");
387     EXPECT_EQ(ret, -1);
388 
389     std::string hostName = "";
390     std::string serverName = "";
391     AddrInfo hints;
392     uint16_t netId = 0;
393     std::vector<AddrInfo> res;
394 
395     ret = NetsysController::GetInstance().GetAddrInfo(hostName, serverName, hints, netId, res);
396     EXPECT_NE(ret, 0);
397 
398     auto callback = new NetsysControllerCallbackTestCb();
399     ret = NetsysController::GetInstance().RegisterCallback(callback);
400     EXPECT_EQ(ret, 0);
401 }
402 
403 HWTEST_F(NetsysControllerTest, NetsysControllerTest017, TestSize.Level1)
404 {
405     uint64_t stats = 0;
406     int32_t ret = NetsysController::GetInstance().GetTotalStats(stats, 0);
407     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
408 
409     stats = 0;
410     ret = NetsysController::GetInstance().GetUidStats(stats, 0, TEST_STATS_UID);
411     EXPECT_EQ(ret, NetStatsResultCode::STATS_ERR_READ_BPF_FAIL);
412 
413     stats = 0;
414     ret = NetsysController::GetInstance().GetIfaceStats(stats, 0, IFACE);
415     EXPECT_EQ(ret, NetStatsResultCode::STATS_ERR_GET_IFACE_NAME_FAILED);
416 
417     ret = NetsysController::GetInstance().DeleteStatsInfo(TEST_UID_32);
418     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
419 
420     ret = NetsysController::GetInstance().DeleteSimStatsInfo(TEST_UID_32);
421     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
422 
423     stats = 0;
424     std::vector<OHOS::NetManagerStandard::NetStatsInfo> statsInfo;
425     ret = NetsysController::GetInstance().GetAllStatsInfo(statsInfo);
426     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
427 
428     ret = NetsysController::GetInstance().GetAllSimStatsInfo(statsInfo);
429     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
430 }
431 
432 HWTEST_F(NetsysControllerTest, NetsysControllerTest018, TestSize.Level1)
433 {
434     std::string respond;
435     int32_t ret = NetsysController::GetInstance().SetIptablesCommandForRes("-L", respond);
436     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_PERMISSION_DENIED);
437 
438     NetManagerBaseAccessToken token;
439     ret = NetsysController::GetInstance().SetIptablesCommandForRes("abc", respond);
440     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_PERMISSION_DENIED);
441 
442     ret = NetsysController::GetInstance().SetIptablesCommandForRes("-L", respond);
443     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_PERMISSION_DENIED);
444 }
445 
446 HWTEST_F(NetsysControllerTest, NetsysControllerErr001, TestSize.Level1)
447 {
448     std::vector<int32_t> beginUids;
449     std::vector<int32_t> endUids;
450     std::string iface = "test";
451     OHOS::nmd::InterfaceConfigurationParcel Parcel;
452 
453     int32_t ret = instance_->SetInternetPermission(0, 0);
454     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
455 
456     ret = instance_->NetworkCreateVirtual(0, false);
457     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
458 
459     ret = instance_->NetworkDestroy(0);
460     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
461 
462     ret = instance_->NetworkAddUids(0, beginUids, endUids);
463     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
464 
465     ret = instance_->NetworkDelUids(0, beginUids, endUids);
466     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
467 
468     ret = instance_->NetworkAddInterface(0, iface, BEARER_DEFAULT);
469     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
470 
471     ret = instance_->NetworkRemoveInterface(0, iface);
472     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
473 
474     ret = instance_->NetworkAddRoute(0, iface, iface, iface);
475     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
476 
477     ret = instance_->NetworkRemoveRoute(0, iface, iface, iface);
478     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
479 
480     ret = instance_->GetInterfaceConfig(Parcel);
481     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
482 
483     ret = instance_->SetInterfaceConfig(Parcel);
484     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
485 
486     ret = instance_->SetInterfaceDown(iface);
487     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
488 
489     ret = instance_->SetInterfaceUp(iface);
490     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
491 
492     instance_->ClearInterfaceAddrs(iface);
493     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
494 
495     ret = instance_->GetInterfaceMtu(iface);
496     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
497 
498     ret = instance_->SetInterfaceMtu(iface, 0);
499     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
500 }
501 
502 HWTEST_F(NetsysControllerTest, NetsysControllerErr002, TestSize.Level1)
503 {
504     std::string iface = "test";
505     std::vector<std::string> servers;
506     uint16_t baseTimeoutMsec = 0;
507     uint8_t retryCount = 0;
508     AddrInfo hints = {0};
509     std::vector<AddrInfo> res;
510     nmd::NetworkSharingTraffic traffic;
511     addrinfo *aihead = static_cast<addrinfo *>(malloc(sizeof(addrinfo)));
512     if (aihead != nullptr) {
513         aihead->ai_next = nullptr;
514         aihead->ai_addr = static_cast<sockaddr *>(malloc(sizeof(sockaddr)));
515     }
516     if (aihead != nullptr) {
517         aihead->ai_canonname = static_cast<char *>(malloc(10));
518     }
519 
520     int32_t ret = instance_->AddInterfaceAddress(iface, iface, 0);
521     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
522 
523     ret = instance_->DelInterfaceAddress(iface, iface, 0);
524     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
525 
526     ret = instance_->InterfaceSetIpAddress(iface, iface);
527     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
528 
529     ret = instance_->InterfaceSetIffUp(iface);
530     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
531 
532     ret = instance_->SetResolverConfig(0, 0, 0, servers, servers);
533     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
534 
535     ret = instance_->GetResolverConfig(0, servers, servers, baseTimeoutMsec, retryCount);
536     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
537 
538     ret = instance_->CreateNetworkCache(0);
539     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
540 
541     ret = instance_->DestroyNetworkCache(0);
542     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
543 
544     instance_->FreeAddrInfo(aihead);
545     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
546 
547     ret = instance_->GetAddrInfo(iface, iface, hints, 0, res);
548     EXPECT_EQ(ret, NetManagerStandard::NetConnResultCode::NET_CONN_ERR_SERVICE_UPDATE_NET_LINK_INFO_FAIL);
549 
550     ret = instance_->GetNetworkSharingTraffic(iface, iface, traffic);
551     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
552 }
553 
554 HWTEST_F(NetsysControllerTest, NetsysControllerErr003, TestSize.Level1)
555 {
556     std::string iface = "test";
557 
558     auto ret = instance_->GetCellularRxBytes();
559     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
560 
561     ret = instance_->GetCellularTxBytes();
562     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
563 
564     ret = instance_->GetAllRxBytes();
565     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
566 
567     ret = instance_->GetAllTxBytes();
568     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
569 
570     ret = instance_->GetUidRxBytes(0);
571     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
572 
573     ret = instance_->GetUidTxBytes(0);
574     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
575 
576     ret = instance_->GetUidOnIfaceRxBytes(0, iface);
577     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
578 
579     ret = instance_->GetUidOnIfaceTxBytes(0, iface);
580     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
581 
582     ret = instance_->GetIfaceRxBytes(iface);
583     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
584 
585     ret = instance_->GetIfaceTxBytes(iface);
586     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
587 
588     ret = instance_->GetIfaceRxPackets(iface);
589     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
590 
591     ret = instance_->GetIfaceTxPackets(iface);
592     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
593 }
594 
595 HWTEST_F(NetsysControllerTest, NetsysControllerErr004, TestSize.Level1)
596 {
597     std::string iface = "test";
598     NetsysNotifyCallback callback;
599 
600     auto faceList = instance_->InterfaceGetList();
601     EXPECT_EQ(faceList.size(), 0);
602 
603     auto uidList = instance_->UidGetList();
604     EXPECT_EQ(uidList.size(), 0);
605 
606     auto ret = instance_->SetDefaultNetWork(0);
607     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
608 
609     ret = instance_->ClearDefaultNetWorkNetId();
610     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
611 
612     ret = instance_->BindSocket(0, 0);
613     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
614 
615     ret = instance_->IpEnableForwarding(iface);
616     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
617 
618     ret = instance_->IpDisableForwarding(iface);
619     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
620 
621     ret = instance_->EnableNat(iface, iface);
622     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
623 
624     ret = instance_->DisableNat(iface, iface);
625     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
626 
627     ret = instance_->IpfwdAddInterfaceForward(iface, iface);
628     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
629 
630     ret = instance_->IpfwdRemoveInterfaceForward(iface, iface);
631     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
632 
633     ret = instance_->ShareDnsSet(0);
634     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
635 
636     ret = instance_->StartDnsProxyListen();
637     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
638 
639     ret = instance_->StopDnsProxyListen();
640     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
641 
642     ret = instance_->RegisterNetsysNotifyCallback(callback);
643     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
644 }
645 
646 HWTEST_F(NetsysControllerTest, NetsysControllerErr005, TestSize.Level1)
647 {
648     std::string iface = "test";
649     struct ifreq ifRequest;
650     int32_t ifaceFd = 0;
651     sptr<NetsysControllerCallback> callback;
652     auto ret = instance_->BindNetworkServiceVpn(0);
653     EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN);
654 
655     ret = instance_->BindNetworkServiceVpn(1);
656     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
657 
658     ret = instance_->EnableVirtualNetIfaceCard(0, ifRequest, ifaceFd);
659     EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN);
660 
661     ret = instance_->EnableVirtualNetIfaceCard(1, ifRequest, ifaceFd);
662     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
663 
664     ret = instance_->SetIpAddress(0, iface, 0, ifRequest);
665     EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN);
666 
667     ret = instance_->SetIpAddress(1, iface, 1, ifRequest);
668     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
669 
670     ret = instance_->SetBlocking(0, false);
671     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
672 
673     ret = instance_->StartDhcpClient(iface, false);
674     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
675 
676     ret = instance_->StopDhcpClient(iface, false);
677     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
678 
679     ret = instance_->StartDhcpService(iface, iface);
680     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
681 
682     ret = instance_->StopDhcpService(iface);
683     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
684 
685     ret = instance_->BandwidthEnableDataSaver(false);
686     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
687 
688     ret = instance_->BandwidthSetIfaceQuota(iface, 0);
689     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
690 
691     ret = instance_->BandwidthRemoveIfaceQuota(iface);
692     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
693 
694     ret = instance_->BandwidthAddDeniedList(0);
695     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
696 
697     ret = instance_->BandwidthRemoveDeniedList(0);
698     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
699 
700     ret = instance_->BandwidthAddAllowedList(0);
701     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
702 
703     ret = instance_->BandwidthRemoveAllowedList(0);
704     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
705 }
706 
707 HWTEST_F(NetsysControllerTest, NetsysControllerErr006, TestSize.Level1)
708 {
709     std::string iface = "test";
710     std::vector<uint32_t> uids;
711     uint64_t stats = 0;
712     std::vector<OHOS::NetManagerStandard::NetStatsInfo> statsInfo;
713 
714     auto ret = instance_->FirewallSetUidsAllowedListChain(0, uids);
715     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
716 
717     ret = instance_->FirewallSetUidsDeniedListChain(0, uids);
718     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
719 
720     ret = instance_->FirewallEnableChain(0, false);
721     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
722 
723     ret = instance_->FirewallSetUidRule(0, uids, 0);
724     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
725 
726     ret = instance_->ClearFirewallAllRules();
727     EXPECT_NE(ret, 0);
728 
729     ret = instance_->GetTotalStats(stats, 0);
730     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
731 
732     ret = instance_->GetUidStats(stats, 0, 0);
733     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
734 
735     ret = instance_->GetIfaceStats(stats, 0, iface);
736     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
737 
738     ret = instance_->GetAllStatsInfo(statsInfo);
739     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
740 
741     ret = instance_->SetIptablesCommandForRes(iface, iface);
742     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
743 
744     ret = instance_->SetTcpBufferSizes("");
745     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
746 }
747 
748 HWTEST_F(NetsysControllerTest, NetDiagGetRouteTable001, TestSize.Level1)
749 {
750     std::list<OHOS::NetsysNative::NetDiagRouteTable> diagrouteTable;
751     auto ret = NetsysController::GetInstance().NetDiagGetRouteTable(diagrouteTable);
752     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
753     for (const auto &lt : diagrouteTable) {
754         NETNATIVE_LOGI(
755             "show NetDiagRouteTable destination_:%{public}s gateway_:%{public}s"
756             "mask_:%{public}s iface_:%{public}s flags_:%{public}s metric_:%{public}d"
757             "ref_:%{public}d use_:%{public}d",
758             lt.destination_.c_str(), lt.gateway_.c_str(), lt.mask_.c_str(), lt.iface_.c_str(), lt.flags_.c_str(),
759             lt.metric_, lt.ref_, lt.use_);
760     }
761 }
762 
ShowSocketInfo(NetsysNative::NetDiagSocketsInfo & info)763 void ShowSocketInfo(NetsysNative::NetDiagSocketsInfo &info)
764 {
765     for (const auto &lt : info.netProtoSocketsInfo_) {
766         NETNATIVE_LOGI(
767             "ShowSocketInfo NeyDiagNetProtoSocketInfo protocol_:%{public}s localAddr_:%{public}s"
768             "foreignAddr_:%{public}s state_:%{public}s user_:%{public}s programName_:%{public}s recvQueue_:%{public}d"
769             "sendQueue_:%{public}d inode_:%{public}d ",
770             lt.protocol_.c_str(), lt.localAddr_.c_str(), lt.foreignAddr_.c_str(), lt.state_.c_str(), lt.user_.c_str(),
771             lt.programName_.c_str(), lt.recvQueue_, lt.sendQueue_, lt.inode_);
772     }
773 
774     for (const auto &lt : info.unixSocketsInfo_) {
775         NETNATIVE_LOGI(
776             "ShowSocketInfo  unixSocketsInfo_ refCnt_:%{public}d inode_:%{public}d protocol_:%{public}s"
777             "flags_:%{public}s type_:%{public}s state_:%{public}s path_:%{public}s",
778             lt.refCnt_, lt.inode_, lt.protocol_.c_str(), lt.flags_.c_str(), lt.type_.c_str(), lt.state_.c_str(),
779             lt.path_.c_str());
780     }
781 }
782 
783 HWTEST_F(NetsysControllerTest, NetDiagGetSocketsInfo001, TestSize.Level1)
784 {
785     OHOS::NetsysNative::NetDiagProtocolType socketType = OHOS::NetsysNative::NetDiagProtocolType::PROTOCOL_TYPE_ALL;
786     OHOS::NetsysNative::NetDiagSocketsInfo socketsInfo;
787     auto ret = NetsysController::GetInstance().NetDiagGetSocketsInfo(socketType, socketsInfo);
788     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
789     ShowSocketInfo(socketsInfo);
790 
791     socketsInfo.unixSocketsInfo_.clear();
792     socketsInfo.netProtoSocketsInfo_.clear();
793     socketType = OHOS::NetsysNative::NetDiagProtocolType::PROTOCOL_TYPE_RAW;
794     ret = NetsysController::GetInstance().NetDiagGetSocketsInfo(socketType, socketsInfo);
795     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
796     ShowSocketInfo(socketsInfo);
797 
798     socketsInfo.unixSocketsInfo_.clear();
799     socketsInfo.netProtoSocketsInfo_.clear();
800     socketType = OHOS::NetsysNative::NetDiagProtocolType::PROTOCOL_TYPE_TCP;
801     ret = NetsysController::GetInstance().NetDiagGetSocketsInfo(socketType, socketsInfo);
802     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
803     ShowSocketInfo(socketsInfo);
804 
805     socketsInfo.unixSocketsInfo_.clear();
806     socketsInfo.netProtoSocketsInfo_.clear();
807     socketType = OHOS::NetsysNative::NetDiagProtocolType::PROTOCOL_TYPE_UDP;
808     ret = NetsysController::GetInstance().NetDiagGetSocketsInfo(socketType, socketsInfo);
809     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
810     ShowSocketInfo(socketsInfo);
811 
812     socketsInfo.unixSocketsInfo_.clear();
813     socketsInfo.netProtoSocketsInfo_.clear();
814     socketType = OHOS::NetsysNative::NetDiagProtocolType::PROTOCOL_TYPE_UNIX;
815     ret = NetsysController::GetInstance().NetDiagGetSocketsInfo(socketType, socketsInfo);
816     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
817     ShowSocketInfo(socketsInfo);
818 }
819 
820 HWTEST_F(NetsysControllerTest, NetDiagGetInterfaceConfig001, TestSize.Level1)
821 {
822     std::list<OHOS::NetsysNative::NetDiagIfaceConfig> configs;
823     std::string ifaceName = "eth0";
824 
825     auto ret = NetsysController::GetInstance().NetDiagGetInterfaceConfig(configs, ifaceName);
826     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
827 
828     for (const OHOS::NetsysNative::NetDiagIfaceConfig &lt : configs) {
829         NETNATIVE_LOGI(
830             "ShowSocketInfo  DiagGetInterfaceConfig  ifaceName_:%{public}s linkEncap_:%{public}s"
831             "ipv4Addr_:%{public}s ipv4Bcast_:%{public}s ipv4Mask_:%{public}s mtu_:%{public}d txQueueLen_:%{public}d"
832             "rxBytes_:%{public}d txBytes_:%{public}d isUp_:%{public}d",
833             lt.ifaceName_.c_str(), lt.linkEncap_.c_str(), CommonUtils::ToAnonymousIp(lt.ipv4Addr_).c_str(),
834             lt.ipv4Bcast_.c_str(), lt.ipv4Mask_.c_str(), lt.mtu_, lt.txQueueLen_, lt.rxBytes_, lt.txBytes_, lt.isUp_);
835     }
836 
837     configs.clear();
838     ifaceName = "eth1";
839     ret = NetsysController::GetInstance().NetDiagGetInterfaceConfig(configs, ifaceName);
840     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
841 
842     for (const OHOS::NetsysNative::NetDiagIfaceConfig &lt : configs) {
843         NETNATIVE_LOGI(
844             "ShowSocketInfo  DiagGetInterfaceConfig ifaceName_:%{public}s linkEncap_:%{public}s"
845             "ipv4Addr_:%{public}s ipv4Bcast_:%{public}s ipv4Mask_:%{public}s mtu_:%{public}d txQueueLen_:%{public}d"
846             "rxBytes_:%{public}d txBytes_:%{public}d isUp_:%{public}d ",
847             lt.ifaceName_.c_str(), lt.linkEncap_.c_str(), CommonUtils::ToAnonymousIp(lt.ipv4Addr_).c_str(),
848             lt.ipv4Bcast_.c_str(), lt.ipv4Mask_.c_str(), lt.mtu_, lt.txQueueLen_, lt.rxBytes_, lt.txBytes_, lt.isUp_);
849     }
850 }
851 
852 HWTEST_F(NetsysControllerTest, NetDiagSetInterfaceActiveState001, TestSize.Level1)
853 {
854     std::list<OHOS::NetsysNative::NetDiagIfaceConfig> configs;
855     std::string ifaceName = "eth0";
856 
857     auto ret = NetsysController::GetInstance().NetDiagSetInterfaceActiveState(ifaceName, false);
858     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
859 
860     configs.clear();
861     ifaceName = "eth1";
862     ret = NetsysController::GetInstance().NetDiagSetInterfaceActiveState(ifaceName, false);
863     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
864 }
865 
866 HWTEST_F(NetsysControllerTest, NetDiagUpdateInterfaceConfig001, TestSize.Level1)
867 {
868     std::string ifaceName = "eth0";
869     OHOS::NetsysNative::NetDiagIfaceConfig config;
870     config.ifaceName_ = ifaceName;
871     config.ipv4Addr_ = "192.168.222.234";
872     config.ipv4Mask_ = "255.255.255.0";
873     config.ipv4Bcast_ = "255.255.255.0";
874     bool add = true;
875     auto ret = NetsysController::GetInstance().NetDiagUpdateInterfaceConfig(config, ifaceName, add);
876     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
877 
878     ifaceName = "eth1";
879     add = false;
880     ret = NetsysController::GetInstance().NetDiagUpdateInterfaceConfig(config, ifaceName, add);
881     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
882 }
883 
884 HWTEST_F(NetsysControllerTest, NetsysControllerErr007, TestSize.Level1)
885 {
886     std::string ipAddr = "192.168.1.100";
887     std::string macAddr = "aa:bb:cc:dd:ee:ff";
888     std::string ifName = "wlan0";
889 
890     auto ret = instance_->AddStaticArp(ipAddr, macAddr, ifName);
891     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
892 
893     ret = instance_->DelStaticArp(ipAddr, macAddr, ifName);
894     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
895 
896     ret = instance_->NetworkCreatePhysical(NET_ID, PERMISSION);
897     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
898 
899     std::string cmd = "";
900     std::string respond = "";
901     ret = instance_->SetIptablesCommandForRes(cmd, respond);
902     EXPECT_EQ(ret, NetManagerStandard::ERR_INVALID_DATA);
903 
904     OHOS::NetsysNative::NetDiagPingOption pingOption = {};
905     ret = instance_->NetDiagPingHost(pingOption, netDiagCallback);
906     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
907 
908     std::list<OHOS::NetsysNative::NetDiagRouteTable> diagrouteTable;
909     ret = instance_->NetDiagGetRouteTable(diagrouteTable);
910     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
911 
912     OHOS::NetsysNative::NetDiagProtocolType socketType = OHOS::NetsysNative::NetDiagProtocolType::PROTOCOL_TYPE_ALL;
913     OHOS::NetsysNative::NetDiagSocketsInfo socketsInfo = {};
914     ret = instance_->NetDiagGetSocketsInfo(socketType, socketsInfo);
915     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
916 
917     std::list<OHOS::NetsysNative::NetDiagIfaceConfig> configs;
918     std::string ifaceName = "eth0";
919     ret = instance_->NetDiagGetInterfaceConfig(configs, ifaceName);
920     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
921 
922     OHOS::NetsysNative::NetDiagIfaceConfig config;
923     ret = instance_->NetDiagUpdateInterfaceConfig(config, ifaceName, false);
924     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
925 
926     ret = instance_->NetDiagSetInterfaceActiveState(ifaceName, false);
927     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
928 }
929 
930 HWTEST_F(NetsysControllerTest, NetsysControllerBranchTest001, TestSize.Level1)
931 {
932     instance_->initFlag_ = true;
933     instance_->Init();
934 
935     instance_->initFlag_ = false;
936     instance_->Init();
937 
938     std::vector<int32_t> beginUids = {1};
939     std::vector<int32_t> endUids = {1};
940     int32_t netId = 0;
941 
942     NetsysController::GetInstance().NetworkCreateVirtual(netId, false);
943 
944     auto ret = instance_->NetworkAddUids(netId, beginUids, endUids);
945     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
946 
947     ret = instance_->NetworkDelUids(netId, beginUids, endUids);
948     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
949 
950     endUids = {1, 2};
951     ret = instance_->NetworkAddUids(netId, beginUids, endUids);
952     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL);
953 
954     ret = instance_->NetworkDelUids(netId, beginUids, endUids);
955     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL);
956 }
957 
958 HWTEST_F(NetsysControllerTest, NetsysControllerBranchTest002, TestSize.Level1)
959 {
960     uint32_t uid = 0;
961     uint8_t allow = 0;
962     auto ret = NetsysController::GetInstance().SetInternetPermission(uid, allow);
963     EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
964 
965     std::string ipAddr = "192.168.1.100";
966     std::string macAddr = "aa:bb:cc:dd:ee:ff";
967     std::string ifName = "wlan0";
968     ret = NetsysController::GetInstance().AddStaticArp(ipAddr, macAddr, ifName);
969     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
970 
971     ret = NetsysController::GetInstance().DelStaticArp(ipAddr, macAddr, ifName);
972     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
973 
974     NetsysNotifyCallback callback;
975     ret = NetsysController::GetInstance().RegisterNetsysNotifyCallback(callback);
976     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
977 
978     int32_t netId = 0;
979     int32_t permission = 0;
980     ret = NetsysController::GetInstance().NetworkCreatePhysical(netId, permission);
981     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
982 
983     ret = NetsysController::GetInstance().NetworkCreateVirtual(netId, false);
984     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
985 }
986 
987 HWTEST_F(NetsysControllerTest, GetCookieStatsTest001, TestSize.Level1)
988 {
989     uint64_t stats = 0;
990     BpfMapper<socket_cookie_stats_key, app_cookie_stats_value> appCookieStatsMap(APP_COOKIE_STATS_MAP_PATH, BPF_ANY);
991     int32_t ret = NetsysController::GetInstance().GetCookieStats(stats, TEST_STATS_TYPE1, TEST_COOKIE);
992     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL);
993 
994     ret = NetsysController::GetInstance().GetCookieStats(stats, TEST_STATS_TYPE2, TEST_COOKIE);
995     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL);
996 }
997 
998 HWTEST_F(NetsysControllerTest, GetNetworkSharingTypeTest001, TestSize.Level1)
999 {
1000     std::set<uint32_t> sharingTypeIsOn;
1001     int32_t ret = NetsysController::GetInstance().GetNetworkSharingType(sharingTypeIsOn);
1002     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
1003 }
1004 
1005 HWTEST_F(NetsysControllerTest, UpdateNetworkSharingTypeTest001, TestSize.Level1)
1006 {
1007     uint64_t type = 0;
1008     bool isOpen = true;
1009     int32_t ret = NetsysController::GetInstance().UpdateNetworkSharingType(type, isOpen);
1010     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
1011 }
1012 
1013 HWTEST_F(NetsysControllerTest, NetsysControllerBranchTest003, TestSize.Level1)
1014 {
1015     uint32_t timeStep = 0;
1016     sptr<OHOS::NetManagerStandard::NetsysDnsReportCallback> callback = nullptr;
1017     int32_t ret = NetsysController::GetInstance().RegisterDnsResultCallback(callback, timeStep);
1018     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
1019 
1020     ret = NetsysController::GetInstance().UnregisterDnsResultCallback(callback);
1021     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
1022 
1023     sptr<OHOS::NetsysNative::INetDnsHealthCallback> healthCallback = nullptr;
1024     ret = NetsysController::GetInstance().RegisterDnsHealthCallback(healthCallback);
1025     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
1026 
1027     ret = NetsysController::GetInstance().UnregisterDnsHealthCallback(healthCallback);
1028     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
1029 }
1030 
1031 HWTEST_F(NetsysControllerTest, SetEnableIpv6Test001, TestSize.Level1)
1032 {
1033     uint32_t on = 0;
1034     std::string interface = "wlan0";
1035     int32_t ret = NetsysController::GetInstance().SetIpv6PrivacyExtensions(interface, on);
1036     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
1037     ret = NetsysController::GetInstance().SetEnableIpv6(interface, on);
1038     EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
1039 }
1040 
1041 HWTEST_F(NetsysControllerTest, NetsysControllerBranchTest004, TestSize.Level1)
1042 {
1043     NetsysController::GetInstance().netsysService_ = nullptr;
1044     uint32_t timeStep = 0;
1045     sptr<OHOS::NetManagerStandard::NetsysDnsReportCallback> callback = nullptr;
1046     int32_t ret = NetsysController::GetInstance().RegisterDnsResultCallback(callback, timeStep);
1047     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
1048 
1049     ret = NetsysController::GetInstance().UnregisterDnsResultCallback(callback);
1050     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
1051 
1052     sptr<OHOS::NetsysNative::INetDnsHealthCallback> healthCallback = nullptr;
1053     ret = NetsysController::GetInstance().RegisterDnsHealthCallback(healthCallback);
1054     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
1055 
1056     ret = NetsysController::GetInstance().UnregisterDnsHealthCallback(healthCallback);
1057     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
1058 
1059     uint64_t stats = 0;
1060     ret = NetsysController::GetInstance().GetCookieStats(stats, TEST_STATS_TYPE1, TEST_COOKIE);
1061     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
1062 }
1063 
1064 HWTEST_F(NetsysControllerTest, SetIpv6PrivacyExtensionsTest001, TestSize.Level1)
1065 {
1066     uint32_t on = 0;
1067     std::string interface = "wlan0";
1068     int32_t ret = NetsysController::GetInstance().SetIpv6PrivacyExtensions(interface, on);
1069     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
1070     ret = NetsysController::GetInstance().SetEnableIpv6(interface, on);
1071     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
1072 }
1073 
1074 HWTEST_F(NetsysControllerTest, SetNetworkAccessPolicy001, TestSize.Level1)
1075 {
1076     uint32_t uid = 0;
1077     NetworkAccessPolicy netAccessPolicy;
1078     netAccessPolicy.wifiAllow = false;
1079     netAccessPolicy.cellularAllow = false;
1080     bool reconfirmFlag = true;
1081     bool isBroker = false;
1082     int32_t ret = NetsysController::GetInstance().SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag, isBroker);
1083     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
1084 }
1085 
1086 HWTEST_F(NetsysControllerTest, NotifyNetBearerTypeChange001, TestSize.Level1)
1087 {
1088     std::set<NetManagerStandard::NetBearType> bearTypes;
1089     bearTypes.insert(NetManagerStandard::NetBearType::BEARER_CELLULAR);
1090     int32_t ret = NetsysController::GetInstance().NotifyNetBearerTypeChange(bearTypes);
1091     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
1092 }
1093 
1094 HWTEST_F(NetsysControllerTest, DeleteNetworkAccessPolicy001, TestSize.Level1)
1095 {
1096     uint32_t uid = 0;
1097     int32_t ret = NetsysController::GetInstance().DeleteNetworkAccessPolicy(uid);
1098     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
1099 }
1100 
1101 HWTEST_F(NetsysControllerTest, CreateVnic001, TestSize.Level1)
1102 {
1103     uint16_t mtu = 1500;
1104     std::string tunAddr = "192.168.1.100";
1105     int32_t prefix = 24;
1106     std::set<int32_t> uids;
1107     int32_t ret = NetsysController::GetInstance().CreateVnic(mtu, tunAddr, prefix, uids);
1108     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
1109 }
1110 
1111 HWTEST_F(NetsysControllerTest, DestroyVnic001, TestSize.Level1)
1112 {
1113     int32_t ret = NetsysController::GetInstance().DestroyVnic();
1114     EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL);
1115 }
1116 } // namespace NetManagerStandard
1117 } // namespace OHOS
1118