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 <gtest/gtest.h>
17
18 #ifdef GTEST_API_
19 #define private public
20 #endif
21 #include "bpf_def.h"
22 #include "bpf_mapper.h"
23 #include "bpf_path.h"
24 #include "net_manager_constants.h"
25 #include "net_stats_constants.h"
26 #include "netsys_native_client.h"
27
28 namespace OHOS {
29 namespace NetManagerStandard {
30 namespace {
31 using namespace testing::ext;
32 static constexpr const char *DESTINATION = "192.168.1.3/24";
33 static constexpr const char *NEXT_HOP = "192.168.1.1";
34 static constexpr const char *LOCALIP = "127.0.0.1";
35 static constexpr const char *IF_NAME = "iface0";
36 static constexpr const char *ETH0 = "eth0";
37 static constexpr const char *IFACE = "test0";
38 static constexpr const char *IP_ADDR = "172.17.5.245";
39 static constexpr const char *INTERFACE_NAME = "interface_name";
40 static constexpr const char *REQUESTOR = "requestor";
41 static constexpr const char *TCP_BUFFER_SIZES = "524288,1048576,2097152,262144,524288,1048576";
42 static constexpr uint64_t TEST_COOKIE = 1;
43 static constexpr uint32_t TEST_STATS_TYPE1 = 0;
44 static constexpr uint32_t TEST_STATS_TYPE2 = 2;
45 static constexpr uint32_t TEST_UID = 1;
46 const int32_t MTU = 111;
47 const int32_t NET_ID = 2;
48 const int32_t IFACEFD = 5;
49 const int64_t UID = 1010;
50 const int32_t APP_ID = 101010;
51 const int32_t SOCKET_FD = 5;
52 const int32_t PERMISSION = 5;
53 const int32_t STATRUID = 1000;
54 const int32_t ENDUID = 1100;
55 const int32_t PREFIX_LENGTH = 23;
56 const int32_t INVALID_ARGUMENTS = -22;
57 uint16_t BASE_TIMEOUT_MSEC = 200;
58 const int64_t CHAIN = 1010;
59 uint8_t RETRY_COUNT = 3;
60 const uint32_t FIREWALL_RULE = 1;
61 } // namespace
62
63 class NetsysNativeClientTest : public testing::Test {
64 public:
65 static void SetUpTestCase();
66
67 static void TearDownTestCase();
68
69 void SetUp();
70
71 void TearDown();
72 static inline std::shared_ptr<NetsysNativeClient> nativeClientInstance_ = std::make_shared<NetsysNativeClient>();
73 static inline NetsysNativeClient &nativeClient_ = *nativeClientInstance_;
74 };
75
SetUpTestCase()76 void NetsysNativeClientTest::SetUpTestCase() {}
77
TearDownTestCase()78 void NetsysNativeClientTest::TearDownTestCase() {}
79
SetUp()80 void NetsysNativeClientTest::SetUp() {}
81
TearDown()82 void NetsysNativeClientTest::TearDown() {}
83
84 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest001, TestSize.Level1)
85 {
86 int32_t ret = nativeClient_.NetworkCreatePhysical(NET_ID, PERMISSION);
87 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
88
89 ret = nativeClient_.NetworkCreatePhysical(NET_ID, PERMISSION);
90 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
91
92 ret = nativeClient_.NetworkDestroy(NET_ID);
93 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
94
95 ret = nativeClient_.NetworkAddInterface(NET_ID, IF_NAME, BEARER_DEFAULT);
96 EXPECT_EQ(ret, -1);
97
98 ret = nativeClient_.NetworkRemoveInterface(NET_ID, IF_NAME);
99 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
100
101 ret = nativeClient_.NetworkAddRoute(NET_ID, IF_NAME, DESTINATION, NEXT_HOP, false);
102 EXPECT_EQ(ret, INVALID_ARGUMENTS);
103
104 ret = nativeClient_.NetworkRemoveRoute(NET_ID, IF_NAME, DESTINATION, NEXT_HOP);
105 EXPECT_EQ(ret, INVALID_ARGUMENTS);
106
107 OHOS::nmd::InterfaceConfigurationParcel parcel;
108 ret = nativeClient_.GetInterfaceConfig(parcel);
109 EXPECT_EQ(ret, 0);
110
111 ret = nativeClient_.SetInterfaceDown(IF_NAME);
112 EXPECT_EQ(ret, 0);
113
114 ret = nativeClient_.SetInterfaceUp(IF_NAME);
115 EXPECT_EQ(ret, 0);
116
117 nativeClient_.ClearInterfaceAddrs(IF_NAME);
118
119 ret = nativeClient_.GetInterfaceMtu(IF_NAME);
120 EXPECT_EQ(ret, -1);
121
122 ret = nativeClient_.SetInterfaceMtu(IF_NAME, MTU);
123 EXPECT_EQ(ret, -1);
124
125 ret = nativeClient_.SetTcpBufferSizes(TCP_BUFFER_SIZES);
126 EXPECT_EQ(ret, 0);
127 }
128
129 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest002, TestSize.Level1)
130 {
131 int32_t ret = nativeClient_.AddInterfaceAddress(IF_NAME, IP_ADDR, PREFIX_LENGTH);
132 EXPECT_EQ(ret, -19);
133
134 ret = nativeClient_.DelInterfaceAddress(IF_NAME, IP_ADDR, PREFIX_LENGTH);
135 EXPECT_EQ(ret, -19);
136
137 ret = nativeClient_.SetResolverConfig(NET_ID, BASE_TIMEOUT_MSEC, RETRY_COUNT, {}, {});
138 EXPECT_EQ(ret, 0);
139
140 std::vector<std::string> servers;
141 std::vector<std::string> domains;
142 ret = nativeClient_.GetResolverConfig(NET_ID, servers, domains, BASE_TIMEOUT_MSEC, RETRY_COUNT);
143 EXPECT_EQ(ret, 0);
144
145 ret = nativeClient_.CreateNetworkCache(NET_ID);
146 EXPECT_EQ(ret, 0);
147
148 ret = nativeClient_.DestroyNetworkCache(NET_ID);
149 EXPECT_EQ(ret, 0);
150
151 nmd::NetworkSharingTraffic traffic;
152 ret = nativeClient_.GetNetworkSharingTraffic(ETH0, ETH0, traffic);
153 EXPECT_NE(ret, 0);
154
155 ret = nativeClient_.GetCellularRxBytes();
156 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
157
158 ret = nativeClient_.GetCellularTxBytes();
159 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
160
161 ret = nativeClient_.GetAllRxBytes();
162 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
163
164 ret = nativeClient_.GetAllTxBytes();
165 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
166 }
167
168 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest003, TestSize.Level1)
169 {
170 int32_t ret = nativeClient_.GetUidRxBytes(NET_ID);
171 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
172
173 ret = nativeClient_.GetUidTxBytes(NET_ID);
174 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
175
176 ret = nativeClient_.GetUidOnIfaceRxBytes(NET_ID, INTERFACE_NAME);
177 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
178
179 ret = nativeClient_.GetUidOnIfaceTxBytes(NET_ID, INTERFACE_NAME);
180 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
181
182 ret = nativeClient_.GetIfaceRxBytes(INTERFACE_NAME);
183 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
184
185 ret = nativeClient_.GetIfaceTxBytes(INTERFACE_NAME);
186 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
187
188 std::vector<std::string> interFaceGetList = nativeClient_.InterfaceGetList();
189 EXPECT_NE(interFaceGetList.size(), 0U);
190
191 std::vector<std::string> uidGetList = nativeClient_.UidGetList();
192 EXPECT_EQ(uidGetList.size(), 0U);
193
194 ret = nativeClient_.GetIfaceRxPackets(INTERFACE_NAME);
195 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
196
197 ret = nativeClient_.GetIfaceTxPackets(INTERFACE_NAME);
198 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
199
200 std::vector<uint32_t> uids;
201 uids.push_back(UID);
202 ret = nativeClient_.FirewallSetUidsAllowedListChain(CHAIN, uids);
203 EXPECT_EQ(ret, -1);
204 ret = nativeClient_.FirewallSetUidsDeniedListChain(CHAIN, uids);
205 EXPECT_EQ(ret, -1);
206 }
207
208 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest004, TestSize.Level1)
209 {
210 int32_t ret = nativeClient_.SetDefaultNetWork(NET_ID);
211 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
212
213 ret = nativeClient_.ClearDefaultNetWorkNetId();
214 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
215
216 ret = nativeClient_.BindSocket(SOCKET_FD, NET_ID);
217 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
218
219 ret = nativeClient_.IpEnableForwarding(REQUESTOR);
220 EXPECT_EQ(ret, 0);
221
222 ret = nativeClient_.IpDisableForwarding(REQUESTOR);
223 EXPECT_EQ(ret, 0);
224
225 ret = nativeClient_.EnableNat(ETH0, ETH0);
226 EXPECT_EQ(ret, -1);
227
228 ret = nativeClient_.DisableNat(ETH0, ETH0);
229 EXPECT_EQ(ret, -1);
230
231 ret = nativeClient_.IpfwdAddInterfaceForward(ETH0, ETH0);
232 EXPECT_EQ(ret, -1);
233
234 ret = nativeClient_.IpfwdRemoveInterfaceForward(ETH0, ETH0);
235 EXPECT_EQ(ret, -1);
236
237 ret = nativeClient_.ShareDnsSet(NET_ID);
238 EXPECT_EQ(ret, 0);
239
240 ret = nativeClient_.StartDnsProxyListen();
241 EXPECT_EQ(ret, 0);
242
243 ret = nativeClient_.StopDnsProxyListen();
244 EXPECT_EQ(ret, 0);
245
246 ret = nativeClient_.FirewallEnableChain(CHAIN, true);
247 EXPECT_EQ(ret, -1);
248 ret = nativeClient_.FirewallSetUidRule(CHAIN, {NET_ID}, FIREWALL_RULE);
249 EXPECT_EQ(ret, 0);
250 }
251
252 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest005, TestSize.Level1)
253 {
254 uint64_t stats = 0;
255 int32_t ret = nativeClient_.GetTotalStats(stats, 0);
256 EXPECT_EQ(ret, 0);
257
258 ret = nativeClient_.GetUidStats(stats, 0, APP_ID);
259 EXPECT_EQ(ret, NetStatsResultCode::STATS_ERR_READ_BPF_FAIL);
260
261 ret = nativeClient_.GetIfaceStats(stats, 0, IFACE);
262 EXPECT_EQ(ret, NetStatsResultCode::STATS_ERR_GET_IFACE_NAME_FAILED);
263
264 std::vector<OHOS::NetManagerStandard::NetStatsInfo> statsInfo;
265 ret = nativeClient_.GetAllStatsInfo(statsInfo);
266 EXPECT_EQ(ret, 0);
267
268 ret = nativeClient_.GetAllSimStatsInfo(statsInfo);
269 EXPECT_EQ(ret, 0);
270 }
271
272 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest006, TestSize.Level1)
273 {
274 std::vector<UidRange> uidRanges;
275 std::vector<int32_t> beginUids;
276 std::vector<int32_t> endUids;
277 beginUids.push_back(STATRUID);
278 endUids.push_back(ENDUID);
279 for (size_t i = 0; i < beginUids.size(); i++) {
280 uidRanges.emplace_back(UidRange(beginUids[i], endUids[i]));
281 }
282 nativeClient_.NetworkAddUids(NET_ID, uidRanges);
283 nativeClient_.NetworkDelUids(NET_ID, uidRanges);
284 int32_t ret = nativeClient_.NetworkCreatePhysical(NET_ID, PERMISSION);
285 EXPECT_EQ(ret, 0);
286 }
287
288 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest007, TestSize.Level1)
289 {
290 NetsysNotifyCallback callback;
291 struct ifreq ifreq = {};
292 int32_t ret = nativeClient_.RegisterNetsysNotifyCallback(callback);
293 EXPECT_EQ(ret, 0);
294 ret = nativeClient_.BindNetworkServiceVpn(SOCKET_FD);
295 int32_t ifacefd1 = 0;
296 nativeClient_.EnableVirtualNetIfaceCard(SOCKET_FD, ifreq, ifacefd1);
297 int32_t sockfd = socket(AF_INET, SOCK_STREAM, 0);
298 ret = nativeClient_.BindNetworkServiceVpn(sockfd);
299 int32_t ifacefd2 = 0;
300 nativeClient_.EnableVirtualNetIfaceCard(sockfd, ifreq, ifacefd2);
301 EXPECT_EQ(ret, 0);
302 }
303
304 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest008, TestSize.Level1)
305 {
306 int32_t ret = nativeClient_.SetBlocking(IFACEFD, true);
307 EXPECT_EQ(ret, NETSYS_ERR_VPN);
308 struct ifreq ifreq = {};
309 int32_t sockfd = socket(AF_INET, SOCK_STREAM, 0);
310 ret = nativeClient_.SetIpAddress(sockfd, LOCALIP, PREFIX_LENGTH, ifreq);
311 EXPECT_EQ(ret, NETSYS_ERR_VPN);
312 }
313
314 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest009, TestSize.Level1)
315 {
316 NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClientInstance_);
317 std::string ifName = "wlan";
318 bool up = true;
319 int32_t ret = notifyCallback.OnInterfaceChanged(ifName, up);
320 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
321 }
322
323 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest010, TestSize.Level1)
324 {
325 NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClientInstance_);
326 sptr<OHOS::NetsysNative::DhcpResultParcel> dhcpResult = new (std::nothrow) OHOS::NetsysNative::DhcpResultParcel();
327 int32_t ret = notifyCallback.OnDhcpSuccess(dhcpResult);
328 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
329 }
330
331 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest011, TestSize.Level1)
332 {
333 NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClientInstance_);
334 std::string limitName = "wlan";
335 std::string iface = "vpncard";
336 int32_t ret = notifyCallback.OnBandwidthReachedLimit(limitName, iface);
337 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
338 }
339
340 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest013, TestSize.Level1)
341 {
342 wptr<IRemoteObject> remote = nullptr;
343 nativeClient_.OnRemoteDied(remote);
344 int handle = 1;
345 sptr<IRemoteObject> result = nullptr;
346 std::u16string descriptor = std::u16string();
347 result = new (std::nothrow) IPCObjectProxy(handle, descriptor);
348 IRemoteObject *object = result.GetRefPtr();
349 remote = object;
350 nativeClient_.OnRemoteDied(remote);
351 uint32_t uid = 0;
352 uint8_t allow = 0;
353 auto ret = nativeClient_.SetInternetPermission(uid, allow);
354 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR);
355 }
356
357 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest014, TestSize.Level1)
358 {
359 std::string ipAddr = "192.168.1.100";
360 std::string macAddr = "aa:bb:cc:dd:ee:ff";
361 std::string ifName = "wlan0";
362 auto ret = nativeClient_.AddStaticArp(ipAddr, macAddr, ifName);
363 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
364
365 ret = nativeClient_.DelStaticArp(ipAddr, macAddr, ifName);
366 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
367 }
368
369 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest016, TestSize.Level1)
370 {
371 std::string ipAddr = "2001:0db8:85a3:0000:0000:8a2e:0370:7334";
372 std::string macAddr = "aa:bb:cc:dd:ee:ff";
373 std::string ifName = "chba0";
374 auto ret = nativeClient_.AddStaticIpv6Addr(ipAddr, macAddr, ifName);
375 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
376
377 ret = nativeClient_.DelStaticIpv6Addr(ipAddr, macAddr, ifName);
378 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
379 }
380
381 HWTEST_F(NetsysNativeClientTest, GetCookieStatsTest001, TestSize.Level1)
382 {
383 uint64_t stats = 0;
384 BpfMapper<socket_cookie_stats_key, app_cookie_stats_value> appCookieStatsMap(APP_COOKIE_STATS_MAP_PATH, BPF_ANY);
385 int32_t ret = nativeClient_.GetCookieStats(stats, TEST_STATS_TYPE1, TEST_COOKIE);
386 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL);
387 ret = nativeClient_.GetCookieStats(stats, TEST_STATS_TYPE2, TEST_COOKIE);
388 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL);
389 }
390
391 HWTEST_F(NetsysNativeClientTest, GetNetworkSharingTypeTest001, TestSize.Level1)
392 {
393 std::set<uint32_t> sharingTypeIsOn;
394 int32_t ret = nativeClient_.GetNetworkSharingType(sharingTypeIsOn);
395 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
396 }
397
398 HWTEST_F(NetsysNativeClientTest, UpdateNetworkSharingTypeTest001, TestSize.Level1)
399 {
400 uint64_t type = 0;
401 bool isOpen = true;
402 int32_t ret = nativeClient_.UpdateNetworkSharingType(type, isOpen);
403 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
404 }
405
406 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientBranchTest001, TestSize.Level1)
407 {
408 uint32_t timeStep = 0;
409 sptr<OHOS::NetManagerStandard::NetsysDnsReportCallback> callback = nullptr;
410 int32_t ret = nativeClient_.RegisterDnsResultCallback(callback, timeStep);
411 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
412 ret = nativeClient_.UnregisterDnsResultCallback(callback);
413 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
414
415 sptr<OHOS::NetsysNative::INetDnsHealthCallback> healthCallback = nullptr;
416 ret = nativeClient_.RegisterDnsHealthCallback(healthCallback);
417 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
418 ret = nativeClient_.UnregisterDnsHealthCallback(healthCallback);
419 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
420
421 sptr<OHOS::NetManagerStandard::NetsysDnsQueryReportCallback> queryCallback = nullptr;
422 ret = nativeClient_.RegisterDnsQueryResultCallback(queryCallback);
423 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
424
425 ret = nativeClient_.UnregisterDnsQueryResultCallback(queryCallback);
426 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
427 }
428
429 HWTEST_F(NetsysNativeClientTest, SetIpv6PrivacyExtensionsTest001, TestSize.Level1)
430 {
431 uint32_t on = 0;
432 std::string interface = "wlan0";
433 int32_t ret = nativeClient_.SetIpv6PrivacyExtensions(interface, on);
434 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
435 ret = nativeClient_.SetEnableIpv6(interface, on);
436 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
437 }
438
439 HWTEST_F(NetsysNativeClientTest, SetNetworkAccessPolicy001, TestSize.Level1)
440 {
441 uint32_t uid = 0;
442 NetworkAccessPolicy netAccessPolicy;
443 netAccessPolicy.wifiAllow = false;
444 netAccessPolicy.cellularAllow = false;
445 bool reconfirmFlag = true;
446 int32_t ret = nativeClient_.SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag);
447 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
448 }
449
450 HWTEST_F(NetsysNativeClientTest, NotifyNetBearerTypeChange001, TestSize.Level1)
451 {
452 std::set<NetManagerStandard::NetBearType> bearerTypes;
453 bearerTypes.insert(NetManagerStandard::NetBearType::BEARER_CELLULAR);
454 int32_t ret = nativeClient_.NotifyNetBearerTypeChange(bearerTypes);
455 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
456 }
457
458 HWTEST_F(NetsysNativeClientTest, DeleteNetworkAccessPolicy001, TestSize.Level1)
459 {
460 uint32_t uid = 0;
461 int32_t ret = nativeClient_.DeleteNetworkAccessPolicy(uid);
462 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
463 }
464
465 HWTEST_F(NetsysNativeClientTest, CloseSocketsUid001, TestSize.Level1)
466 {
467 std::string ipAddr = "";
468 uint32_t uid = 1000;
469 int32_t ret = nativeClient_.CloseSocketsUid(ipAddr, uid);
470 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
471 }
472
473 HWTEST_F(NetsysNativeClientTest, SetBrokerUidAccessPolicyMapTest001, TestSize.Level1)
474 {
475 std::unordered_map<uint32_t, uint32_t> params;
476 int32_t ret = nativeClient_.SetBrokerUidAccessPolicyMap(params);
477 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
478 }
479
480 HWTEST_F(NetsysNativeClientTest, SetBrokerUidAccessPolicyMapTest002, TestSize.Level1)
481 {
482 std::unordered_map<uint32_t, uint32_t> params;
483 params.emplace(TEST_UID, TEST_UID);
484 int32_t ret = nativeClient_.SetBrokerUidAccessPolicyMap(params);
485 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
486 }
487
488 HWTEST_F(NetsysNativeClientTest, DelBrokerUidAccessPolicyMapTest001, TestSize.Level1)
489 {
490 int32_t ret = nativeClient_.DelBrokerUidAccessPolicyMap(TEST_UID);
491 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
492 }
493
494 #ifdef FEATURE_WEARABLE_DISTRIBUTED_NET_ENABLE
495 HWTEST_F(NetsysNativeClientTest, DisableWearableDistributedNetForward, TestSize.Level1)
496 {
497 int32_t ret = nativeClient_.EnableWearableDistributedNetForward(8001, 8002);
498 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
499 ret = nativeClient_.DisableWearableDistributedNetForward();
500 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
501 }
502 #endif
503
504 HWTEST_F(NetsysNativeClientTest, EnableDistributedClientNet001, TestSize.Level1)
505 {
506 std::string virnicAddr = "1.189.55.61";
507 std::string iif = "lo";
508 int32_t ret = nativeClient_.EnableDistributedClientNet(virnicAddr, iif);
509 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
510
511 bool isServer = false;
512 ret = nativeClient_.DisableDistributedNet(isServer);
513 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
514 }
515
516 HWTEST_F(NetsysNativeClientTest, EnableDistributedServerNet001, TestSize.Level1)
517 {
518 std::string iif = "lo";
519 std::string devIface = "lo";
520 std::string dstAddr = "1.189.55.61";
521 int32_t ret = nativeClient_.EnableDistributedServerNet(iif, devIface, dstAddr);
522 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
523
524 bool isServer = true;
525 ret = nativeClient_.DisableDistributedNet(isServer);
526 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
527 }
528
529 HWTEST_F(NetsysNativeClientTest, GetNetworkCellularSharingTraffic001, TestSize.Level1)
530 {
531 nmd::NetworkSharingTraffic traffic;
532 std::string ifaceName = "virnic";
533
534 int32_t ret = nativeClient_.GetNetworkCellularSharingTraffic(traffic, ifaceName);
535 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
536 }
537
538 HWTEST_F(NetsysNativeClientTest, SetGetClearNetStateTrafficMap001, TestSize.Level1)
539 {
540 uint8_t flag = 1;
541 uint64_t availableTraffic = 1000000;
542
543 int32_t ret = nativeClient_.SetNetStateTrafficMap(flag, availableTraffic);
544 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
545 ret = nativeClient_.GetNetStateTrafficMap(flag, availableTraffic);
546 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
547 ret = nativeClient_.ClearIncreaseTrafficMap();
548 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
549 ret = nativeClient_.DeleteIncreaseTrafficMap(12); // 12:ifIndex
550 EXPECT_TRUE(ret == NetManagerStandard::NETMANAGER_SUCCESS || ret == NETMANAGER_ERROR);
551 }
552
553 HWTEST_F(NetsysNativeClientTest, UpdateIfIndexMap001, TestSize.Level1)
554 {
555 uint8_t key = 1;
556 uint64_t index = 10;
557 int32_t ret = nativeClient_.UpdateIfIndexMap(key, index);
558 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
559 }
560
561 HWTEST_F(NetsysNativeClientTest, RegisterNetsysTrafficCallback001, TestSize.Level1)
562 {
563 sptr<NetsysNative::INetsysTrafficCallback> callback = nullptr;
564 int32_t ret = nativeClient_.RegisterNetsysTrafficCallback(callback);
565 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
566 }
567
568 HWTEST_F(NetsysNativeClientTest, StartStopClat001, TestSize.Level1)
569 {
570 std::string interfaceName = "eth0";
571 int32_t netId = 1;
572 std::string nat64PrefixStr = "2001:db8::/64";
573
574 int32_t ret = nativeClient_.StartClat(interfaceName, netId, nat64PrefixStr);
575 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
576 ret = nativeClient_.StopClat(interfaceName);
577 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
578 }
579
580 HWTEST_F(NetsysNativeClientTest, SetNicTrafficAllowed001, TestSize.Level1)
581 {
582 std::vector<std::string> ifaceNames = {"eth0", "wlan0"};
583 bool status = true;
584
585 int32_t ret = nativeClient_.SetNicTrafficAllowed(ifaceNames, status);
586 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
587 }
588
589 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest015, TestSize.Level1)
590 {
591 std::unique_ptr<NetsysNativeClient> client = std::make_unique<NetsysNativeClient>();
592 EXPECT_EQ(client->netsysNativeService_, nullptr);
593 EXPECT_EQ(client->deathRecipient_, nullptr);
594 client.reset();
595 }
596
597 HWTEST_F(NetsysNativeClientTest, DelInterfaceAddressTest001, TestSize.Level1)
598 {
599 std::string netCapabilities = "";
600 auto ret = nativeClient_.DelInterfaceAddress(IF_NAME, IP_ADDR, PREFIX_LENGTH, netCapabilities);
601 EXPECT_EQ(ret, 0);
602 }
603
604 HWTEST_F(NetsysNativeClientTest, OnRemoteDiedTest001, TestSize.Level1)
605 {
606 wptr<IRemoteObject> remote = nullptr;
607 nativeClient_.OnRemoteDied(remote);
608 int handle = 1;
609 sptr<IRemoteObject> result = nullptr;
610 std::u16string descriptor = std::u16string();
611 result = new (std::nothrow) IPCObjectProxy(handle, descriptor);
612 IRemoteObject *object = result.GetRefPtr();
613 remote = object;
614 EXPECT_NE(nativeClient_.netsysNativeService_, nullptr);
615 nativeClient_.netsysNativeService_ = nullptr;
616 nativeClient_.OnRemoteDied(remote);
617 }
618
619 HWTEST_F(NetsysNativeClientTest, UnRegisterNetsysTrafficCallback001, TestSize.Level1)
620 {
621 sptr<NetsysNative::INetsysTrafficCallback> callback = nullptr;
622 int32_t ret = nativeClient_.UnRegisterNetsysTrafficCallback(callback);
623 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
624 }
625
626 HWTEST_F(NetsysNativeClientTest, FlushDnsCache001, TestSize.Level1)
627 {
628 uint16_t netId = NET_ID;
629 int32_t ret = nativeClient_.FlushDnsCache(netId);
630 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
631 }
632
633 HWTEST_F(NetsysNativeClientTest, FlushDnsCache002, TestSize.Level1)
634 {
635 uint16_t netId = 0;
636 int32_t ret = nativeClient_.FlushDnsCache(netId);
637 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
638 }
639
640 HWTEST_F(NetsysNativeClientTest, SetDnsCacheTest001, TestSize.Level1)
641 {
642 uint16_t netId = 101;
643 std::string testHost = "test";
644 AddrInfo info;
645 int32_t ret = nativeClient_.SetDnsCache(netId, testHost, info);
646 EXPECT_TRUE(ret == NetManagerStandard::NETMANAGER_SUCCESS || ret == 400);
647 }
648
649 HWTEST_F(NetsysNativeClientTest, OnDnsQueryResultReportTest001, TestSize.Level1)
650 {
651 NetsysNativeClient::NativeNetDnsResultCallback notifyCallback(nativeClientInstance_);
652 uint32_t size = 1;
653 OHOS::NetsysNative::NetDnsQueryResultReport netDnsResultReport{};
654 std::list<OHOS::NetsysNative::NetDnsQueryResultReport> res = {netDnsResultReport};
655 int32_t ret = notifyCallback.OnDnsQueryResultReport(size, res);
656 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
657 }
658
659 HWTEST_F(NetsysNativeClientTest, OnDnsQueryAbnormalReportTest001, TestSize.Level1)
660 {
661 NetsysNativeClient::NativeNetDnsResultCallback notifyCallback(nativeClientInstance_);
662 uint32_t eventfailcause = 1;
663 OHOS::NetsysNative::NetDnsQueryResultReport netDnsResultReport{};
664 int32_t ret = notifyCallback.OnDnsQueryAbnormalReport(eventfailcause, netDnsResultReport);
665 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
666 }
667
668 #ifdef FEATURE_ENTERPRISE_ROUTE_CUSTOM
669 HWTEST_F(NetsysNativeClientTest, UpdateEnterpriseRouteTest001, TestSize.Level1)
670 {
671 uint32_t uid = 20000138;
672 std::string ifname = "wlan0";
673 bool add = true;
674 auto ret = nativeClient_.UpdateEnterpriseRoute(ifname, uid, add);
675 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
676 }
677
678 HWTEST_F(NetsysNativeClientTest, UpdateEnterpriseRouteTest002, TestSize.Level1)
679 {
680 uint32_t uid = 0;
681 std::string ifname = "wlan0";
682 bool add = true;
683 auto ret = nativeClient_.UpdateEnterpriseRoute(ifname, uid, add);
684 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
685 }
686
687 HWTEST_F(NetsysNativeClientTest, UpdateEnterpriseRouteTest003, TestSize.Level1)
688 {
689 uint32_t uid = 20000138;
690 std::string ifname = "notexist";
691 bool add = true;
692 auto ret = nativeClient_.UpdateEnterpriseRoute(ifname, uid, add);
693 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_PARAMETER_ERROR);
694 }
695 #endif
696 } // namespace NetManagerStandard
697 } // namespace OHOS
698