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