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);
102 EXPECT_EQ(ret, INVALID_ARGUMENTS);
103
104 ret = nativeClient_.NetworkRemoveRoute(NET_ID, IF_NAME, DESTINATION, NEXT_HOP);
105 EXPECT_NE(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, GetCookieStatsTest001, TestSize.Level1)
370 {
371 uint64_t stats = 0;
372 BpfMapper<socket_cookie_stats_key, app_cookie_stats_value> appCookieStatsMap(APP_COOKIE_STATS_MAP_PATH, BPF_ANY);
373 int32_t ret = nativeClient_.GetCookieStats(stats, TEST_STATS_TYPE1, TEST_COOKIE);
374 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL);
375 ret = nativeClient_.GetCookieStats(stats, TEST_STATS_TYPE2, TEST_COOKIE);
376 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL);
377 }
378
379 HWTEST_F(NetsysNativeClientTest, GetNetworkSharingTypeTest001, TestSize.Level1)
380 {
381 std::set<uint32_t> sharingTypeIsOn;
382 int32_t ret = nativeClient_.GetNetworkSharingType(sharingTypeIsOn);
383 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
384 }
385
386 HWTEST_F(NetsysNativeClientTest, UpdateNetworkSharingTypeTest001, TestSize.Level1)
387 {
388 uint64_t type = 0;
389 bool isOpen = true;
390 int32_t ret = nativeClient_.UpdateNetworkSharingType(type, isOpen);
391 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
392 }
393
394 HWTEST_F(NetsysNativeClientTest, NetsysNativeClientBranchTest001, TestSize.Level1)
395 {
396 uint32_t timeStep = 0;
397 sptr<OHOS::NetManagerStandard::NetsysDnsReportCallback> callback = nullptr;
398 int32_t ret = nativeClient_.RegisterDnsResultCallback(callback, timeStep);
399 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
400 ret = nativeClient_.UnregisterDnsResultCallback(callback);
401 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
402
403 sptr<OHOS::NetsysNative::INetDnsHealthCallback> healthCallback = nullptr;
404 ret = nativeClient_.RegisterDnsHealthCallback(healthCallback);
405 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
406 ret = nativeClient_.UnregisterDnsHealthCallback(healthCallback);
407 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
408 }
409
410 HWTEST_F(NetsysNativeClientTest, SetIpv6PrivacyExtensionsTest001, TestSize.Level1)
411 {
412 uint32_t on = 0;
413 std::string interface = "wlan0";
414 int32_t ret = nativeClient_.SetIpv6PrivacyExtensions(interface, on);
415 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
416 ret = nativeClient_.SetEnableIpv6(interface, on);
417 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
418 }
419
420 HWTEST_F(NetsysNativeClientTest, SetNetworkAccessPolicy001, TestSize.Level1)
421 {
422 uint32_t uid = 0;
423 NetworkAccessPolicy netAccessPolicy;
424 netAccessPolicy.wifiAllow = false;
425 netAccessPolicy.cellularAllow = false;
426 bool reconfirmFlag = true;
427 int32_t ret = nativeClient_.SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag);
428 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
429 }
430
431 HWTEST_F(NetsysNativeClientTest, NotifyNetBearerTypeChange001, TestSize.Level1)
432 {
433 std::set<NetManagerStandard::NetBearType> bearerTypes;
434 bearerTypes.insert(NetManagerStandard::NetBearType::BEARER_CELLULAR);
435 int32_t ret = nativeClient_.NotifyNetBearerTypeChange(bearerTypes);
436 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
437 }
438
439 HWTEST_F(NetsysNativeClientTest, DeleteNetworkAccessPolicy001, TestSize.Level1)
440 {
441 uint32_t uid = 0;
442 int32_t ret = nativeClient_.DeleteNetworkAccessPolicy(uid);
443 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
444 }
445
446 HWTEST_F(NetsysNativeClientTest, CloseSocketsUid001, TestSize.Level1)
447 {
448 std::string ipAddr = "";
449 uint32_t uid = 1000;
450 int32_t ret = nativeClient_.CloseSocketsUid(ipAddr, uid);
451 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
452 }
453
454 HWTEST_F(NetsysNativeClientTest, SetBrokerUidAccessPolicyMapTest001, TestSize.Level1)
455 {
456 std::unordered_map<uint32_t, uint32_t> params;
457 int32_t ret = nativeClient_.SetBrokerUidAccessPolicyMap(params);
458 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
459 }
460
461 HWTEST_F(NetsysNativeClientTest, SetBrokerUidAccessPolicyMapTest002, TestSize.Level1)
462 {
463 std::unordered_map<uint32_t, uint32_t> params;
464 params.emplace(TEST_UID, TEST_UID);
465 int32_t ret = nativeClient_.SetBrokerUidAccessPolicyMap(params);
466 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
467 }
468
469 HWTEST_F(NetsysNativeClientTest, DelBrokerUidAccessPolicyMapTest001, TestSize.Level1)
470 {
471 int32_t ret = nativeClient_.DelBrokerUidAccessPolicyMap(TEST_UID);
472 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
473 }
474
475 #ifdef FEATURE_WEARABLE_DISTRIBUTED_NET_ENABLE
476 HWTEST_F(NetsysNativeClientTest, DisableWearableDistributedNetForward, TestSize.Level1)
477 {
478 int32_t ret = nativeClient_.EnableWearableDistributedNetForward(8001, 8002);
479 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
480 ret = nativeClient_.DisableWearableDistributedNetForward();
481 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
482 }
483 #endif
484
485 HWTEST_F(NetsysNativeClientTest, EnableDistributedClientNet001, TestSize.Level1)
486 {
487 std::string virnicAddr = "1.189.55.61";
488 std::string iif = "lo";
489 int32_t ret = nativeClient_.EnableDistributedClientNet(virnicAddr, iif);
490 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
491
492 bool isServer = false;
493 ret = nativeClient_.DisableDistributedNet(isServer);
494 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
495 }
496
497 HWTEST_F(NetsysNativeClientTest, EnableDistributedServerNet001, TestSize.Level1)
498 {
499 std::string iif = "lo";
500 std::string devIface = "lo";
501 std::string dstAddr = "1.189.55.61";
502 int32_t ret = nativeClient_.EnableDistributedServerNet(iif, devIface, dstAddr);
503 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
504
505 bool isServer = true;
506 ret = nativeClient_.DisableDistributedNet(isServer);
507 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
508 }
509
510 HWTEST_F(NetsysNativeClientTest, GetNetworkCellularSharingTraffic001, TestSize.Level1)
511 {
512 nmd::NetworkSharingTraffic traffic;
513 std::string ifaceName = "virnic";
514
515 int32_t ret = nativeClient_.GetNetworkCellularSharingTraffic(traffic, ifaceName);
516 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
517 }
518
519 HWTEST_F(NetsysNativeClientTest, SetGetClearNetStateTrafficMap001, TestSize.Level1)
520 {
521 uint8_t flag = 1;
522 uint64_t availableTraffic = 1000000;
523
524 int32_t ret = nativeClient_.SetNetStateTrafficMap(flag, availableTraffic);
525 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
526 ret = nativeClient_.GetNetStateTrafficMap(flag, availableTraffic);
527 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
528 ret = nativeClient_.ClearIncreaseTrafficMap();
529 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
530 }
531
532 HWTEST_F(NetsysNativeClientTest, UpdateIfIndexMap001, TestSize.Level1)
533 {
534 uint8_t key = 1;
535 uint64_t index = 10;
536 int32_t ret = nativeClient_.UpdateIfIndexMap(key, index);
537 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
538 }
539
540 HWTEST_F(NetsysNativeClientTest, RegisterNetsysTrafficCallback001, TestSize.Level1)
541 {
542 sptr<NetsysNative::INetsysTrafficCallback> callback = nullptr;
543 int32_t ret = nativeClient_.RegisterNetsysTrafficCallback(callback);
544 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL);
545 }
546
547 HWTEST_F(NetsysNativeClientTest, StartStopClat001, TestSize.Level1)
548 {
549 std::string interfaceName = "eth0";
550 int32_t netId = 1;
551 std::string nat64PrefixStr = "2001:db8::/64";
552
553 int32_t ret = nativeClient_.StartClat(interfaceName, netId, nat64PrefixStr);
554 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
555 ret = nativeClient_.StopClat(interfaceName);
556 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
557 }
558
559 HWTEST_F(NetsysNativeClientTest, SetNicTrafficAllowed001, TestSize.Level1)
560 {
561 std::vector<std::string> ifaceNames = {"eth0", "wlan0"};
562 bool status = true;
563
564 int32_t ret = nativeClient_.SetNicTrafficAllowed(ifaceNames, status);
565 EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS);
566 }
567 } // namespace NetManagerStandard
568 } // namespace OHOS
569