1 /*
2 * Copyright (c) 2022-2025 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 #define private public
18 #define protected public
19 #include "ability_manager_service.h"
20 #include "interceptor/ability_jump_interceptor.h"
21 #include "interceptor/ecological_rule_interceptor.h"
22 #include "interceptor/disposed_rule_interceptor.h"
23 #include "interceptor/kiosk_interceptor.h"
24 #undef private
25 #undef protected
26
27 #include "bundlemgr/mock_bundle_manager.h"
28 #include "interceptor/ability_interceptor_executer.h"
29 #include "interceptor/control_interceptor.h"
30 #include "interceptor/crowd_test_interceptor.h"
31 #include "permission_constants.h"
32 #include "start_ability_utils.h"
33
34 using namespace testing;
35 using namespace testing::ext;
36 using namespace OHOS::AppExecFwk;
37
38 namespace {
39 const std::string BUNDLE_NAME = "testBundle";
40 const std::string ATOMIC_SERVICE_BUNDLE_NAME = "com.test.atomicservice";
41 const std::string PASS_ABILITY_NAME = "com.test.pass";
42 const std::string DENY_ABILITY_NAME = "com.test.deny";
43 const std::string JUMP_ABILITY_NAME = "com.test.jump";
44 }
45
46 namespace OHOS {
47 namespace AAFwk {
48 class AbilityInterceptorTest : public testing::Test {
49 public:
50 static void SetUpTestCase();
51 static void TearDownTestCase();
52 void SetUp();
53 void TearDown();
54
55 public:
56 };
57
SetUpTestCase()58 void AbilityInterceptorTest::SetUpTestCase()
59 {
60 GTEST_LOG_(INFO) << "AbilityInterceptorTest SetUpTestCase called";
61 AbilityManagerClient::GetInstance()->CleanAllMissions();
62 OHOS::DelayedSingleton<SaMgrClient>::DestroyInstance();
63
64 OHOS::DelayedSingleton<SaMgrClient>::GetInstance()->RegisterSystemAbility(
65 OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService());
66 }
67
TearDownTestCase()68 void AbilityInterceptorTest::TearDownTestCase()
69 {
70 GTEST_LOG_(INFO) << "AbilityInterceptorTest TearDownTestCase called";
71 OHOS::DelayedSingleton<SaMgrClient>::DestroyInstance();
72 }
73
SetUp()74 void AbilityInterceptorTest::SetUp()
75 {}
76
TearDown()77 void AbilityInterceptorTest::TearDown()
78 {}
79
80 HWTEST_F(AbilityInterceptorTest, CreateExecuter_001, TestSize.Level1)
81 {
82 std::shared_ptr<AbilityInterceptorExecuter> executer = std::make_shared<AbilityInterceptorExecuter>();
83 EXPECT_NE(executer, nullptr);
84 }
85
86 /**
87 * @tc.name: AbilityInterceptorTest_CrowdTestInterceptor_001
88 * @tc.desc: CrowdTestInterceptor
89 * @tc.type: FUNC
90 * @tc.require: issueI5I0DY
91 */
92 HWTEST_F(AbilityInterceptorTest, CrowdTestInterceptor_001, TestSize.Level1)
93 {
94 std::shared_ptr<AbilityInterceptorExecuter> executer = std::make_shared<AbilityInterceptorExecuter>();
95 Want want;
96 ElementName element("", "com.test.crowdtest", "CrowdtestExpired");
97 want.SetElement(element);
98 int requestCode = 0;
99 int userId = 100;
100 executer->AddInterceptor("CrowdTest", std::make_shared<CrowdTestInterceptor>());
__anon79b807420202() 101 auto shouldBlockFunc = []() { return false; };
102 AbilityInterceptorParam param = AbilityInterceptorParam(want, requestCode, userId, true, nullptr,
103 shouldBlockFunc);
104 int result = executer->DoProcess(param);
105 EXPECT_EQ(result, ERR_OK);
106 }
107
108 /**
109 * @tc.name: AbilityInterceptorTest_CrowdTestInterceptor_002
110 * @tc.desc: CrowdTestInterceptor
111 * @tc.type: FUNC
112 * @tc.require: issueI5I0DY
113 */
114 HWTEST_F(AbilityInterceptorTest, CrowdTestInterceptor_002, TestSize.Level1)
115 {
116 std::shared_ptr<AbilityInterceptorExecuter> executer = std::make_shared<AbilityInterceptorExecuter>();
117 Want want;
118 ElementName element("", "com.test.crowdtest", "CrowdtestExpired");
119 want.SetElement(element);
120 int userId = 100;
121 executer->AddInterceptor("CrowdTest", std::make_shared<CrowdTestInterceptor>());
__anon79b807420302() 122 auto shouldBlockFunc = []() { return false; };
123 AbilityInterceptorParam param = AbilityInterceptorParam(want, 0, userId, false, nullptr,
124 shouldBlockFunc);
125 int result = executer->DoProcess(param);
126 EXPECT_EQ(result, ERR_OK);
127 }
128
129 /**
130 * @tc.name: AbilityInterceptorTest_ControlInterceptor_001
131 * @tc.desc: ControlInterceptor
132 * @tc.type: FUNC
133 * @tc.require: issueI5QT7P
134 */
135 HWTEST_F(AbilityInterceptorTest, ControlInterceptor_001, TestSize.Level1)
136 {
137 std::shared_ptr<AbilityInterceptorExecuter> executer = std::make_shared<AbilityInterceptorExecuter>();
138 Want want;
139 ElementName element("", "com.test.control", "MainAbility");
140 want.SetElement(element);
141 int requestCode = 0;
142 int userId = 100;
143 executer->AddInterceptor("Control", std::make_shared<ControlInterceptor>());
__anon79b807420402() 144 auto shouldBlockFunc = []() { return false; };
145 AbilityInterceptorParam param = AbilityInterceptorParam(want, requestCode, userId, true, nullptr,
146 shouldBlockFunc);
147 int result = executer->DoProcess(param);
148 EXPECT_EQ(result, ERR_OK);
149 }
150
151 /**
152 * @tc.name: AbilityInterceptorTest_ControlInterceptor_002
153 * @tc.desc: ControlInterceptor
154 * @tc.type: FUNC
155 * @tc.require: issueI5QT7P
156 */
157 HWTEST_F(AbilityInterceptorTest, ControlInterceptor_002, TestSize.Level1)
158 {
159 std::shared_ptr<AbilityInterceptorExecuter> executer = std::make_shared<AbilityInterceptorExecuter>();
160 Want want;
161 ElementName element("", "com.test.control", "MainAbility");
162 want.SetElement(element);
163 int userId = 100;
164 executer->AddInterceptor("Control", std::make_shared<ControlInterceptor>());
__anon79b807420502() 165 auto shouldBlockFunc = []() { return false; };
166 AbilityInterceptorParam param = AbilityInterceptorParam(want, 0, userId, false, nullptr,
167 shouldBlockFunc);
168 int result = executer->DoProcess(param);
169 EXPECT_EQ(result, ERR_OK);
170 }
171
172 /**
173 * @tc.name: AbilityInterceptorTest_ControlInterceptor_003
174 * @tc.desc: ControlInterceptor
175 * @tc.type: FUNC
176 * @tc.require: issueI5QT7P
177 */
178 HWTEST_F(AbilityInterceptorTest, ControlInterceptor_003, TestSize.Level1)
179 {
180 std::shared_ptr<AbilityInterceptorExecuter> executer = std::make_shared<AbilityInterceptorExecuter>();
181 Want want;
182 ElementName element("", "com.test.control2", "MainAbility");
183 want.SetElement(element);
184 int userId = 100;
185 executer->AddInterceptor("Control", std::make_shared<ControlInterceptor>());
__anon79b807420602() 186 auto shouldBlockFunc = []() { return false; };
187 AbilityInterceptorParam param = AbilityInterceptorParam(want, 0, userId, false, nullptr,
188 shouldBlockFunc);
189 int result = executer->DoProcess(param);
190 EXPECT_EQ(result, ERR_OK);
191 }
192
193 /**
194 * @tc.name: AbilityInterceptorTest_ControlInterceptor_004
195 * @tc.desc: ControlInterceptor
196 * @tc.type: FUNC
197 * @tc.require: issueI5QT7P
198 */
199 HWTEST_F(AbilityInterceptorTest, ControlInterceptor_004, TestSize.Level1)
200 {
201 std::shared_ptr<AbilityInterceptorExecuter> executer = std::make_shared<AbilityInterceptorExecuter>();
202 Want want;
203 ElementName element("", "com.test.control3", "MainAbility");
204 want.SetElement(element);
205 int userId = 100;
206 executer->AddInterceptor("Control", std::make_shared<ControlInterceptor>());
__anon79b807420702() 207 auto shouldBlockFunc = []() { return false; };
208 AbilityInterceptorParam param = AbilityInterceptorParam(want, 0, userId, false, nullptr,
209 shouldBlockFunc);
210 int result = executer->DoProcess(param);
211 EXPECT_EQ(result, ERR_OK);
212 }
213
214 /**
215 * @tc.name: AbilityInterceptorTest_ControlInterceptor_005
216 * @tc.desc: ControlInterceptor
217 * @tc.type: FUNC
218 * @tc.require: issueI5QT7P
219 */
220 HWTEST_F(AbilityInterceptorTest, ControlInterceptor_005, TestSize.Level1)
221 {
222 std::shared_ptr<AbilityInterceptorExecuter> executer = std::make_shared<AbilityInterceptorExecuter>();
223 Want want;
224 ElementName element("", "com.test.control", "MainAbility");
225 want.SetElement(element);
226 int userId = 100;
227 auto bundleMgrHelper = AbilityUtil::GetBundleManagerHelper();
228 // make appControlRule become nullptr by crowdtest interceptor
229 executer->AddInterceptor("CrowdTest", std::make_shared<CrowdTestInterceptor>());
230 executer->AddInterceptor("Control", std::make_shared<ControlInterceptor>());
__anon79b807420802() 231 auto shouldBlockFunc = []() { return false; };
232 AbilityInterceptorParam param = AbilityInterceptorParam(want, 0, userId, false, nullptr,
233 shouldBlockFunc);
234 int result = executer->DoProcess(param);
235 EXPECT_EQ(result, ERR_OK);
236 }
237
238 /**
239 * @tc.name: AbilityInterceptorTest_DisposedRuleInterceptor_001
240 * @tc.desc: DisposedRuleInterceptor
241 * @tc.type: FUNC
242 * @tc.require: issueI8D3OD
243 */
244 HWTEST_F(AbilityInterceptorTest, DisposedRuleInterceptor_001, TestSize.Level1)
245 {
246 std::shared_ptr<AbilityInterceptorExecuter> executer = std::make_shared<AbilityInterceptorExecuter>();
247 Want want;
248 ElementName element("", "com.acts.disposedrulehap", "ServiceAbility2", "entry");
249 want.SetElement(element);
250 int requestCode = 0;
251 int userId = 100;
252 executer->AddInterceptor("DisposedRule", std::make_shared<DisposedRuleInterceptor>());
__anon79b807420902() 253 auto shouldBlockFunc = []() { return false; };
254 AbilityInterceptorParam param = AbilityInterceptorParam(want, requestCode, userId, false, nullptr,
255 shouldBlockFunc);
256 int result = executer->DoProcess(param);
257 EXPECT_EQ(result, ERR_OK);
258 }
259
260 /**
261 * @tc.name: AbilityInterceptorTest_DisposedRuleInterceptor_002
262 * @tc.desc: DisposedRuleInterceptor
263 * @tc.type: FUNC
264 * @tc.require: issueI8D3OD
265 */
266 HWTEST_F(AbilityInterceptorTest, DisposedRuleInterceptor_002, TestSize.Level1)
267 {
268 std::shared_ptr<AbilityInterceptorExecuter> executer = std::make_shared<AbilityInterceptorExecuter>();
269 Want want;
270 ElementName element("", "com.acts.disposedrulehap", "MainAbility2", "entry");
271 want.SetElement(element);
272 int requestCode = 0;
273 int userId = 100;
274 executer->AddInterceptor("Disposed", std::make_shared<DisposedRuleInterceptor>());
__anon79b807420a02() 275 auto shouldBlockFunc = []() { return false; };
276 AbilityInterceptorParam param = AbilityInterceptorParam(want, requestCode, userId, true, nullptr,
277 shouldBlockFunc);
278 int result = executer->DoProcess(param);
279 EXPECT_EQ(result, ERR_OK);
280 }
281
282 /**
283 * @tc.name: AbilityInterceptorTest_DisposedRuleInterceptor_003
284 * @tc.desc: DisposedRuleInterceptor
285 * @tc.type: FUNC
286 * @tc.require: issueI8D3OD
287 */
288 HWTEST_F(AbilityInterceptorTest, DisposedRuleInterceptor_003, TestSize.Level1)
289 {
290 std::shared_ptr<AbilityInterceptorExecuter> executer = std::make_shared<AbilityInterceptorExecuter>();
291 Want want;
292 ElementName element("", "com.acts.disposedrulehap", "MainAbility3", "entry");
293 want.SetElement(element);
294 int requestCode = 0;
295 int userId = 100;
296 executer->AddInterceptor("DisposedRule", std::make_shared<DisposedRuleInterceptor>());
__anon79b807420b02() 297 auto shouldBlockFunc = []() { return false; };
298 AbilityInterceptorParam param = AbilityInterceptorParam(want, requestCode, userId, true, nullptr,
299 shouldBlockFunc);
300 int result = executer->DoProcess(param);
301 EXPECT_EQ(result, ERR_OK);
302 }
303
304 /**
305 * @tc.name: AbilityInterceptorTest_DisposedRuleInterceptor_004
306 * @tc.desc: DisposedRuleInterceptor
307 * @tc.type: FUNC
308 * @tc.require: issueI8D3OD
309 */
310 HWTEST_F(AbilityInterceptorTest, DisposedRuleInterceptor_004, TestSize.Level1)
311 {
312 std::shared_ptr<AbilityInterceptorExecuter> executer = std::make_shared<AbilityInterceptorExecuter>();
313 Want want;
314 ElementName element("", "com.acts.disposedrulehap", "MainAbility4", "entry");
315 want.SetElement(element);
316 int requestCode = 0;
317 int userId = 100;
318 executer->AddInterceptor("DisposedRule", std::make_shared<DisposedRuleInterceptor>());
__anon79b807420c02() 319 auto shouldBlockFunc = []() { return false; };
320 AbilityInterceptorParam param = AbilityInterceptorParam(want, requestCode, userId, true, nullptr,
321 shouldBlockFunc);
322 int result = executer->DoProcess(param);
323 EXPECT_EQ(result, ERR_OK);
324 }
325
326 /**
327 * @tc.name: AbilityInterceptorTest_DisposedRuleInterceptor_005
328 * @tc.desc: DisposedRuleInterceptor
329 * @tc.type: FUNC
330 * @tc.require: issueI8D3OD
331 */
332 HWTEST_F(AbilityInterceptorTest, DisposedRuleInterceptor_005, TestSize.Level1)
333 {
334 std::shared_ptr<AbilityInterceptorExecuter> executer = std::make_shared<AbilityInterceptorExecuter>();
335 Want want;
336 ElementName element("", "com.test.disposedrule", "MainAbility", "entry");
337 want.SetElement(element);
338 int requestCode = 0;
339 int userId = 100;
340 executer->AddInterceptor("DisposedRule", std::make_shared<DisposedRuleInterceptor>());
__anon79b807420d02() 341 auto shouldBlockFunc = []() { return false; };
342 AbilityInterceptorParam param = AbilityInterceptorParam(want, requestCode, userId, true, nullptr,
343 shouldBlockFunc);
344 int result = executer->DoProcess(param);
345 EXPECT_EQ(result, ERR_OK);
346 }
347
348 /**
349 * @tc.name: AbilityInterceptorTest_DisposedRuleInterceptor_006
350 * @tc.desc: DisposedRuleInterceptor
351 * @tc.type: FUNC
352 * @tc.require: No
353 */
354 HWTEST_F(AbilityInterceptorTest, DisposedRuleInterceptor_006, TestSize.Level1)
355 {
356 std::shared_ptr<DisposedRuleInterceptor> executer = std::make_shared<DisposedRuleInterceptor>();
357 Want want;
358 ElementName element("", "com.test.disposedrule", "MainAbility5", "entry");
359 want.SetElement(element);
360 int requestCode = 0;
361 int userId = 100;
__anon79b807420e02() 362 auto shouldBlockFunc = []() { return false; };
363 AbilityInterceptorParam param = AbilityInterceptorParam(want, requestCode, userId, true, nullptr,
364 shouldBlockFunc);
365 int result = executer->DoProcess(param);
366 EXPECT_EQ(result, ERR_OK);
367 }
368
369 /**
370 * @tc.name: AbilityInterceptorTest_DisposedRuleInterceptor_007
371 * @tc.desc: DisposedRuleInterceptor
372 * @tc.type: FUNC
373 * @tc.require: No
374 */
375 HWTEST_F(AbilityInterceptorTest, DisposedRuleInterceptor_007, TestSize.Level1)
376 {
377 std::shared_ptr<DisposedRuleInterceptor> executer = std::make_shared<DisposedRuleInterceptor>();
378 Want want;
379 ElementName element("", "com.test.disposedrule", "MainAbility6", "entry");
380 want.SetElement(element);
381 AppExecFwk::DisposedRule disposedRule;
382 bool result = executer->CheckDisposedRule(want, disposedRule);
383 EXPECT_EQ(result, false);
384 }
385
386 /**
387 * @tc.name: AbilityInterceptorTest_DisposedRuleInterceptor_008
388 * @tc.desc: DisposedRuleInterceptor
389 * @tc.type: FUNC
390 * @tc.require: No
391 */
392 HWTEST_F(AbilityInterceptorTest, DisposedRuleInterceptor_008, TestSize.Level1)
393 {
394 std::shared_ptr<DisposedRuleInterceptor> executer = std::make_shared<DisposedRuleInterceptor>();
395 Want want;
396 ElementName element("", "com.test.disposedrule", "MainAbility6", "entry");
397 want.SetElement(element);
398 AppExecFwk::DisposedRule disposedRule;
399 disposedRule.disposedType = AppExecFwk::DisposedType::NON_BLOCK;
400 bool result = executer->CheckDisposedRule(want, disposedRule);
401 EXPECT_EQ(result, false);
402 }
403
404 /**
405 * @tc.name: AbilityInterceptorTest_DisposedRuleInterceptor_009
406 * @tc.desc: DisposedRuleInterceptor
407 * @tc.type: FUNC
408 * @tc.require: No
409 */
410 HWTEST_F(AbilityInterceptorTest, DisposedRuleInterceptor_009, TestSize.Level1)
411 {
412 std::shared_ptr<DisposedRuleInterceptor> executer = std::make_shared<DisposedRuleInterceptor>();
413 Want want;
414 ElementName element("", "com.test.disposedrule", "MainAbility6", "entry");
415 want.SetElement(element);
416 AppExecFwk::DisposedRule disposedRule;
417 disposedRule.disposedType = AppExecFwk::DisposedType::BLOCK_APPLICATION;
418 bool result = executer->CheckDisposedRule(want, disposedRule);
419 EXPECT_EQ(result, false);
420 }
421
422 /**
423 * @tc.name: AbilityInterceptorTest_DisposedRuleInterceptor_010
424 * @tc.desc: DisposedRuleInterceptor
425 * @tc.type: FUNC
426 * @tc.require: No
427 */
428 HWTEST_F(AbilityInterceptorTest, DisposedRuleInterceptor_010, TestSize.Level1)
429 {
430 std::shared_ptr<DisposedRuleInterceptor> executer = std::make_shared<DisposedRuleInterceptor>();
431 Want want;
432 ElementName element("", "com.test.disposedrule", "MainAbility6", "entry");
433 want.SetElement(element);
434 AppExecFwk::DisposedRule disposedRule;
435 disposedRule.disposedType = AppExecFwk::DisposedType::BLOCK_APPLICATION;
436 disposedRule.controlType = AppExecFwk::ControlType::ALLOWED_LIST;
437 bool result = executer->CheckDisposedRule(want, disposedRule);
438 EXPECT_EQ(result, false);
439 }
440
441 /**
442 * @tc.name: AbilityInterceptorTest_DisposedRuleInterceptor_011
443 * @tc.desc: DisposedRuleInterceptor
444 * @tc.type: FUNC
445 * @tc.require: No
446 */
447 HWTEST_F(AbilityInterceptorTest, DisposedRuleInterceptor_011, TestSize.Level1)
448 {
449 std::shared_ptr<DisposedRuleInterceptor> executer = std::make_shared<DisposedRuleInterceptor>();
450 Want want;
451 ElementName element("", "com.test.disposedrule", "MainAbility6", "entry");
452 want.SetElement(element);
453 AppExecFwk::DisposedRule disposedRule;
454 disposedRule.disposedType = AppExecFwk::DisposedType::BLOCK_APPLICATION;
455 disposedRule.controlType = AppExecFwk::ControlType::DISALLOWED_LIST;
456 bool result = executer->CheckDisposedRule(want, disposedRule);
457 EXPECT_EQ(result, true);
458 }
459
460 /**
461 * @tc.name: AbilityInterceptorTest_DisposedRuleInterceptor_012
462 * @tc.desc: DisposedRuleInterceptor
463 * @tc.type: FUNC
464 * @tc.require: No
465 */
466 HWTEST_F(AbilityInterceptorTest, DisposedRuleInterceptor_012, TestSize.Level1)
467 {
468 std::shared_ptr<DisposedRuleInterceptor> executer = std::make_shared<DisposedRuleInterceptor>();
469 Want want;
470 AppExecFwk::DisposedRule disposedRule;
471 ErrCode result = executer->StartNonBlockRule(want, disposedRule, 0);
472 EXPECT_EQ(result, ERR_OK);
473 }
474
475 /**
476 * @tc.name: AbilityInterceptorTest_DisposedRuleInterceptor_013
477 * @tc.desc: DisposedRuleInterceptor
478 * @tc.type: FUNC
479 * @tc.require: No
480 */
481 HWTEST_F(AbilityInterceptorTest, DisposedRuleInterceptor_013, TestSize.Level1)
482 {
483 std::shared_ptr<DisposedRuleInterceptor> executer = std::make_shared<DisposedRuleInterceptor>();
484 std::string bundleName = "com.example.disposedruletest1";
485 Want want;
486 want.SetBundle(bundleName);
487 DisposedRule disposedRule;
488 ErrCode result = executer->StartNonBlockRule(want, disposedRule, 0);
489 EXPECT_EQ(result, ERR_OK);
490 }
491
492 /**
493 * @tc.name: AbilityInterceptorTest_DisposedRuleInterceptor_014
494 * @tc.desc: DisposedRuleInterceptor
495 * @tc.type: FUNC
496 * @tc.require: No
497 */
498 HWTEST_F(AbilityInterceptorTest, DisposedRuleInterceptor_014, TestSize.Level1)
499 {
500 std::shared_ptr<DisposedRuleInterceptor> executer = std::make_shared<DisposedRuleInterceptor>();
501 Want want;
502 ElementName element("", "com.acts.disposedrulehap", "MainAbility", "entry");
503 want.SetElement(element);
504 int requestCode = 0;
505 int userId = 100;
__anon79b807420f02() 506 auto shouldBlockFunc = []() { return false; };
507 AbilityInterceptorParam param = AbilityInterceptorParam(want, requestCode, userId, true, nullptr,
508 shouldBlockFunc);
509 executer->DoProcess(param);
510 EXPECT_NE(executer->GetAppMgr(), nullptr);
511 }
512
513 /**
514 * @tc.name: AbilityInterceptorTest_DisposedRuleInterceptor_015
515 * @tc.desc: DisposedRuleInterceptor
516 * @tc.type: FUNC
517 * @tc.require: No
518 */
519 HWTEST_F(AbilityInterceptorTest, DisposedRuleInterceptor_015, TestSize.Level1)
520 {
521 std::shared_ptr<DisposedRuleInterceptor> executer = std::make_shared<DisposedRuleInterceptor>();
522 std::string bundleName = "com.example.disposedruletest";
523 Want want;
524 want.SetBundle(bundleName);
525 sptr<IRemoteObject> callerToken;
526 ErrCode result = executer->CreateModalUIExtension(want, callerToken);
527 EXPECT_EQ(result, INNER_ERR);
528 }
529
530 /**
531 * @tc.name: AbilityInterceptorTest_AbilityJumpInterceptor_001
532 * @tc.desc: DoProcess
533 * @tc.type: FUNC
534 * @tc.require: No
535 */
536 HWTEST_F(AbilityInterceptorTest, AbilityJumpInterceptor_001, TestSize.Level1)
537 {
538 std::shared_ptr<AbilityJumpInterceptor> interceptor = std::make_shared<AbilityJumpInterceptor>();
539 Want want;
540 int requestCode = 0;
541 int userId = 100;
__anon79b807421002() 542 auto shouldBlockFunc = []() { return false; };
543 AbilityInterceptorParam param = AbilityInterceptorParam(want, requestCode, userId, false, nullptr,
544 shouldBlockFunc);
545 int result = interceptor->DoProcess(param);
546 EXPECT_EQ(result, ERR_OK);
547 }
548
549 /**
550 * @tc.name: AbilityInterceptorTest_AbilityJumpInterceptor_002
551 * @tc.desc: DoProcess
552 * @tc.type: FUNC
553 * @tc.require: No
554 */
555 HWTEST_F(AbilityInterceptorTest, AbilityJumpInterceptor_002, TestSize.Level1)
556 {
557 std::shared_ptr<AbilityJumpInterceptor> interceptor = std::make_shared<AbilityJumpInterceptor>();
558 std::string bundleName = "interceptor_callerBundleName";
559 Want want;
560 want.SetBundle(bundleName);
561 int requestCode = 0;
562 int userId = 100;
__anon79b807421102() 563 auto shouldBlockFunc = []() { return false; };
564 AbilityInterceptorParam param = AbilityInterceptorParam(want, requestCode, userId, true, nullptr,
565 shouldBlockFunc);
566 int result = interceptor->DoProcess(param);
567 EXPECT_EQ(result, ERR_OK);
568 }
569
570 /**
571 * @tc.name: AbilityInterceptorTest_AbilityJumpInterceptor_003
572 * @tc.desc: DoProcess
573 * @tc.type: FUNC
574 * @tc.require: No
575 */
576 HWTEST_F(AbilityInterceptorTest, AbilityJumpInterceptor_003, TestSize.Level1)
577 {
578 std::shared_ptr<AbilityJumpInterceptor> interceptor = std::make_shared<AbilityJumpInterceptor>();
579 Want want;
580 ElementName element("", "com.test.jumpinterceptor", "MainAbility", "entry");
581 want.SetElement(element);
582 int requestCode = 1;
583 int userId = 100;
__anon79b807421202() 584 auto shouldBlockFunc = []() { return false; };
585 AbilityInterceptorParam param = AbilityInterceptorParam(want, requestCode, userId, true, nullptr,
586 shouldBlockFunc);
587 int result = interceptor->DoProcess(param);
588 EXPECT_EQ(result, ERR_OK);
589 }
590
591 /**
592 * @tc.name: AbilityInterceptorTest_AbilityJumpInterceptor_004
593 * @tc.desc: CheckControl
594 * @tc.type: FUNC
595 * @tc.require: No
596 */
597 HWTEST_F(AbilityInterceptorTest, AbilityJumpInterceptor_004, TestSize.Level1)
598 {
599 std::shared_ptr<AbilityJumpInterceptor> interceptor = std::make_shared<AbilityJumpInterceptor>();
600 std::shared_ptr<AppExecFwk::BundleMgrHelper> bundleMgrHelper = std::make_shared<AppExecFwk::BundleMgrHelper>();
601 Want want;
602 int32_t userId = 10;
603 AppExecFwk::AppJumpControlRule controlRule;
604 bool result = interceptor->CheckControl(bundleMgrHelper, want, userId, controlRule);
605 EXPECT_EQ(result, false);
606 }
607
608 /**
609 * @tc.name: AbilityInterceptorTest_AbilityJumpInterceptor_005
610 * @tc.desc: CheckControl
611 * @tc.type: FUNC
612 * @tc.require: No
613 */
614 HWTEST_F(AbilityInterceptorTest, AbilityJumpInterceptor_005, TestSize.Level1)
615 {
616 std::shared_ptr<AbilityJumpInterceptor> interceptor = std::make_shared<AbilityJumpInterceptor>();
617 std::shared_ptr<AppExecFwk::BundleMgrHelper> bundleMgrHelper = std::make_shared<AppExecFwk::BundleMgrHelper>();
618 std::string bundleName = "interceptor_callerBundleName";
619 Want want;
620 int32_t userId = 10;
621 AppExecFwk::AppJumpControlRule controlRule;
622 bool result = interceptor->CheckControl(bundleMgrHelper, want, userId, controlRule);
623 EXPECT_EQ(result, false);
624 }
625
626 /**
627 * @tc.name: AbilityInterceptorTest_AbilityJumpInterceptor_006
628 * @tc.desc: CheckControl
629 * @tc.type: FUNC
630 * @tc.require: No
631 */
632 HWTEST_F(AbilityInterceptorTest, AbilityJumpInterceptor_006, TestSize.Level1)
633 {
634 std::shared_ptr<AbilityJumpInterceptor> interceptor = std::make_shared<AbilityJumpInterceptor>();
635 std::shared_ptr<AppExecFwk::BundleMgrHelper> bundleMgrHelper = std::make_shared<AppExecFwk::BundleMgrHelper>();
636 std::string bundleName = "interceptor_callerBundleName";
637 Want want;
638 want.SetBundle(bundleName);
639 int32_t userId = 10;
640 AppExecFwk::AppJumpControlRule controlRule;
641 controlRule.callerPkg = "interceptor_callerBundleName";
642 bool result = interceptor->CheckControl(bundleMgrHelper, want, userId, controlRule);
643 EXPECT_EQ(result, false);
644 }
645
646 /**
647 * @tc.name: AbilityInterceptorTest_AbilityJumpInterceptor_007
648 * @tc.desc: CheckControl
649 * @tc.type: FUNC
650 * @tc.require: No
651 */
652 HWTEST_F(AbilityInterceptorTest, AbilityJumpInterceptor_007, TestSize.Level1)
653 {
654 std::shared_ptr<AbilityJumpInterceptor> interceptor = std::make_shared<AbilityJumpInterceptor>();
655 std::shared_ptr<AppExecFwk::BundleMgrHelper> bundleMgrHelper = std::make_shared<AppExecFwk::BundleMgrHelper>();
656 std::string bundleName = "BundleName";
657 Want want;
658 want.SetBundle(bundleName);
659 int32_t userId = 10;
660 AppExecFwk::AppJumpControlRule controlRule;
661 controlRule.callerPkg = "interceptor_callerBundleName";
662 bool result = interceptor->CheckControl(bundleMgrHelper, want, userId, controlRule);
663 EXPECT_EQ(result, false);
664 }
665
666 /**
667 * @tc.name: AbilityInterceptorTest_AbilityJumpInterceptor_008
668 * @tc.desc: CheckIfJumpExempt
669 * @tc.type: FUNC
670 * @tc.require: No
671 */
672 HWTEST_F(AbilityInterceptorTest, AbilityJumpInterceptor_008, TestSize.Level1)
673 {
674 std::shared_ptr<AbilityJumpInterceptor> interceptor = std::make_shared<AbilityJumpInterceptor>();
675 AppExecFwk::AppJumpControlRule controlRule;
676 controlRule.callerPkg = "interceptor_callerBundleName";
677 int32_t userId = 10;
678 bool result = interceptor->CheckIfJumpExempt(controlRule, userId);
679 EXPECT_EQ(result, false);
680 }
681
682 /**
683 * @tc.name: AbilityInterceptorTest_AbilityJumpInterceptor_009
684 * @tc.desc: CheckIfJumpExempt
685 * @tc.type: FUNC
686 * @tc.require: No
687 */
688 HWTEST_F(AbilityInterceptorTest, AbilityJumpInterceptor_009, TestSize.Level1)
689 {
690 std::shared_ptr<AbilityJumpInterceptor> interceptor = std::make_shared<AbilityJumpInterceptor>();
691 AppExecFwk::AppJumpControlRule controlRule;
692 controlRule.targetPkg = "interceptor_callerBundleName";
693 int32_t userId = 10;
694 bool result = interceptor->CheckIfJumpExempt(controlRule, userId);
695 EXPECT_EQ(result, false);
696 }
697
698 /**
699 * @tc.name: AbilityInterceptorTest_AbilityJumpInterceptor_010
700 * @tc.desc: CheckIfExemptByBundleName
701 * @tc.type: FUNC
702 * @tc.require: No
703 */
704 HWTEST_F(AbilityInterceptorTest, AbilityJumpInterceptor_010, TestSize.Level1)
705 {
706 std::shared_ptr<AbilityJumpInterceptor> interceptor = std::make_shared<AbilityJumpInterceptor>();
707 std::string bundleName = "interceptor_callerBundleName";
708 std::string permission = PermissionConstants::PERMISSION_EXEMPT_AS_CALLER;
709 int32_t userId = 10;
710 bool result = interceptor->CheckIfExemptByBundleName(bundleName, permission, userId);
711 EXPECT_EQ(result, false);
712 }
713
714 /**
715 * @tc.name: AbilityInterceptorTest_AbilityJumpInterceptor_011
716 * @tc.desc: CheckIfExemptByBundleName
717 * @tc.type: FUNC
718 * @tc.require: No
719 */
720 HWTEST_F(AbilityInterceptorTest, AbilityJumpInterceptor_011, TestSize.Level1)
721 {
722 std::shared_ptr<AbilityJumpInterceptor> interceptor = std::make_shared<AbilityJumpInterceptor>();
723 std::string bundleName = "interceptor_callerBundleName";
724 Want want;
725 want.SetBundle(bundleName);
726 int32_t abilityuserId = 0;
727 int32_t appIndex = 0;
728 StartAbilityUtils::startAbilityInfo = StartAbilityInfo::CreateStartExtensionInfo(want,
729 abilityuserId, appIndex);
730 std::string permission = PermissionConstants::PERMISSION_EXEMPT_AS_CALLER;
731 int32_t userId = 10;
732 bool result = interceptor->CheckIfExemptByBundleName(bundleName, permission, userId);
733 EXPECT_EQ(result, false);
734 }
735
736 /**
737 * @tc.name: AbilityInterceptorTest_EcologicalRuleInterceptor_001
738 * @tc.desc: DoProcess
739 * @tc.type: FUNC
740 * @tc.require: No
741 */
742 HWTEST_F(AbilityInterceptorTest, EcologicalRuleInterceptor_001, TestSize.Level1)
743 {
744 std::shared_ptr<EcologicalRuleInterceptor> interceptor = std::make_shared<EcologicalRuleInterceptor>();
745 Want want;
746 int requestCode = 0;
747 int userId = 100;
__anon79b807421302() 748 auto shouldBlockFunc = []() { return false; };
749 AbilityInterceptorParam param = AbilityInterceptorParam(want, requestCode, userId, false, nullptr,
750 shouldBlockFunc);
751 ErrCode result = interceptor->DoProcess(param);
752 EXPECT_EQ(result, ERR_OK);
753 }
754
755 /**
756 * @tc.name: AbilityInterceptorTest_EcologicalRuleInterceptor_002
757 * @tc.desc: DoProcess
758 * @tc.type: FUNC
759 * @tc.require: No
760 */
761 HWTEST_F(AbilityInterceptorTest, EcologicalRuleInterceptor_002, TestSize.Level1)
762 {
763 std::shared_ptr<EcologicalRuleInterceptor> interceptor = std::make_shared<EcologicalRuleInterceptor>();
764 std::string bundleName = "com.ohos.sceneboard";
765 Want want;
766 want.SetBundle(bundleName);
767 int requestCode = 0;
768 int userId = 100;
769 sptr<IRemoteObject> token;
__anon79b807421402() 770 auto shouldBlockFunc = []() { return false; };
771 AbilityInterceptorParam param = AbilityInterceptorParam(want, requestCode, userId, true, token,
772 shouldBlockFunc);
773 ErrCode result = interceptor->DoProcess(param);
774 EXPECT_EQ(result, ERR_OK);
775 }
776
777 /**
778 * @tc.name: AbilityInterceptorTest_EcologicalRuleInterceptor_003
779 * @tc.desc: DoProcess
780 * @tc.type: FUNC
781 * @tc.require: No
782 */
783 HWTEST_F(AbilityInterceptorTest, EcologicalRuleInterceptor_003, TestSize.Level1)
784 {
785 std::shared_ptr<EcologicalRuleInterceptor> interceptor = std::make_shared<EcologicalRuleInterceptor>();
786 Want want;
787 int userId = 100;
788 bool result = interceptor->DoProcess(want, userId);
789 EXPECT_EQ(result, true);
790 }
791 } // namespace AAFwk
792 } // namespace OHOS
793