1 /*
2  * Copyright (c) 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 <arpa/inet.h>
17 #include <gtest/gtest.h>
18 #include <net/if.h>
19 #include <netinet/in.h>
20 #include <poll.h>
21 #include <sys/ioctl.h>
22 #include <sys/socket.h>
23 #include <thread>
24 #include <unistd.h>
25 #include <random>
26 #include <linux/if_tun.h>
27 
28 #include "iservice_registry.h"
29 #include "netmanager_ext_test_security.h"
30 #include "netmgr_ext_log_wrapper.h"
31 #include "system_ability_definition.h"
32 
33 #ifdef GTEST_API_
34 #define private public
35 #define protected public
36 #endif
37 #include "net_manager_constants.h"
38 
39 #include "i_netfirewall_service.h"
40 #include "netfirewall_client.h"
41 #include "netfirewall_common.h"
42 #include "netfirewall_proxy.h"
43 #include "netfirewall_service.h"
44 
45 namespace OHOS {
46 namespace NetManagerStandard {
47 namespace {
48 using namespace testing::ext;
49 int32_t g_rowId = 0;
50 constexpr int32_t MAX_TEST_CNT = 1;
51 constexpr int32_t MAX_USER_RULE = 1;
52 constexpr uint32_t APPID_TEST01 = 2034;
53 constexpr int32_t USER_ID1 = 100;
54 constexpr int32_t USER_ID2 = 101;
55 const uint16_t LOCAL_START_PORT = 10020;
56 const uint16_t LOCAL_END_PORT = 1003;
57 const uint16_t REMOTE_START_PORT = 1002;
58 const uint16_t REMOTE_END_PORT = 10030;
59 constexpr int32_t MAX_IPS = 1;
60 constexpr int32_t MAX_PORTS = 1;
61 constexpr int32_t MAX_DOMAINS = 1;
62 const int32_t MAX_RULE_DESCRITION_LEN = 256;
63 
GetIpList(const std::string & addressStart,uint8_t type,uint8_t family=FAMILY_IPV6)64 std::vector<NetFirewallIpParam> GetIpList(const std::string &addressStart, uint8_t type, uint8_t family = FAMILY_IPV6)
65 {
66     const uint8_t mask = 24;
67     const int32_t gap = 10;
68     const int32_t hexWidth = 4;
69     std::vector<NetFirewallIpParam> localParamList;
70     NetFirewallIpParam localParam;
71     localParam.family = family;
72     localParam.type = type;
73     std::string ip;
74     std::stringstream ss;
75     for (int32_t i = 0; i < MAX_IPS; i++) {
76         ss.str("");
77         ss.clear();
78         ss << addressStart;
79         if (family == FAMILY_IPV4) {
80             ss << (i * gap);
81             inet_pton(AF_INET, ss.str().c_str(), &localParam.ipv4.startIp);
82         } else {
83             ss << std::hex << std::setw(hexWidth) << std::setfill('0') << (i * gap);
84             inet_pton(AF_INET6, ss.str().c_str(), &localParam.ipv6.startIp);
85         }
86         if (type == MULTIPLE_IP) {
87             ss.str("");
88             ss.clear();
89             ss << addressStart;
90             if (family == FAMILY_IPV4) {
91                 ss << (i * gap);
92                 inet_pton(AF_INET, ss.str().c_str(), &localParam.ipv4.endIp);
93             } else {
94                 ss << std::hex << std::setw(hexWidth) << std::setfill('0') << (i * gap + gap);
95                 inet_pton(AF_INET6, ss.str().c_str(), &localParam.ipv6.endIp);
96             }
97         } else {
98             localParam.mask = mask;
99         }
100         localParamList.emplace_back(std::move(localParam));
101     }
102     return localParamList;
103 }
104 
GetPortList(const uint16_t startPort,const uint16_t endPort)105 std::vector<NetFirewallPortParam> GetPortList(const uint16_t startPort, const uint16_t endPort)
106 {
107     const int32_t offset = 20;
108     std::vector<NetFirewallPortParam> localPortParamList;
109     NetFirewallPortParam localPortParam;
110     localPortParam.startPort = startPort;
111     localPortParam.endPort = endPort;
112     for (int32_t i = 0; i < MAX_PORTS; i++) {
113         localPortParamList.emplace_back(std::move(localPortParam));
114         localPortParam.startPort += offset;
115         localPortParam.endPort += offset;
116     }
117     return localPortParamList;
118 }
119 
generateRandomString(int32_t length)120 std::string generateRandomString(int32_t length)
121 {
122     std::string charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
123     std::string result;
124     std::random_device rd;
125     std::mt19937 gen(rd());
126     std::uniform_int_distribution<> dis(0, charset.size() - 1);
127     for (int32_t i = 0; i < length; ++i) {
128         result += charset[dis(gen)];
129     }
130     return result;
131 }
132 
GetNetFirewallRuleSptr(NetFirewallRuleType ruleType=NetFirewallRuleType::RULE_IP,NetFirewallRuleDirection ruleDirection=NetFirewallRuleDirection::RULE_OUT,uint8_t type=SINGLE_IP)133 sptr<NetFirewallRule> GetNetFirewallRuleSptr(NetFirewallRuleType ruleType = NetFirewallRuleType::RULE_IP,
134     NetFirewallRuleDirection ruleDirection = NetFirewallRuleDirection::RULE_OUT, uint8_t type = SINGLE_IP)
135 {
136     sptr<NetFirewallRule> rule = (std::make_unique<NetFirewallRule>()).release();
137     if (!rule) {
138         return rule;
139     }
140     rule->ruleId = 1;
141     rule->userId = USER_ID1;
142     rule->ruleName = generateRandomString(MAX_RULE_NAME_LEN);
143     rule->ruleDescription = generateRandomString(MAX_RULE_DESCRITION_LEN);
144     rule->ruleDirection = ruleDirection;
145     rule->ruleAction = FirewallRuleAction::RULE_ALLOW;
146     rule->ruleType = ruleType;
147     rule->isEnabled = true;
148     rule->appUid = APPID_TEST01;
149     if (ruleType == NetFirewallRuleType::RULE_IP) {
150         if (ruleDirection == NetFirewallRuleDirection::RULE_OUT) {
151             rule->localIps = GetIpList("AA22:BB11:1122:CDEF:1111:AA99:8888:", type);
152         } else {
153             rule->remoteIps = GetIpList("AA22:BB11:1122:CDEF:2222:AA99:8888:", type);
154         }
155         rule->localPorts = GetPortList(LOCAL_START_PORT, LOCAL_END_PORT);
156         rule->remotePorts = GetPortList(REMOTE_START_PORT, REMOTE_END_PORT);
157     } else if (ruleType == NetFirewallRuleType::RULE_DOMAIN) {
158         std::vector<NetFirewallDomainParam> domainList;
159         NetFirewallDomainParam domain;
160         domain.isWildcard = false;
161         const std::string tmp = "www.openharmony.cn";
162         for (int32_t i = 0; i < MAX_DOMAINS; i++) {
163             domain.domain = tmp + std::to_string(i);
164             domainList.emplace_back(domain);
165         }
166         rule->domains = domainList;
167     } else {
168         rule->dns.primaryDns = "192.168.1.245";
169         rule->dns.standbyDns = "192.168.1.1";
170     }
171 
172     return rule;
173 }
174 
GetNetFirewallIpV4RuleSptr(NetFirewallRuleDirection ruleDirection=NetFirewallRuleDirection::RULE_OUT,uint8_t type=SINGLE_IP)175 sptr<NetFirewallRule> GetNetFirewallIpV4RuleSptr(
176     NetFirewallRuleDirection ruleDirection = NetFirewallRuleDirection::RULE_OUT, uint8_t type = SINGLE_IP)
177 {
178     sptr<NetFirewallRule> rule = (std::make_unique<NetFirewallRule>()).release();
179     if (!rule) {
180         return rule;
181     }
182     rule->ruleId = 1;
183     rule->userId = USER_ID1;
184     rule->ruleName = generateRandomString(MAX_RULE_NAME_LEN);
185     rule->ruleDescription = generateRandomString(MAX_RULE_DESCRITION_LEN);
186     rule->ruleDirection = ruleDirection;
187     rule->ruleAction = FirewallRuleAction::RULE_ALLOW;
188     rule->ruleType = NetFirewallRuleType::RULE_IP;
189     rule->isEnabled = true;
190     rule->appUid = APPID_TEST01;
191     if (ruleDirection == NetFirewallRuleDirection::RULE_OUT) {
192         rule->localIps = GetIpList("192.168.1.", type, FAMILY_IPV4);
193     } else {
194         rule->remoteIps = GetIpList("192.168.2.", type, FAMILY_IPV4);
195     }
196     rule->localPorts = GetPortList(LOCAL_START_PORT, LOCAL_START_PORT);
197     rule->remotePorts = GetPortList(REMOTE_START_PORT, REMOTE_START_PORT);
198 
199     return rule;
200 }
201 
202 uint64_t g_startTimeTest = 0;
203 uint64_t g_endTimeTest = 0;
204 } // namespace
205 
206 class NetFirewallClientTest : public testing::Test {
207 public:
208     static void SetUpTestCase();
209     static void TearDownTestCase();
210     void SetUp();
211     void TearDown();
212 
213     NetFirewallClient &netfirewallClient_ = NetFirewallClient::GetInstance();
214 };
215 
SetUpTestCase()216 void NetFirewallClientTest::SetUpTestCase() {}
217 
TearDownTestCase()218 void NetFirewallClientTest::TearDownTestCase() {}
219 
SetUp()220 void NetFirewallClientTest::SetUp() {}
221 
TearDown()222 void NetFirewallClientTest::TearDown() {}
223 
224 HWTEST_F(NetFirewallClientTest, SetNetFirewallPolicy, TestSize.Level1)
225 {
226     NetManagerExtAccessToken token;
227     int32_t userId = 100;
228     int32_t ret = -1;
229     sptr<NetFirewallPolicy> status = new (std::nothrow) NetFirewallPolicy();
230     g_startTimeTest = GetCurrentMilliseconds();
231     for (int32_t i = 0; i < MAX_TEST_CNT; i++) {
232         status->isOpen = true;
233         status->inAction = (FirewallRuleAction)(1);
234         status->outAction = FirewallRuleAction::RULE_ALLOW;
235         ret = netfirewallClient_.SetNetFirewallPolicy(userId, status);
236         std::cout << "SetNetFirewallPolicy " << i + 1 << " ret " << ret << std::endl;
237     }
238     g_endTimeTest = GetCurrentMilliseconds();
239     std::cout << "CALL_TEST SetNetFirewallPolicy user " << userId << " call " << MAX_TEST_CNT << ", use time : " <<
240         g_endTimeTest - g_startTimeTest << " ms" << std::endl;
241     EXPECT_EQ(ret, 0);
242 }
243 
244 HWTEST_F(NetFirewallClientTest, GetNetFirewallPolicy, TestSize.Level1)
245 {
246     NetManagerExtAccessToken token;
247     int32_t userId = 100;
248     int32_t ret = -1;
249     sptr<NetFirewallPolicy> status = new (std::nothrow) NetFirewallPolicy();
250     g_startTimeTest = GetCurrentMilliseconds();
251     for (int32_t i = 0; i < MAX_TEST_CNT; i++) {
252         ret = netfirewallClient_.GetNetFirewallPolicy(userId, status);
253         std::cout << "GetNetFirewallPolicy " << i + 1 << " ret " << ret << std::endl;
254     }
255     g_endTimeTest = GetCurrentMilliseconds();
256     std::cout << "CALL_TEST GetNetFirewallPolicy user " << userId << " call " << MAX_TEST_CNT << ", use time : " <<
257         g_endTimeTest - g_startTimeTest << " ms" << std::endl;
258     EXPECT_EQ(ret, 0);
259 }
260 
261 HWTEST_F(NetFirewallClientTest, AddNetFirewallRule001, TestSize.Level1)
262 {
263     NetManagerExtAccessToken token;
264     int32_t ruleId = 0;
265     int32_t ret = -1;
266     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr();
267     g_startTimeTest = GetCurrentMilliseconds();
268     for (int32_t i = 0; i < MAX_USER_RULE; i++) {
269         if (i >= FIREWALL_USER_MAX_RULE) {
270             rule->userId = USER_ID2;
271         }
272         uint64_t stime = GetCurrentMilliseconds();
273         ret = netfirewallClient_.AddNetFirewallRule(rule, ruleId);
274         std::cout << "AddNetFirewallRule IP " << i + 1 << " ruleId " << ruleId << ", use time : " <<
275             GetCurrentMilliseconds() - stime << " ms" << std::endl;
276         if (ret != FIREWALL_SUCCESS) {
277             EXPECT_EQ(ret, FIREWALL_SUCCESS);
278             break;
279         }
280     }
281     g_rowId = ruleId;
282     g_endTimeTest = GetCurrentMilliseconds();
283     std::cout << "CALL_TEST AddNetFirewallRule user " << rule->userId << " call " << MAX_USER_RULE << ", use time : " <<
284         g_endTimeTest - g_startTimeTest << " ms" << std::endl;
285     EXPECT_EQ(ret, FIREWALL_SUCCESS);
286 }
287 
288 HWTEST_F(NetFirewallClientTest, AddNetFirewallRule002, TestSize.Level1)
289 {
290     NetManagerExtAccessToken token;
291     int32_t ruleId = 0;
292     int32_t ret = -1;
293     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr(NetFirewallRuleType::RULE_DOMAIN);
294     g_startTimeTest = GetCurrentMilliseconds();
295     for (int32_t i = 0; i < MAX_USER_RULE; i++) {
296         uint64_t stime = GetCurrentMilliseconds();
297         ret = netfirewallClient_.AddNetFirewallRule(rule, ruleId);
298         std::cout << "AddNetFirewallRule DOMAIN " << i + 1 << " ruleId " << ruleId << ", use time : " <<
299             GetCurrentMilliseconds() - stime << " ms" << std::endl;
300     }
301     g_rowId = ruleId;
302     g_endTimeTest = GetCurrentMilliseconds();
303     std::cout << "CALL_TEST DOMAIN AddNetFirewallRule user " << rule->userId << " call " << MAX_USER_RULE <<
304         ", use time : " << g_endTimeTest - g_startTimeTest << " ms" << std::endl;
305     EXPECT_EQ(ret, FIREWALL_SUCCESS);
306 }
307 
308 HWTEST_F(NetFirewallClientTest, AddNetFirewallRule003, TestSize.Level1)
309 {
310     NetManagerExtAccessToken token;
311     int32_t ruleId = 0;
312     int32_t ret = -1;
313     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr(NetFirewallRuleType::RULE_DNS);
314     g_startTimeTest = GetCurrentMilliseconds();
315     for (int32_t i = 0; i < MAX_USER_RULE; i++) {
316         uint64_t stime = GetCurrentMilliseconds();
317         ret = netfirewallClient_.AddNetFirewallRule(rule, ruleId);
318         std::cout << "AddNetFirewallRule DSN " << i + 1 << " ruleId " << ruleId << ", use time : " <<
319             GetCurrentMilliseconds() - stime << " ms" << std::endl;
320     }
321     g_rowId = ruleId;
322     g_endTimeTest = GetCurrentMilliseconds();
323     std::cout << "CALL_TEST DNS AddNetFirewallRule user " << rule->userId << " call " << MAX_USER_RULE <<
324         ", use time : " << g_endTimeTest - g_startTimeTest << " ms" << std::endl;
325     EXPECT_EQ(ret, FIREWALL_SUCCESS);
326 }
327 
328 HWTEST_F(NetFirewallClientTest, AddNetFirewallRule004, TestSize.Level1)
329 {
330     NetManagerExtAccessToken token;
331     int32_t ruleId = 0;
332     int32_t ret = -1;
333     sptr<NetFirewallRule> rule = GetNetFirewallIpV4RuleSptr();
334     g_startTimeTest = GetCurrentMilliseconds();
335     for (int32_t i = 0; i < MAX_USER_RULE; i++) {
336         uint64_t stime = GetCurrentMilliseconds();
337         ret = netfirewallClient_.AddNetFirewallRule(rule, ruleId);
338         std::cout << "AddNetFirewallRule4 IP " << i + 1 << " ruleId " << ruleId << ", use time : " <<
339             GetCurrentMilliseconds() - stime << " ms" << std::endl;
340         if (ret != FIREWALL_SUCCESS) {
341             EXPECT_EQ(ret, FIREWALL_SUCCESS);
342             break;
343         }
344     }
345     g_rowId = ruleId;
346     g_endTimeTest = GetCurrentMilliseconds();
347     std::cout << "CALL_TEST AddNetFirewallRule4 user " << rule->userId << " call " << MAX_USER_RULE <<
348         ", use time : " << g_endTimeTest - g_startTimeTest << " ms" << std::endl;
349     EXPECT_EQ(ret, FIREWALL_SUCCESS);
350 }
351 
352 /**
353  * @tc.name: UpdateNetFirewallRule001
354  * @tc.desc: Test NetFirewallClientTest UpdateNetFirewallRule.
355  * @tc.type: FUNC
356  */
357 HWTEST_F(NetFirewallClientTest, UpdateNetFirewallRule001, TestSize.Level1)
358 {
359     NetManagerExtAccessToken token;
360     int32_t ret = -1;
361     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr();
362     rule->userId = 100;
363     rule->ruleId = g_rowId;
364     g_startTimeTest = GetCurrentMilliseconds();
365     for (int32_t i = 0; i < MAX_USER_RULE; i++) {
366         ret = netfirewallClient_.UpdateNetFirewallRule(rule);
367         std::cout << "UpdateNetFirewallRule " << i + 1 << " ret " << ret << std::endl;
368     }
369     g_endTimeTest = GetCurrentMilliseconds();
370     std::cout << "CALL_TEST UpdateNetFirewallRule user " << rule->userId << " call " << MAX_USER_RULE <<
371         ", use time : " << g_endTimeTest - g_startTimeTest << " ms" << std::endl;
372     EXPECT_EQ(ret, FIREWALL_SUCCESS);
373 }
374 
375 /**
376  * @tc.name: GetAllNetFirewallRule001
377  * @tc.desc: Test NetFirewallClientTest GetNetFirewallRules.
378  * @tc.type: FUNC
379  */
380 HWTEST_F(NetFirewallClientTest, GetAllNetFirewallRule001, TestSize.Level1)
381 {
382     NetManagerExtAccessToken token;
383     int32_t userId = 100;
384     int32_t ret = -1;
385     std::vector<NetFirewallRule> ruleList;
386     sptr<RequestParam> param = new (std::nothrow) RequestParam();
387     param->page = 0;
388     param->pageSize = 5;
389     param->orderType = NetFirewallOrderType::ORDER_ASC;
390     sptr<FirewallRulePage> info = new (std::nothrow) FirewallRulePage();
391     g_startTimeTest = GetCurrentMilliseconds();
392     for (int32_t i = 0; i < MAX_USER_RULE; i++) {
393         ret = netfirewallClient_.GetNetFirewallRules(userId, param, info);
394         std::cout << "GetAllNetFirewallRule " << i + 1 << " page=" << param->page << std::endl;
395         info->data.clear();
396         if (param->page >= info->totalPage) {
397             param->page = 0;
398         } else {
399             param->page += 1;
400         }
401     }
402     g_endTimeTest = GetCurrentMilliseconds();
403     std::cout << "CALL_TEST GetAllNetFirewallRule user " << userId << " call " << MAX_USER_RULE << ", use time : " <<
404         g_endTimeTest - g_startTimeTest << " ms" << std::endl;
405     EXPECT_EQ(ret, FIREWALL_SUCCESS);
406 }
407 
408 /**
409  * @tc.name: GetAllNetFirewallRule002
410  * @tc.desc: Test NetFirewallClientTest GetNetFirewallRules.
411  * @tc.type: FUNC
412  */
413 HWTEST_F(NetFirewallClientTest, GetAllNetFirewallRule002, TestSize.Level1)
414 {
415     int32_t userId = 102;
416     sptr<RequestParam> param = new (std::nothrow) RequestParam();
417     param->page = 0;
418     param->pageSize = 5;
419     param->orderType = NetFirewallOrderType::ORDER_DESC;
420     sptr<FirewallRulePage> info = new (std::nothrow) FirewallRulePage();
421     int32_t ret = netfirewallClient_.GetNetFirewallRules(userId, param, info);
422 
423     EXPECT_EQ(ret, FIREWALL_ERR_PERMISSION_DENIED);
424 }
425 
426 /**
427  * @tc.name: GetNetFirewallRule001
428  * @tc.desc: Test NetFirewallClientTest GetNetFirewallRule.
429  * @tc.type: FUNC
430  */
431 HWTEST_F(NetFirewallClientTest, GetNetFirewallRule001, TestSize.Level1)
432 {
433     NetManagerExtAccessToken token;
434     int32_t ruleId = 1;
435     int32_t userId = 100;
436     NetFirewallRuleManager::GetInstance().GetAllRuleConstraint(userId);
437     ruleId = NetFirewallRuleManager::GetInstance().allUserRule_;
438     int32_t ret = -1;
439     sptr<NetFirewallRule> rule = new (std::nothrow) NetFirewallRule();
440     rule->ruleId = ruleId;
441     g_startTimeTest = GetCurrentMilliseconds();
442     for (int32_t i = 0; i < MAX_USER_RULE; i++) {
443         ret = netfirewallClient_.GetNetFirewallRule(userId, ruleId, rule);
444         std::cout << "GetNetFirewallRule " << i + 1 << " ruleId " << rule->ruleId << std::endl;
445     }
446     g_endTimeTest = GetCurrentMilliseconds();
447     std::cout << "CALL_TEST GetNetFirewallRule user " << userId << " call " << MAX_USER_RULE << ", use time : " <<
448         g_endTimeTest - g_startTimeTest << " ms" << std::endl;
449     if (ruleId == 0) {
450         EXPECT_EQ(ret, FIREWALL_ERR_NO_RULE);
451     } else {
452         EXPECT_EQ(ret, FIREWALL_SUCCESS);
453     }
454 }
455 
456 /**
457  * @tc.name: GetInterceptRecords
458  * @tc.desc: Test NetFirewallClientTest GetInterceptRecords.
459  * @tc.type: FUNC
460  */
461 HWTEST_F(NetFirewallClientTest, GetInterceptRecord001, TestSize.Level1)
462 {
463     NetManagerExtAccessToken token;
464     int32_t userId = 100;
465     int32_t ret = -1;
466     sptr<RequestParam> param = new (std::nothrow) RequestParam();
467     param->page = 0;
468     param->pageSize = 5;
469     param->orderType = NetFirewallOrderType::ORDER_ASC;
470     sptr<InterceptRecordPage> info = new (std::nothrow) InterceptRecordPage();
471     g_startTimeTest = GetCurrentMilliseconds();
472     for (int32_t i = 0; i < MAX_USER_RULE; i++) {
473         ret = netfirewallClient_.GetInterceptRecords(userId, param, info);
474         std::cout << "GetInterceptRecord " << i + 1 << " page=" << param->page << std::endl;
475         info->data.clear();
476         if (param->page >= info->totalPage) {
477             param->page = 0;
478         } else {
479             param->page += 1;
480         }
481     }
482     g_endTimeTest = GetCurrentMilliseconds();
483     std::cout << "CALL_TEST GetInterceptRecord user " << userId << " call " << MAX_USER_RULE << ", use time : " <<
484         g_endTimeTest - g_startTimeTest << " ms" << std::endl;
485     EXPECT_EQ(ret, FIREWALL_SUCCESS);
486 }
487 
488 /**
489  * @tc.name: DeleteNetFirewallRule001
490  * @tc.desc: Test NetFirewallClientTest DeleteNetFirewallRule.
491  * @tc.type: FUNC
492  */
493 HWTEST_F(NetFirewallClientTest, DeleteNetFirewallRule001, TestSize.Level1)
494 {
495     NetManagerExtAccessToken token;
496     int32_t userId = 100;
497     int32_t ruleId = 0;
498     NetFirewallRuleManager::GetInstance().GetAllRuleConstraint(userId);
499     ruleId = NetFirewallRuleManager::GetInstance().allUserRule_;
500     int32_t ret = -1;
501     g_startTimeTest = GetCurrentMilliseconds();
502     for (int32_t i = 0; i < MAX_USER_RULE; i++) {
503         ++ruleId;
504         ret = netfirewallClient_.DeleteNetFirewallRule(userId, ruleId);
505         std::cout << "DeleteNetFirewallRule " << i + 1 << " ret " << ret << std::endl;
506     }
507     g_endTimeTest = GetCurrentMilliseconds();
508     std::cout << "CALL_TEST DeleteNetFirewallRule user " << ruleId << " call " << MAX_USER_RULE << ", use time : " <<
509         g_endTimeTest - g_startTimeTest << " ms" << std::endl;
510     EXPECT_EQ(ret, FIREWALL_ERR_NO_RULE);
511 }
512 
513 HWTEST_F(NetFirewallClientTest, OnLoadSystemAbility001, TestSize.Level1)
514 {
515     int32_t systemAbilityId = 0;
516     DelayedSingleton<NetFirewallLoadCallback>::GetInstance()->OnLoadSystemAbilityFail(systemAbilityId);
517     auto ret = DelayedSingleton<NetFirewallLoadCallback>::GetInstance()->IsFailed();
518     EXPECT_EQ(ret, true);
519 }
520 
521 HWTEST_F(NetFirewallClientTest, OnRemoteDied001, TestSize.Level0)
522 {
523     NetManagerExtAccessToken token;
524     wptr<IRemoteObject> remote = nullptr;
525     sptr<NetFirewallPolicy> status = new (std::nothrow) NetFirewallPolicy();
526     int32_t ret = netfirewallClient_.GetNetFirewallPolicy(USER_ID1, status);
527     netfirewallClient_.OnRemoteDied(remote);
528     wptr<IRemoteObject> remote1 = netfirewallClient_.netfirewallService_->AsObject();
529     netfirewallClient_.OnRemoteDied(remote1);
530     sptr<IRemoteObject::DeathRecipient> deathRec =
531         new (std::nothrow) NetFirewallClient::MonitorPcfirewallServiceDead(netfirewallClient_);
532     deathRec->OnRemoteDied(remote1);
533     EXPECT_EQ(ret, FIREWALL_SUCCESS);
534 }
535 
536 HWTEST_F(NetFirewallClientTest, GetProxy001, TestSize.Level0)
537 {
538     sptr<INetFirewallService> result = netfirewallClient_.GetProxy();
539     EXPECT_NE(result, nullptr);
540 }
541 
542 HWTEST_F(NetFirewallClientTest, RestartNetFirewallManagerSysAbility001, TestSize.Level0)
543 {
544     bool result = netfirewallClient_.RestartNetFirewallManagerSysAbility();
545     EXPECT_EQ(result, true);
546 }
547 
548 HWTEST_F(NetFirewallClientTest, LoadSaOnDemand001, TestSize.Level0)
549 {
550     sptr<IRemoteObject> result = netfirewallClient_.LoadSaOnDemand();
551     EXPECT_NE(result, nullptr);
552 }
553 } // namespace NetManagerStandard
554 } // namespace OHOS
555