1 /*
2 * Copyright (c) 2022-2023 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 #include "iservice_registry.h"
19 #include "system_ability_definition.h"
20
21 #define private public
22 #include "firewall_manager.h"
23 #undef private
24 #include "iptables_type.h"
25 #include "net_manager_constants.h"
26 #include "netnative_log_wrapper.h"
27 #include "netsys_controller.h"
28
29 namespace OHOS {
30 namespace NetsysNative {
31 using namespace testing::ext;
32 using namespace nmd;
33 using namespace NetManagerStandard;
34 std::shared_ptr<FirewallManager> g_firewallManager = nullptr;
35 class FirewallManagerTest : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp();
40 void TearDown();
41 };
42
SetUpTestCase()43 void FirewallManagerTest::SetUpTestCase()
44 {
45 NetsysController::GetInstance().FirewallEnableChain(ChainType::CHAIN_OHFW_DOZABLE, false);
46 g_firewallManager = std::make_shared<FirewallManager>();
47 }
48
TearDownTestCase()49 void FirewallManagerTest::TearDownTestCase() {}
50
SetUp()51 void FirewallManagerTest::SetUp() {}
52
TearDown()53 void FirewallManagerTest::TearDown()
54 {
55 NetsysController::GetInstance().FirewallSetUidRule(ChainType::CHAIN_OHFW_UNDOZABLE, {0}, FirewallRule::RULE_DENY);
56 }
57
58 /**
59 * @tc.name: FirewallEnableChainTest001
60 * @tc.desc: Test FirewallManager FirewallEnableChain.
61 * @tc.type: FUNC
62 */
63 HWTEST_F(FirewallManagerTest, FirewallEnableChainTest001, TestSize.Level1)
64 {
65 // CHAIN_OHFW_DOZABLE, enable
66 int32_t ret = NetsysController::GetInstance().FirewallEnableChain(ChainType::CHAIN_OHFW_DOZABLE, true);
67 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
68 }
69
70 /**
71 * @tc.name: FirewallEnableChainTest002
72 * @tc.desc: Test FirewallManager FirewallEnableChain.
73 * @tc.type: FUNC
74 */
75 HWTEST_F(FirewallManagerTest, FirewallEnableChainTest002, TestSize.Level1)
76 {
77 // CHAIN_OHFW_DOZABLE, disable
78 int32_t ret = NetsysController::GetInstance().FirewallEnableChain(ChainType::CHAIN_OHFW_DOZABLE, false);
79 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
80 }
81
82 /**
83 * @tc.name: FirewallEnableChainTest003
84 * @tc.desc: Test FirewallManager FirewallEnableChain.
85 * @tc.type: FUNC
86 */
87 HWTEST_F(FirewallManagerTest, FirewallEnableChainTest003, TestSize.Level1)
88 {
89 // CHAIN_OHFW_UNDOZABLE, enable
90 int32_t ret = NetsysController::GetInstance().FirewallEnableChain(ChainType::CHAIN_OHFW_UNDOZABLE, true);
91 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
92 }
93
94 /**
95 * @tc.name: FirewallEnableChainTest004
96 * @tc.desc: Test FirewallManager FirewallEnableChain.
97 * @tc.type: FUNC
98 */
99 HWTEST_F(FirewallManagerTest, FirewallEnableChainTest004, TestSize.Level1)
100 {
101 // CHAIN_OHFW_UNDOZABLE, disable
102 int32_t ret = NetsysController::GetInstance().FirewallEnableChain(ChainType::CHAIN_OHFW_UNDOZABLE, false);
103 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
104 }
105
106 /**
107 * @tc.name: FirewallEnableChainTest005
108 * @tc.desc: Test FirewallManager FirewallEnableChain.
109 * @tc.type: FUNC
110 */
111 HWTEST_F(FirewallManagerTest, FirewallEnableChainTest005, TestSize.Level1)
112 {
113 // CHAIN_OHFW_UNDOZABLE, disable
114 int32_t ret = NetsysController::GetInstance().FirewallEnableChain(ChainType::CHAIN_OHFW_DOZABLE, true);
115 ret = NetsysController::GetInstance().FirewallEnableChain(ChainType::CHAIN_OHFW_DOZABLE, true);
116 EXPECT_EQ(ret, -1);
117 }
118
119 /**
120 * @tc.name: FirewallEnableChainTest006
121 * @tc.desc: Test FirewallManager FirewallEnableChain.
122 * @tc.type: FUNC
123 */
124 HWTEST_F(FirewallManagerTest, FirewallEnableChainTest006, TestSize.Level1)
125 {
126 // CHAIN_OHFW_UNDOZABLE, disable
127 int32_t ret = NetsysController::GetInstance().FirewallEnableChain(ChainType::CHAIN_OHFW_DOZABLE, false);
128 ret = NetsysController::GetInstance().FirewallEnableChain(ChainType::CHAIN_OHFW_DOZABLE, false);
129 EXPECT_EQ(ret, -1);
130 }
131
132 /**
133 * @tc.name: FirewallSetUidRuleTest001
134 * @tc.desc: Test FirewallManager FirewallSetUidRule.
135 * @tc.type: FUNC
136 */
137 HWTEST_F(FirewallManagerTest, FirewallSetUidRuleTest001, TestSize.Level1)
138 {
139 NetsysController::GetInstance().FirewallSetUidRule(ChainType::CHAIN_OHFW_DOZABLE, {0}, FirewallRule::RULE_DENY);
140 // CHAIN_OHFW_DOZABLE, root, RULE_ALLOW
141 int32_t ret = NetsysController::GetInstance().FirewallSetUidRule(ChainType::CHAIN_OHFW_DOZABLE, {0},
142 FirewallRule::RULE_ALLOW);
143 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
144 }
145
146 /**
147 * @tc.name: FirewallSetUidRuleTest002
148 * @tc.desc: Test FirewallManager FirewallSetUidRule.
149 * @tc.type: FUNC
150 */
151 HWTEST_F(FirewallManagerTest, FirewallSetUidRuleTest002, TestSize.Level1)
152 {
153 // CHAIN_OHFW_DOZABLE, root, RULE_DENY
154 int32_t ret =
155 NetsysController::GetInstance().FirewallSetUidRule(ChainType::CHAIN_OHFW_DOZABLE, {0}, FirewallRule::RULE_DENY);
156 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
157 }
158
159 /**
160 * @tc.name: FirewallSetUidRuleTest003
161 * @tc.desc: Test FirewallManager FirewallSetUidRule.
162 * @tc.type: FUNC
163 */
164 HWTEST_F(FirewallManagerTest, FirewallSetUidRuleTest003, TestSize.Level1)
165 {
166 NetsysController::GetInstance().FirewallSetUidRule(ChainType::CHAIN_OHFW_UNDOZABLE, {0}, FirewallRule::RULE_ALLOW);
167 // CHAIN_OHFW_UNDOZABLE, root, RULE_ALLOW
168 int32_t ret = NetsysController::GetInstance().FirewallSetUidRule(ChainType::CHAIN_OHFW_UNDOZABLE, {0},
169 FirewallRule::RULE_DENY);
170 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
171 }
172
173 /**
174 * @tc.name: FirewallSetUidRuleTest004
175 * @tc.desc: Test FirewallManager FirewallSetUidRule.
176 * @tc.type: FUNC
177 */
178 HWTEST_F(FirewallManagerTest, FirewallSetUidRuleTest004, TestSize.Level1)
179 {
180 // CHAIN_OHFW_UNDOZABLE, root, RULE_DENY
181 int32_t ret = NetsysController::GetInstance().FirewallSetUidRule(ChainType::CHAIN_OHFW_UNDOZABLE, {0},
182 FirewallRule::RULE_ALLOW);
183 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
184 }
185
186 /**
187 * @tc.name: FirewallSetUidRuleTest005
188 * @tc.desc: Test FirewallManager FirewallSetUidRule.
189 * @tc.type: FUNC
190 */
191 HWTEST_F(FirewallManagerTest, FirewallSetUidRuleTest005, TestSize.Level1)
192 {
193 // CHAIN_OHFW_UNDOZABLE, root, RULE_DENY
194 int32_t ret = NetsysController::GetInstance().FirewallSetUidRule(ChainType::CHAIN_OHFW_DOZABLE, {0},
195 FirewallRule::RULE_ALLOW);
196 ret = NetsysController::GetInstance().FirewallSetUidRule(ChainType::CHAIN_OHFW_DOZABLE, {0},
197 FirewallRule::RULE_ALLOW);
198 EXPECT_EQ(ret, -1);
199 }
200
201 /**
202 * @tc.name: FirewallSetUidRuleTest006
203 * @tc.desc: Test FirewallManager FirewallSetUidRule.
204 * @tc.type: FUNC
205 */
206 HWTEST_F(FirewallManagerTest, FirewallSetUidRuleTest006, TestSize.Level1)
207 {
208 // CHAIN_OHFW_UNDOZABLE, root, RULE_DENY
209 int32_t ret = NetsysController::GetInstance().FirewallSetUidRule(ChainType::CHAIN_OHFW_UNDOZABLE, {0},
210 FirewallRule::RULE_DENY);
211 ret = NetsysController::GetInstance().FirewallSetUidRule(ChainType::CHAIN_OHFW_UNDOZABLE, {0},
212 FirewallRule::RULE_DENY);
213 EXPECT_EQ(ret, -1);
214 ret = NetsysController::GetInstance().FirewallSetUidRule(ChainType::CHAIN_OHFW_UNDOZABLE, {0},
215 FirewallRule::RULE_ALLOW);
216 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
217 }
218
219 /**
220 * @tc.name: FirewallSetUidsAllowedListChainTest001
221 * @tc.desc: Test FirewallManager FirewallSetUidsAllowedListChain.
222 * @tc.type: FUNC
223 */
224 HWTEST_F(FirewallManagerTest, FirewallSetUidsAllowedListChainTest001, TestSize.Level1)
225 {
226 // CHAIN_OHFW_DOZABLE, <root>
227 std::vector<uint32_t> uids;
228 uids.push_back(0);
229 int32_t ret =
230 NetsysController::GetInstance().FirewallSetUidsAllowedListChain(ChainType::CHAIN_OHFW_DOZABLE, uids);
231 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
232 }
233
234 /**
235 * @tc.name: FirewallSetUidsAllowedListChainTest002
236 * @tc.desc: Test FirewallManager FirewallSetUidsAllowedListChain.
237 * @tc.type: FUNC
238 */
239 HWTEST_F(FirewallManagerTest, FirewallSetUidsAllowedListChainTest002, TestSize.Level1)
240 {
241 // CHAIN_OHFW_UNDOZABLE, <root, system>
242 std::vector<uint32_t> uids;
243 uids.push_back(0);
244 uids.push_back(20010034);
245 int32_t ret =
246 NetsysController::GetInstance().FirewallSetUidsAllowedListChain(ChainType::CHAIN_OHFW_DOZABLE, uids);
247 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
248 }
249
250 /**
251 * @tc.name: FirewallSetUidsAllowedListChainTest003
252 * @tc.desc: Test FirewallManager FirewallSetUidsAllowedListChain.
253 * @tc.type: FUNC
254 */
255 HWTEST_F(FirewallManagerTest, FirewallSetUidsAllowedListChainTest003, TestSize.Level1)
256 {
257 // CHAIN_OHFW_UNDOZABLE, <root, system>
258 std::vector<uint32_t> uids;
259 uids.push_back(0);
260 uids.push_back(20010034);
261 int32_t ret =
262 NetsysController::GetInstance().FirewallSetUidsAllowedListChain(ChainType::CHAIN_OHFW_UNDOZABLE, uids);
263 EXPECT_EQ(ret, -1);
264 }
265
266 /**
267 * @tc.name: FirewallSetUidsDeniedListChainTest001
268 * @tc.desc: Test FirewallManager FirewallSetUidsDeniedListChain.
269 * @tc.type: FUNC
270 */
271 HWTEST_F(FirewallManagerTest, FirewallSetUidsDeniedListChainTest001, TestSize.Level1)
272 {
273 // CHAIN_OHFW_DOZABLE, <root>
274 std::vector<uint32_t> uids;
275 uids.push_back(0);
276 int32_t ret =
277 NetsysController::GetInstance().FirewallSetUidsDeniedListChain(ChainType::CHAIN_OHFW_UNDOZABLE, uids);
278 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
279 }
280
281 /**
282 * @tc.name: FirewallSetUidsDeniedListChainTest002
283 * @tc.desc: Test FirewallManager FirewallSetUidsDeniedListChain.
284 * @tc.type: FUNC
285 */
286 HWTEST_F(FirewallManagerTest, FirewallSetUidsDeniedListChainTest002, TestSize.Level1)
287 {
288 // CHAIN_OHFW_UNDOZABLE, <root, system>
289 std::vector<uint32_t> uids;
290 uids.push_back(0);
291 uids.push_back(20010034);
292 int32_t ret =
293 NetsysController::GetInstance().FirewallSetUidsDeniedListChain(ChainType::CHAIN_OHFW_UNDOZABLE, uids);
294 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
295 }
296
297 /**
298 * @tc.name: FirewallSetUidsDeniedListChainTest003
299 * @tc.desc: Test FirewallManager FirewallSetUidsDeniedListChain.
300 * @tc.type: FUNC
301 */
302 HWTEST_F(FirewallManagerTest, FirewallSetUidsDeniedListChainTest003, TestSize.Level1)
303 {
304 // CHAIN_OHFW_UNDOZABLE, <root, system>
305 std::vector<uint32_t> uids;
306 uids.push_back(0);
307 uids.push_back(20010034);
308 int32_t ret = NetsysController::GetInstance().FirewallSetUidsDeniedListChain(ChainType::CHAIN_OHFW_DOZABLE, uids);
309 EXPECT_EQ(ret, -1);
310 }
311
312 /**
313 * @tc.name: FirewallManagerInnerFunctionTest
314 * @tc.desc: Test FirewallManager FirewallManagerInnerFunctionTest.
315 * @tc.type: FUNC
316 */
317 HWTEST_F(FirewallManagerTest, FirewallManagerInnerFunctionTest, TestSize.Level1)
318 {
319 std::shared_ptr<OHOS::nmd::FirewallManager> firewallManager = std::make_shared<OHOS::nmd::FirewallManager>();
320 if (firewallManager == nullptr) {
321 return;
322 }
323 if (firewallManager->chainInitFlag_ == false) {
324 int32_t ret = firewallManager->InitChain();
325 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
326 ret = firewallManager->InitDefaultRules();
327 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
328 }
329 ChainType chain = ChainType::CHAIN_OHFW_DOZABLE;
330 FirewallType fwType = firewallManager->FetchChainType(chain);
331 EXPECT_EQ((fwType == FirewallType::TYPE_ALLOWED_LIST), true);
332
333 chain = ChainType::CHAIN_OHFW_UNDOZABLE;
334 fwType = firewallManager->FetchChainType(chain);
335 EXPECT_EQ((fwType == FirewallType::TYPE_DENIDE_LIST), true);
336
337 chain = ChainType::CHAIN_NONE;
338 fwType = firewallManager->FetchChainType(chain);
339 EXPECT_EQ((fwType == FirewallType::TYPE_ALLOWED_LIST), true);
340
341 int32_t ret = firewallManager->DeInitChain();
342 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
343 }
344
345 /**
346 * @tc.name: IsFirewallChian1
347 * @tc.desc: Test FirewallManager IsFirewallChian1.
348 * @tc.type: FUNC
349 */
350 HWTEST_F(FirewallManagerTest, IsFirewallChian1, TestSize.Level1)
351 {
352 int32_t ret = g_firewallManager->IsFirewallChian(ChainType::CHAIN_OHFW_DOZABLE);
353 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
354 }
355
356 /**
357 * @tc.name: IsFirewallChian2
358 * @tc.desc: Test FirewallManager IsFirewallChian2.
359 * @tc.type: FUNC
360 */
361 HWTEST_F(FirewallManagerTest, IsFirewallChian2, TestSize.Level1)
362 {
363 int32_t ret = g_firewallManager->IsFirewallChian(ChainType::CHAIN_OHFW_FORWARD);
364 EXPECT_EQ(ret, NETMANAGER_ERROR);
365 }
366
367 /**
368 * @tc.name: FetchChainName
369 * @tc.desc: Test FirewallManager FetchChainName.
370 * @tc.type: FUNC
371 */
372 HWTEST_F(FirewallManagerTest, FetchChainName, TestSize.Level1)
373 {
374 std::string ret = g_firewallManager->FetchChainName(ChainType::CHAIN_OHBW_DATA_SAVER);
375 EXPECT_EQ(ret, "oh_unusable");
376 }
377
378 /**
379 * @tc.name: FetchChainType
380 * @tc.desc: Test FirewallManager FetchChainType.
381 * @tc.type: FUNC
382 */
383 HWTEST_F(FirewallManagerTest, FetchChainType1, TestSize.Level1)
384 {
385 FirewallType type = g_firewallManager->FetchChainType(ChainType::CHAIN_OHFW_DOZABLE);
386 EXPECT_EQ(type, FirewallType::TYPE_ALLOWED_LIST);
387 }
388
389 /**
390 * @tc.name: FetchChainType
391 * @tc.desc: Test FirewallManager FetchChainType.
392 * @tc.type: FUNC
393 */
394 HWTEST_F(FirewallManagerTest, FetchChainType2, TestSize.Level1)
395 {
396 FirewallType type = g_firewallManager->FetchChainType(ChainType::CHAIN_OHFW_POWERSAVING);
397 EXPECT_EQ(type, FirewallType::TYPE_ALLOWED_LIST);
398 }
399
400 /**
401 * @tc.name: FetchChainType
402 * @tc.desc: Test FirewallManager FetchChainType.
403 * @tc.type: FUNC
404 */
405 HWTEST_F(FirewallManagerTest, FetchChainType3, TestSize.Level1)
406 {
407 FirewallType type = g_firewallManager->FetchChainType(ChainType::CHAIN_OHFW_UNDOZABLE);
408 EXPECT_EQ(type, FirewallType::TYPE_DENIDE_LIST);
409 }
410
411 /**
412 * @tc.name: FetchChainType
413 * @tc.desc: Test FirewallManager FetchChainType.
414 * @tc.type: FUNC
415 */
416 HWTEST_F(FirewallManagerTest, FetchChainType4, TestSize.Level1)
417 {
418 FirewallType type = g_firewallManager->FetchChainType(ChainType::CHAIN_OHBW_DATA_SAVER);
419 EXPECT_EQ(type, FirewallType::TYPE_ALLOWED_LIST);
420 }
421
422 /**
423 * @tc.name: InitChain
424 * @tc.desc: Test FirewallManager InitChain.
425 * @tc.type: FUNC
426 */
427 HWTEST_F(FirewallManagerTest, InitChain, TestSize.Level1)
428 {
429 int32_t ret = g_firewallManager->InitChain();
430 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
431
432 int32_t ret2 = g_firewallManager->DeInitChain();
433 EXPECT_EQ(ret2, NetManagerStandard::NETMANAGER_SUCCESS);
434 }
435
436 /**
437 * @tc.name: InitDefaultRules
438 * @tc.desc: Test FirewallManager InitDefaultRules.
439 * @tc.type: FUNC
440 */
441 HWTEST_F(FirewallManagerTest, InitDefaultRules, TestSize.Level1)
442 {
443 int32_t ret = g_firewallManager->InitDefaultRules();
444 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
445
446 int32_t ret2 = g_firewallManager->ClearAllRules();
447 EXPECT_EQ(ret2, NetManagerStandard::NETMANAGER_SUCCESS);
448 }
449
450 /**
451 * @tc.name: InitDefaultRules
452 * @tc.desc: Test FirewallManager InitDefaultRules.
453 * @tc.type: FUNC
454 */
455 HWTEST_F(FirewallManagerTest, IptablesNewChain, TestSize.Level1)
456 {
457 ChainType type = ChainType::CHAIN_OHFW_UNDOZABLE;
458 int32_t ret = g_firewallManager->IptablesNewChain(type);
459 EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS);
460 }
461
462 /**
463 * @tc.name: IptablesSetRule
464 * @tc.desc: Test FirewallManager IptablesSetRule.
465 * @tc.type: FUNC
466 */
467 HWTEST_F(FirewallManagerTest, IptablesSetRule, TestSize.Level1)
468 {
469 std::string chainName = g_firewallManager->FetchChainName(ChainType::CHAIN_OHFW_INPUT);
470 std::string option = "-A";
471 std::string target = "DROP";
472 uint32_t uid = 150000;
473 int32_t ret = g_firewallManager->IptablesSetRule(chainName, option, target, uid);
474 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
475 }
476
477 /**
478 * @tc.name: SetUidsAllowedListChain1
479 * @tc.desc: Test FirewallManager SetUidsAllowedListChain1.
480 * @tc.type: FUNC
481 */
482 HWTEST_F(FirewallManagerTest, SetUidsAllowedListChain1, TestSize.Level1)
483 {
484 std::vector<uint32_t> uids;
485 uids.push_back(150000);
486 int32_t ret = g_firewallManager->SetUidsAllowedListChain(ChainType::CHAIN_OHBW_DATA_SAVER, uids);
487 EXPECT_EQ(ret, NETMANAGER_ERROR);
488 }
489
490 /**
491 * @tc.name: SetUidsAllowedListChain2
492 * @tc.desc: Test FirewallManager SetUidsAllowedListChain2.
493 * @tc.type: FUNC
494 */
495 HWTEST_F(FirewallManagerTest, SetUidsAllowedListChain2, TestSize.Level1)
496 {
497 std::vector<uint32_t> uids;
498 uids.push_back(150000);
499 int32_t ret = g_firewallManager->SetUidsAllowedListChain(ChainType::CHAIN_OHFW_DOZABLE, uids);
500 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
501 }
502
503 /**
504 * @tc.name: SetUidsDeniedListChain1
505 * @tc.desc: Test FirewallManager SetUidsDeniedListChain1.
506 * @tc.type: FUNC
507 */
508 HWTEST_F(FirewallManagerTest, SetUidsDeniedListChain1, TestSize.Level1)
509 {
510 std::vector<uint32_t> uids;
511 uids.push_back(150000);
512 int32_t ret = g_firewallManager->SetUidsDeniedListChain(ChainType::CHAIN_OHBW_DATA_SAVER, uids);
513 EXPECT_EQ(ret, NETMANAGER_ERROR);
514 }
515
516 /**
517 * @tc.name: SetUidsDeniedListChain2
518 * @tc.desc: Test FirewallManager SetUidsDeniedListChain2.
519 * @tc.type: FUNC
520 */
521 HWTEST_F(FirewallManagerTest, SetUidsDeniedListChain2, TestSize.Level1)
522 {
523 std::vector<uint32_t> uids;
524 uids.push_back(150000);
525 int32_t ret = g_firewallManager->SetUidsDeniedListChain(ChainType::CHAIN_OHFW_UNDOZABLE, uids);
526 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
527 }
528
529 /**
530 * @tc.name: EnableChain1
531 * @tc.desc: Test FirewallManager EnableChain1.
532 * @tc.type: FUNC
533 */
534 HWTEST_F(FirewallManagerTest, EnableChain1, TestSize.Level1)
535 {
536 int32_t ret = g_firewallManager->EnableChain(ChainType::CHAIN_OHFW_FORWARD, false);
537 EXPECT_EQ(ret, NETMANAGER_ERROR);
538 }
539
540 /**
541 * @tc.name: EnableChain2
542 * @tc.desc: Test FirewallManager EnableChain2.
543 * @tc.type: FUNC
544 */
545 HWTEST_F(FirewallManagerTest, EnableChain2, TestSize.Level1)
546 {
547 g_firewallManager->EnableChain(ChainType::CHAIN_OHFW_UNDOZABLE, false);
548 int32_t ret = g_firewallManager->EnableChain(ChainType::CHAIN_OHFW_UNDOZABLE, true);
549 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
550 }
551
552 /**
553 * @tc.name: EnableChain3
554 * @tc.desc: Test FirewallManager EnableChain3.
555 * @tc.type: FUNC
556 */
557 HWTEST_F(FirewallManagerTest, EnableChain3, TestSize.Level1)
558 {
559 int32_t ret = g_firewallManager->EnableChain(ChainType::CHAIN_OHFW_UNDOZABLE, false);
560 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
561 }
562
563 /**
564 * @tc.name: EnableChain4
565 * @tc.desc: Test FirewallManager EnableChain4.
566 * @tc.type: FUNC
567 */
568 HWTEST_F(FirewallManagerTest, EnableChain4, TestSize.Level1)
569 {
570 int32_t ret = g_firewallManager->EnableChain(ChainType::CHAIN_OHFW_UNDOZABLE, false);
571 EXPECT_EQ(ret, NETMANAGER_ERROR);
572 }
573
574 /**
575 * @tc.name: SetUidRule1
576 * @tc.desc: Test FirewallManager SetUidRule1.
577 * @tc.type: FUNC
578 */
579 HWTEST_F(FirewallManagerTest, SetUidRule1, TestSize.Level1)
580 {
581 uint32_t uid = 150000;
582 int32_t ret = g_firewallManager->SetUidRule(ChainType::CHAIN_FORWARD, uid, FirewallRule::RULE_DENY);
583 EXPECT_EQ(ret, NETMANAGER_ERROR);
584 }
585
586 /**
587 * @tc.name: SetUidRule2
588 * @tc.desc: Test FirewallManager SetUidRule2.
589 * @tc.type: FUNC
590 */
591 HWTEST_F(FirewallManagerTest, SetUidRule2, TestSize.Level1)
592 {
593 uint32_t uid = 150000;
594 int32_t ret = g_firewallManager->SetUidRule(ChainType::CHAIN_OHFW_DOZABLE, uid, FirewallRule::RULE_DENY);
595 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
596 }
597
598 /**
599 * @tc.name: SetUidRule3
600 * @tc.desc: Test FirewallManager SetUidRule3.
601 * @tc.type: FUNC
602 */
603 HWTEST_F(FirewallManagerTest, SetUidRule3, TestSize.Level1)
604 {
605 uint32_t uid = 150000;
606 int32_t ret = g_firewallManager->SetUidRule(ChainType::CHAIN_OHFW_DOZABLE, uid, FirewallRule::RULE_ALLOW);
607 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
608 }
609
610 /**
611 * @tc.name: SetUidRule4
612 * @tc.desc: Test FirewallManager SetUidRule4.
613 * @tc.type: FUNC
614 */
615 HWTEST_F(FirewallManagerTest, SetUidRule4, TestSize.Level1)
616 {
617 uint32_t uid = 160000;
618 int32_t ret = g_firewallManager->SetUidRule(ChainType::CHAIN_OHFW_UNDOZABLE, uid, FirewallRule::RULE_DENY);
619 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
620 }
621
622 /**
623 * @tc.name: SetUidRule5
624 * @tc.desc: Test FirewallManager SetUidRule5.
625 * @tc.type: FUNC
626 */
627 HWTEST_F(FirewallManagerTest, SetUidRule5, TestSize.Level1)
628 {
629 uint32_t uid = 160000;
630 int32_t ret = g_firewallManager->SetUidRule(ChainType::CHAIN_OHFW_UNDOZABLE, uid, FirewallRule::RULE_ALLOW);
631 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
632 }
633
634 /**
635 * @tc.name: ClearAllRules
636 * @tc.desc: Test FirewallManager ClearAllRules.
637 * @tc.type: FUNC
638 */
639 HWTEST_F(FirewallManagerTest, ClearAllRules, TestSize.Level1)
640 {
641 int32_t ret = g_firewallManager->ClearAllRules();
642 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
643 }
644 } // namespace NetsysNative
645 } // namespace OHOS
646