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