1 /*
2  * Copyright (c) 2022 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 #include <string>
18 #include <map>
19 
20 #define private public
21 #include "ability_delegator.h"
22 #include "ability_manager_client.h"
23 #undef private
24 
25 #include "ability_delegator_infos.h"
26 #include "ability_delegator_registry.h"
27 #include "app_loader.h"
28 #include "context_impl.h"
29 #include "hilog_tag_wrapper.h"
30 #include "mock_ability_delegator_stub.h"
31 #include "mock_iability_monitor.h"
32 #include "mock_test_observer_stub.h"
33 #include "ohos_application.h"
34 #include "test_observer_stub.h"
35 #include "test_observer.h"
36 #include "test_runner.h"
37 #include "want.h"
38 #include "scene_board_judgement.h"
39 
40 using namespace testing::ext;
41 using namespace OHOS;
42 using namespace OHOS::AppExecFwk;
43 using namespace OHOS::AAFwk;
44 
45 namespace {
46 const std::string KEY_TEST_BUNDLE_NAME = "-p";
47 const std::string VALUE_TEST_BUNDLE_NAME = "com.example.myapplication";
48 const std::string CHANGE_VALUE_TEST_BUNDLE_NAME = "com.example.myapplicationmodule";
49 const std::string KEY_TEST_RUNNER_CLASS = "-s unittest";
50 const std::string VALUE_TEST_RUNNER_CLASS = "JSUserTestRunner";
51 const std::string CHANGE_VALUE_TEST_RUNNER_CLASS = "JSUserTestRunnermodule";
52 const std::string KEY_TEST_CASE = "-s class";
53 const std::string VALUE_TEST_CASE = "ohos.acts.aafwk.ability.test.ConstructorTest#testDataAbilityOtherFunction0010";
54 const std::string CHANGE_VALUE_TEST_CASE =
55     "ohos.acts.aafwk.ability.test.ConstructorTest#testDataAbilityOtherFunction0010module";
56 const std::string KEY_TEST_WAIT_TIMEOUT = "-w";
57 const std::string VALUE_TEST_WAIT_TIMEOUT = "20";
58 const std::string CHANGE_VALUE_TEST_WAIT_TIMEOUT = "40";
59 const std::string SET_VALUE_TEST_BUNDLE_NAME = "com.example.myapplicationset";
60 const std::string ABILITY_NAME = "com.example.myapplication.MainAbility";
61 const std::string FINISH_MSG = "finish message";
62 const int32_t FINISH_RESULT_CODE = 144;
63 const std::string PRINT_MSG = "print aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
64 const int ZERO = 0;
65 const int ONE = 1;
66 const int TWO = 2;
67 const int64_t TIMEOUT = 50;
68 const std::string CMD = "ls -l";
69 const std::string PROPERTY_ABILITY_STAGE_MODULE_NAME = "com.example.entry_test";
70 const std::string PROPERTY_ABILITY_STAGE_SOURCE_ENTRANCE = "./ets/Application/TestAbilityStage.ts";
71 }  // namespace
72 
73 class AbilityDelegatorModuleTest : public ::testing::Test {
74 public:
75     static void SetUpTestCase();
76     static void TearDownTestCase();
77     void SetUp() override;
78     void TearDown() override;
79     void MakeMockObjects() const;
80 };
81 
SetUpTestCase()82 void AbilityDelegatorModuleTest::SetUpTestCase()
83 {}
84 
TearDownTestCase()85 void AbilityDelegatorModuleTest::TearDownTestCase()
86 {}
87 
SetUp()88 void AbilityDelegatorModuleTest::SetUp()
89 {
90     // reset optind to 0
91     optind = 0;
92 
93     // make mock objects
94     MakeMockObjects();
95 }
96 
TearDown()97 void AbilityDelegatorModuleTest::TearDown()
98 {}
99 
MakeMockObjects() const100 void AbilityDelegatorModuleTest::MakeMockObjects() const
101 {
102     // mock a stub
103     auto managerStubPtr = sptr<OHOS::AAFwk::IAbilityManager>(new MockAbilityDelegatorStub);
104 
105     // set the mock stub
106     auto managerClientPtr = AbilityManagerClient::GetInstance();
107     managerClientPtr->proxy_ = managerStubPtr;
108 }
109 
110 class AbilityDelegatorModuleTest2 : public ::testing::Test {
111 public:
112     static void SetUpTestCase();
113     static void TearDownTestCase();
114     void SetUp() override;
115     void TearDown() override;
116     void MakeMockObjects() const;
117 };
118 
SetUpTestCase()119 void AbilityDelegatorModuleTest2::SetUpTestCase()
120 {}
121 
TearDownTestCase()122 void AbilityDelegatorModuleTest2::TearDownTestCase()
123 {}
124 
SetUp()125 void AbilityDelegatorModuleTest2::SetUp()
126 {
127     // reset optind to 0
128     optind = 0;
129 
130     // make mock objects
131     MakeMockObjects();
132 }
133 
TearDown()134 void AbilityDelegatorModuleTest2::TearDown()
135 {}
136 
MakeMockObjects() const137 void AbilityDelegatorModuleTest2::MakeMockObjects() const
138 {
139     // mock a stub
140     auto managerStubPtr = sptr<OHOS::AAFwk::IAbilityManager>(new MockAbilityDelegatorStub2);
141 
142     // set the mock stub
143     auto managerClientPtr = AbilityManagerClient::GetInstance();
144     managerClientPtr->proxy_ = managerStubPtr;
145 }
146 
147 /**
148  * @tc.number: Ability_Delegator_Args_Test_0100
149  * @tc.name: ClearAllMonitors and AddAbilityMonitor and GetMonitorsNum
150  * @tc.desc: Verify the ClearAllMonitors and AddAbilityMonitor and GetMonitorsNum.
151  */
152 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_0100, Function | MediumTest | Level1)
153 {
154     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_0100 is called");
155     std::map<std::string, std::string> paras;
156     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
157     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
158     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
159     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
160 
161     Want want;
162     for (auto para : paras) {
163         want.SetParam(para.first, para.second);
164     }
165 
166     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
167     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
168         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
169         std::make_shared<AbilityDelegatorArgs>(want),
170         true);
171     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
172     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
173 
174     abilityDelegator.ClearAllMonitors();
175     std::shared_ptr<IAbilityMonitor> imotor = std::make_shared<IAbilityMonitor>(ABILITY_NAME);
176     std::shared_ptr<IAbilityMonitor> imotor1 = std::make_shared<IAbilityMonitor>(ABILITY_NAME);
177 
178     abilityDelegator.AddAbilityMonitor(imotor);
179     EXPECT_EQ((int)(abilityDelegator.GetMonitorsNum()), ONE);
180     abilityDelegator.AddAbilityMonitor(imotor);
181     EXPECT_EQ((int)(abilityDelegator.GetMonitorsNum()), ONE);
182     abilityDelegator.AddAbilityMonitor(imotor1);
183     EXPECT_EQ((int)(abilityDelegator.GetMonitorsNum()), TWO);
184 }
185 
186 /**
187  * @tc.number: Ability_Delegator_Args_Test_0200
188  * @tc.name: ClearAllMonitors and AddAbilityMonitor and RemoveAbilityMonitor and GetMonitorsNum
189  * @tc.desc: Verify the AddAbilityMonitor and RemoveAbilityMonitor.
190  */
191 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_0200, Function | MediumTest | Level1)
192 {
193     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_0200 is called");
194     std::map<std::string, std::string> paras;
195     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
196     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
197     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
198     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
199 
200     Want want;
201     for (auto para : paras) {
202         want.SetParam(para.first, para.second);
203     }
204 
205     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
206     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
207         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
208         std::make_shared<AbilityDelegatorArgs>(want),
209         true);
210     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
211     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
212 
213     std::shared_ptr<IAbilityMonitor> imotor = std::make_shared<IAbilityMonitor>(ABILITY_NAME);
214     abilityDelegator.ClearAllMonitors();
215     abilityDelegator.AddAbilityMonitor(imotor);
216     EXPECT_EQ((int)(abilityDelegator.GetMonitorsNum()), ONE);
217     abilityDelegator.RemoveAbilityMonitor(imotor);
218     EXPECT_EQ((int)(abilityDelegator.GetMonitorsNum()), ZERO);
219 }
220 
221 /**
222  * @tc.number: Ability_Delegator_Args_Test_0300
223  * @tc.name: GetAbilityState
224  * @tc.desc: Verify the GetAbilityState input para is valid.
225  */
226 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_0300, Function | MediumTest | Level1)
227 {
228     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_0300 is called");
229     std::map<std::string, std::string> paras;
230     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
231     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
232     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
233     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
234 
235     Want want;
236     for (auto para : paras) {
237         want.SetParam(para.first, para.second);
238     }
239 
240     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
241     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
242         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
243         std::make_shared<AbilityDelegatorArgs>(want),
244         true);
245     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
246     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
247 
248     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
249     std::shared_ptr<ADelegatorAbilityProperty> abilityProperty = std::make_shared<ADelegatorAbilityProperty>();
250     abilityProperty->token_ = token;
251     abilityProperty->name_ = ABILITY_NAME;
252     abilityProperty->lifecycleState_ = AbilityLifecycleExecutor::LifecycleState::STARTED_NEW;
253     abilityDelegator.abilityProperties_.emplace_front(abilityProperty);
254     int abilityState = static_cast<int>(abilityDelegator.GetAbilityState(token));
255 
256     EXPECT_EQ(abilityState, static_cast<int>(AbilityDelegator::AbilityState::STARTED));
257 }
258 
259 /**
260  * @tc.number: Ability_Delegator_Args_Test_0400
261  * @tc.name: GetAbilityState
262  * @tc.desc: Verify the GetAbilityState input para is valid but not find in abilityProperties_.
263  */
264 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_0400, Function | MediumTest | Level1)
265 {
266     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_0400 is called");
267     std::map<std::string, std::string> paras;
268     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
269     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
270     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
271     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
272 
273     Want want;
274     for (auto para : paras) {
275         want.SetParam(para.first, para.second);
276     }
277 
278     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
279     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
280         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
281         std::make_shared<AbilityDelegatorArgs>(want),
282         true);
283     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
284     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
285 
286     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
287     int abilityState = static_cast<int>(abilityDelegator.GetAbilityState(token));
288 
289     EXPECT_EQ(abilityState, static_cast<int>(AbilityDelegator::AbilityState::UNINITIALIZED));
290 }
291 
292 /**
293  * @tc.number: Ability_Delegator_Args_Test_0500
294  * @tc.name: GetCurrentTopAbility
295  * @tc.desc: Verify the GetCurrentTopAbility is valid.
296  */
297 HWTEST_F(AbilityDelegatorModuleTest2, Ability_Delegator_Args_Test_0500, Function | MediumTest | Level1)
298 {
299     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_0500 is called");
300     std::map<std::string, std::string> paras;
301     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
302     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
303     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
304     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
305 
306     Want want;
307     for (auto para : paras) {
308         want.SetParam(para.first, para.second);
309     }
310 
311     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
312     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
313         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
314         std::make_shared<AbilityDelegatorArgs>(want),
315         true);
316     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub2());
317     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
318     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub2);
319 
320     EXPECT_EQ(abilityDelegator.GetCurrentTopAbility(), nullptr);
321 }
322 
323 /**
324  * @tc.number: Ability_Delegator_Args_Test_0600
325  * @tc.name: DoAbilityForeground
326  * @tc.desc: Verify the DoAbilityForeground is valid.
327  */
328 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_0600, Function | MediumTest | Level1)
329 {
330     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_0600 is called");
331     std::map<std::string, std::string> paras;
332     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
333     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
334     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
335     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
336 
337     Want want;
338     for (auto para : paras) {
339         want.SetParam(para.first, para.second);
340     }
341 
342     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
343     EXPECT_TRUE(context != nullptr);
344     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
345         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
346         std::make_shared<AbilityDelegatorArgs>(want),
347         true);
348     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
349     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
350 
351     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
352 
353     if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
354         EXPECT_TRUE(abilityDelegator.DoAbilityForeground(token));
355     }
356 }
357 
358 /**
359  * @tc.number: Ability_Delegator_Args_Test_0700
360  * @tc.name: DoAbilityBackground
361  * @tc.desc: Verify the DoAbilityBackground is valid.
362  */
363 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_0700, Function | MediumTest | Level1)
364 {
365     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_0700 is called");
366     std::map<std::string, std::string> paras;
367     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
368     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
369     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
370     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
371 
372     Want want;
373     for (auto para : paras) {
374         want.SetParam(para.first, para.second);
375     }
376 
377     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
378     EXPECT_TRUE(context != nullptr);
379     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
380         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
381         std::make_shared<AbilityDelegatorArgs>(want),
382         true);
383     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
384     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
385 
386     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
387 
388     if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
389         EXPECT_TRUE(abilityDelegator.DoAbilityForeground(token));
390     }
391 }
392 
393 /**
394  * @tc.number: Ability_Delegator_Args_Test_0800
395  * @tc.name: ExecuteShellCommand
396  * @tc.desc: Verify the ExecuteShellCommand is valid.
397  */
398 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_0800, Function | MediumTest | Level1)
399 {
400     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_0800 is called");
401     std::map<std::string, std::string> paras;
402     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
403     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
404     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
405     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
406 
407     Want want;
408     for (auto para : paras) {
409         want.SetParam(para.first, para.second);
410     }
411 
412     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
413     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
414         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
415         std::make_shared<AbilityDelegatorArgs>(want),
416         true);
417     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
418     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
419     sptr<IRemoteObject> shobserver = sptr<IRemoteObject>(new MockTestObserverStub);
420     abilityDelegator.observer_ = shobserver;
421 
422     EXPECT_NE(abilityDelegator.ExecuteShellCommand(CMD, TIMEOUT), nullptr);
423 }
424 
425 /**
426  * @tc.number: Ability_Delegator_Args_Test_0900
427  * @tc.name: Print
428  * @tc.desc: Verify the Print is invalid.
429  */
430 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_0900, Function | MediumTest | Level1)
431 {
432     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_0900 is called");
433     std::map<std::string, std::string> paras;
434     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
435     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
436     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
437     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
438 
439     Want want;
440     for (auto para : paras) {
441         want.SetParam(para.first, para.second);
442     }
443 
444     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
445     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
446         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
447         std::make_shared<AbilityDelegatorArgs>(want),
448         true);
449     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
450     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
451     sptr<IRemoteObject> shobserver = sptr<IRemoteObject>(new MockTestObserverStub);
452     abilityDelegator.observer_ = nullptr;
453     abilityDelegator.Print(PRINT_MSG);
454 
455     EXPECT_FALSE(iface_cast<MockTestObserverStub>(shobserver)->testStatusFlag);
456 }
457 
458 /**
459  * @tc.number: Ability_Delegator_Args_Test_1000
460  * @tc.name: ProcessAbilityProperties
461  * @tc.desc: Verify the ProcessAbilityProperties list is add.
462  */
463 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_1000, Function | MediumTest | Level1)
464 {
465     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_1000 is called");
466     std::map<std::string, std::string> paras;
467     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
468     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
469     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
470     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
471 
472     Want want;
473     for (auto para : paras) {
474         want.SetParam(para.first, para.second);
475     }
476 
477     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
478     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
479         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
480         std::make_shared<AbilityDelegatorArgs>(want),
481         true);
482     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
483     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
484 
485     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
486     std::shared_ptr<ADelegatorAbilityProperty> ability = std::make_shared<ADelegatorAbilityProperty>();
487     ability->token_ = token;
488     ability->name_ = ABILITY_NAME;
489     ability->lifecycleState_ = AbilityLifecycleExecutor::LifecycleState::STARTED_NEW;
490     abilityDelegator.abilityProperties_.clear();
491     abilityDelegator.PostPerformStart(ability);
492 
493     EXPECT_EQ(abilityDelegator.abilityProperties_.size(), ONE);
494 }
495 
496 /**
497  * @tc.number: Ability_Delegator_Args_Test_1100
498  * @tc.name: ProcessAbilityProperties
499  * @tc.desc: Verify the ProcessAbilityProperties list is not add.
500  */
501 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_1100, Function | MediumTest | Level1)
502 {
503     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_1100 is called");
504     std::map<std::string, std::string> paras;
505     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
506     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
507     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
508     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
509 
510     Want want;
511     for (auto para : paras) {
512         want.SetParam(para.first, para.second);
513     }
514 
515     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
516     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
517         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
518         std::make_shared<AbilityDelegatorArgs>(want),
519         true);
520     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
521     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
522     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
523     std::shared_ptr<ADelegatorAbilityProperty> ability = std::make_shared<ADelegatorAbilityProperty>();
524     ability->token_ = token;
525     ability->name_ = ABILITY_NAME;
526     ability->lifecycleState_ = AbilityLifecycleExecutor::LifecycleState::STARTED_NEW;
527     abilityDelegator.abilityProperties_.clear();
528     abilityDelegator.abilityProperties_.emplace_back(ability);
529     abilityDelegator.PostPerformStart(ability);
530     EXPECT_EQ(abilityDelegator.abilityProperties_.size(), ONE);
531 }
532 
533 /**
534  * @tc.number: Ability_Delegator_Args_Test_1200
535  * @tc.name: PostPerformStart
536  * @tc.desc: Verify the PostPerformStart is valid.
537  */
538 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_1200, Function | MediumTest | Level1)
539 {
540     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_1200 is called");
541     std::map<std::string, std::string> paras;
542     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
543     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
544     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
545     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
546 
547     Want want;
548     for (auto para : paras) {
549         want.SetParam(para.first, para.second);
550     }
551 
552     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
553     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
554         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
555         std::make_shared<AbilityDelegatorArgs>(want),
556         true);
557     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
558     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
559     std::shared_ptr<MockIabilityMonitor> mockMonitor = std::make_shared<MockIabilityMonitor>(ABILITY_NAME);
560     abilityDelegator.abilityMonitors_.clear();
561     abilityDelegator.abilityMonitors_.emplace_back(mockMonitor);
562     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
563     std::shared_ptr<ADelegatorAbilityProperty> ability = std::make_shared<ADelegatorAbilityProperty>();
564     ability->token_ = token;
565     ability->name_ = ABILITY_NAME;
566     ability->lifecycleState_ = AbilityLifecycleExecutor::LifecycleState::STARTED_NEW;
567     abilityDelegator.PostPerformStart(ability);
568 
569     EXPECT_TRUE(mockMonitor->start_);
570 }
571 
572 /**
573  * @tc.number: Ability_Delegator_Args_Test_1300
574  * @tc.name: PostPerformScenceCreated
575  * @tc.desc: Verify the PostPerformScenceCreated is valid.
576  */
577 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_1300, Function | MediumTest | Level1)
578 {
579     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_1300 is called");
580     std::map<std::string, std::string> paras;
581     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
582     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
583     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
584     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
585 
586     Want want;
587     for (auto para : paras) {
588         want.SetParam(para.first, para.second);
589     }
590 
591     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
592     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
593         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
594         std::make_shared<AbilityDelegatorArgs>(want),
595         true);
596     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
597     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
598     std::shared_ptr<MockIabilityMonitor> mockMonitor = std::make_shared<MockIabilityMonitor>(ABILITY_NAME);
599     abilityDelegator.abilityMonitors_.clear();
600     abilityDelegator.abilityMonitors_.emplace_back(mockMonitor);
601     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
602     std::shared_ptr<ADelegatorAbilityProperty> ability = std::make_shared<ADelegatorAbilityProperty>();
603     ability->token_ = token;
604     ability->name_ = ABILITY_NAME;
605     ability->lifecycleState_ = AbilityLifecycleExecutor::LifecycleState::STARTED_NEW;
606     abilityDelegator.PostPerformScenceCreated(ability);
607 
608     EXPECT_TRUE(mockMonitor->windowStageCreate_);
609 }
610 
611 /**
612  * @tc.number: Ability_Delegator_Args_Test_1400
613  * @tc.name: PostPerformScenceRestored
614  * @tc.desc: Verify the PostPerformScenceRestored is invalid.
615  */
616 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_1400, Function | MediumTest | Level1)
617 {
618     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_1400 is called");
619     std::map<std::string, std::string> paras;
620     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
621     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
622     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
623     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
624 
625     Want want;
626     for (auto para : paras) {
627         want.SetParam(para.first, para.second);
628     }
629 
630     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
631     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
632         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
633         std::make_shared<AbilityDelegatorArgs>(want),
634         true);
635     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
636     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
637     std::shared_ptr<MockIabilityMonitor> mockMonitor = std::make_shared<MockIabilityMonitor>(ABILITY_NAME);
638     abilityDelegator.abilityMonitors_.emplace_back(mockMonitor);
639     abilityDelegator.PostPerformScenceRestored(nullptr);
640 
641     EXPECT_FALSE(mockMonitor->windowStageRestore_);
642 }
643 
644 /**
645  * @tc.number: Ability_Delegator_Args_Test_1500
646  * @tc.name: PostPerformScenceRestored
647  * @tc.desc: Verify the PostPerformScenceRestored is valid.
648  */
649 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_1500, Function | MediumTest | Level1)
650 {
651     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_1500 is called");
652     std::map<std::string, std::string> paras;
653     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
654     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
655     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
656     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
657 
658     Want want;
659     for (auto para : paras) {
660         want.SetParam(para.first, para.second);
661     }
662 
663     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
664     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
665         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
666         std::make_shared<AbilityDelegatorArgs>(want),
667         true);
668     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
669     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
670     std::shared_ptr<MockIabilityMonitor> mockMonitor = std::make_shared<MockIabilityMonitor>(ABILITY_NAME);
671     abilityDelegator.abilityMonitors_.clear();
672     abilityDelegator.abilityMonitors_.emplace_back(mockMonitor);
673     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
674     std::shared_ptr<ADelegatorAbilityProperty> ability = std::make_shared<ADelegatorAbilityProperty>();
675     ability->token_ = token;
676     ability->name_ = ABILITY_NAME;
677     ability->lifecycleState_ = AbilityLifecycleExecutor::LifecycleState::STARTED_NEW;
678     abilityDelegator.PostPerformScenceRestored(ability);
679 
680     EXPECT_TRUE(mockMonitor->windowStageRestore_);
681 }
682 
683 /**
684  * @tc.number: Ability_Delegator_Args_Test_1600
685  * @tc.name: PostPerformScenceDestroyed
686  * @tc.desc: Verify the PostPerformScenceDestroyed is invalid.
687  */
688 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_1600, Function | MediumTest | Level1)
689 {
690     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_1600 is called");
691     std::map<std::string, std::string> paras;
692     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
693     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
694     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
695     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
696 
697     Want want;
698     for (auto para : paras) {
699         want.SetParam(para.first, para.second);
700     }
701 
702     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
703     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
704         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
705         std::make_shared<AbilityDelegatorArgs>(want),
706         true);
707     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
708     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
709     std::shared_ptr<MockIabilityMonitor> mockMonitor = std::make_shared<MockIabilityMonitor>(ABILITY_NAME);
710     abilityDelegator.abilityMonitors_.emplace_back(mockMonitor);
711     abilityDelegator.PostPerformScenceDestroyed(nullptr);
712 
713     EXPECT_FALSE(mockMonitor->windowStageDestroy_);
714 }
715 
716 /**
717  * @tc.number: Ability_Delegator_Args_Test_1700
718  * @tc.name: PostPerformScenceDestroyed
719  * @tc.desc: Verify the PostPerformScenceDestroyed is valid.
720  */
721 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_1700, Function | MediumTest | Level1)
722 {
723     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_1700 is called");
724     std::map<std::string, std::string> paras;
725     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
726     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
727     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
728     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
729 
730     Want want;
731     for (auto para : paras) {
732         want.SetParam(para.first, para.second);
733     }
734 
735     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
736     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
737         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
738         std::make_shared<AbilityDelegatorArgs>(want),
739         true);
740     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
741     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
742     std::shared_ptr<MockIabilityMonitor> mockMonitor = std::make_shared<MockIabilityMonitor>(ABILITY_NAME);
743     abilityDelegator.abilityMonitors_.clear();
744     abilityDelegator.abilityMonitors_.emplace_back(mockMonitor);
745     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
746     std::shared_ptr<ADelegatorAbilityProperty> ability = std::make_shared<ADelegatorAbilityProperty>();
747     ability->token_ = token;
748     ability->name_ = ABILITY_NAME;
749     ability->lifecycleState_ = AbilityLifecycleExecutor::LifecycleState::STARTED_NEW;
750     abilityDelegator.PostPerformScenceDestroyed(ability);
751 
752     EXPECT_TRUE(mockMonitor->windowStageDestroy_);
753 }
754 
755 /**
756  * @tc.number: Ability_Delegator_Args_Test_1800
757  * @tc.name: PostPerformForeground
758  * @tc.desc: Verify the PostPerformForeground is invalid.
759  */
760 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_1800, Function | MediumTest | Level1)
761 {
762     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_1800 is called");
763     std::map<std::string, std::string> paras;
764     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
765     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
766     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
767     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
768 
769     Want want;
770     for (auto para : paras) {
771         want.SetParam(para.first, para.second);
772     }
773 
774     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
775     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
776         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
777         std::make_shared<AbilityDelegatorArgs>(want),
778         true);
779     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
780     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
781     std::shared_ptr<MockIabilityMonitor> mockMonitor = std::make_shared<MockIabilityMonitor>(ABILITY_NAME);
782     abilityDelegator.abilityMonitors_.emplace_back(mockMonitor);
783     abilityDelegator.PostPerformForeground(nullptr);
784 
785     EXPECT_FALSE(mockMonitor->foreground_);
786 }
787 
788 /**
789  * @tc.number: Ability_Delegator_Args_Test_1900
790  * @tc.name: PostPerformForeground
791  * @tc.desc: Verify the PostPerformForeground is valid.
792  */
793 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_1900, Function | MediumTest | Level1)
794 {
795     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_1900 is called");
796     std::map<std::string, std::string> paras;
797     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
798     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
799     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
800     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
801 
802     Want want;
803     for (auto para : paras) {
804         want.SetParam(para.first, para.second);
805     }
806 
807     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
808     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
809         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
810         std::make_shared<AbilityDelegatorArgs>(want),
811         true);
812     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
813     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
814     abilityDelegator.abilityMonitors_.clear();
815     std::shared_ptr<MockIabilityMonitor> mockMonitor = std::make_shared<MockIabilityMonitor>(ABILITY_NAME);
816     abilityDelegator.abilityMonitors_.emplace_back(mockMonitor);
817     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
818     std::shared_ptr<ADelegatorAbilityProperty> ability = std::make_shared<ADelegatorAbilityProperty>();
819     ability->token_ = token;
820     ability->name_ = ABILITY_NAME;
821     ability->lifecycleState_ = AbilityLifecycleExecutor::LifecycleState::STARTED_NEW;
822     abilityDelegator.PostPerformForeground(ability);
823 
824     EXPECT_TRUE(mockMonitor->foreground_);
825 }
826 
827 /**
828  * @tc.number: Ability_Delegator_Args_Test_2000
829  * @tc.name: PostPerformBackground
830  * @tc.desc: Verify the PostPerformBackground is invalid.
831  */
832 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_2000, Function | MediumTest | Level1)
833 {
834     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_2000 is called");
835     std::map<std::string, std::string> paras;
836     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
837     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
838     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
839     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
840 
841     Want want;
842     for (auto para : paras) {
843         want.SetParam(para.first, para.second);
844     }
845 
846     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
847     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
848         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
849         std::make_shared<AbilityDelegatorArgs>(want),
850         true);
851     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
852     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
853     abilityDelegator.abilityMonitors_.clear();
854     std::shared_ptr<MockIabilityMonitor> mockMonitor = std::make_shared<MockIabilityMonitor>(ABILITY_NAME);
855     abilityDelegator.abilityMonitors_.emplace_back(mockMonitor);
856     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
857     std::shared_ptr<ADelegatorAbilityProperty> ability = std::make_shared<ADelegatorAbilityProperty>();
858     ability->token_ = token;
859     ability->name_ = ABILITY_NAME;
860     ability->lifecycleState_ = AbilityLifecycleExecutor::LifecycleState::STARTED_NEW;
861     abilityDelegator.PostPerformBackground(nullptr);
862 
863     EXPECT_FALSE(mockMonitor->background_);
864 }
865 
866 /**
867  * @tc.number: Ability_Delegator_Args_Test_2100
868  * @tc.name: PostPerformBackground
869  * @tc.desc: Verify the PostPerformBackground is valid.
870  */
871 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_2100, Function | MediumTest | Level1)
872 {
873     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_2100 is called");
874     std::map<std::string, std::string> paras;
875     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
876     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
877     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
878     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
879 
880     Want want;
881     for (auto para : paras) {
882         want.SetParam(para.first, para.second);
883     }
884 
885     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
886     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
887         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
888         std::make_shared<AbilityDelegatorArgs>(want),
889         true);
890     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
891     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
892     abilityDelegator.abilityMonitors_.clear();
893     std::shared_ptr<MockIabilityMonitor> mockMonitor = std::make_shared<MockIabilityMonitor>(ABILITY_NAME);
894     abilityDelegator.abilityMonitors_.emplace_back(mockMonitor);
895     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
896     std::shared_ptr<ADelegatorAbilityProperty> ability = std::make_shared<ADelegatorAbilityProperty>();
897     ability->token_ = token;
898     ability->name_ = ABILITY_NAME;
899     ability->lifecycleState_ = AbilityLifecycleExecutor::LifecycleState::STARTED_NEW;
900     abilityDelegator.PostPerformBackground(ability);
901 
902     EXPECT_TRUE(mockMonitor->background_);
903 }
904 
905 /**
906  * @tc.number: Ability_Delegator_Args_Test_2200
907  * @tc.name: PostPerformStop
908  * @tc.desc: Verify the PostPerformStop is invalid.
909  */
910 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_2200, Function | MediumTest | Level1)
911 {
912     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_2200 is called");
913     std::map<std::string, std::string> paras;
914     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
915     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
916     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
917     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
918 
919     Want want;
920     for (auto para : paras) {
921         want.SetParam(para.first, para.second);
922     }
923 
924     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
925     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
926         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
927         std::make_shared<AbilityDelegatorArgs>(want),
928         true);
929     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
930     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
931     abilityDelegator.abilityMonitors_.clear();
932     std::shared_ptr<MockIabilityMonitor> mockMonitor = std::make_shared<MockIabilityMonitor>(ABILITY_NAME);
933     abilityDelegator.abilityMonitors_.emplace_back(mockMonitor);
934     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
935     std::shared_ptr<ADelegatorAbilityProperty> ability = std::make_shared<ADelegatorAbilityProperty>();
936     ability->token_ = token;
937     ability->name_ = ABILITY_NAME;
938     ability->lifecycleState_ = AbilityLifecycleExecutor::LifecycleState::STARTED_NEW;
939     abilityDelegator.PostPerformStop(nullptr);
940 
941     EXPECT_FALSE(mockMonitor->stop_);
942 }
943 
944 /**
945  * @tc.number: Ability_Delegator_Args_Test_2300
946  * @tc.name: PostPerformStop
947  * @tc.desc: Verify the PostPerformStop is valid.
948  */
949 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_2300, Function | MediumTest | Level1)
950 {
951     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_2300 is called");
952     std::map<std::string, std::string> paras;
953     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
954     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
955     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
956     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
957 
958     Want want;
959     for (auto para : paras) {
960         want.SetParam(para.first, para.second);
961     }
962 
963     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
964     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
965         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
966         std::make_shared<AbilityDelegatorArgs>(want),
967         true);
968     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
969     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
970     abilityDelegator.abilityMonitors_.clear();
971     std::shared_ptr<MockIabilityMonitor> mockMonitor = std::make_shared<MockIabilityMonitor>(ABILITY_NAME);
972     abilityDelegator.abilityMonitors_.emplace_back(mockMonitor);
973     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
974     std::shared_ptr<ADelegatorAbilityProperty> ability = std::make_shared<ADelegatorAbilityProperty>();
975     ability->token_ = token;
976     ability->name_ = ABILITY_NAME;
977     ability->lifecycleState_ = AbilityLifecycleExecutor::LifecycleState::STARTED_NEW;
978     abilityDelegator.PostPerformStop(ability);
979 
980     EXPECT_TRUE(mockMonitor->stop_);
981 }
982 
983 /**
984  * @tc.number: Ability_Delegator_Args_Test_2400
985  * @tc.name: FinishUserTest
986  * @tc.desc: Verify the FinishUserTest is valid.
987  */
988 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_2400, Function | MediumTest | Level1)
989 {
990     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_2400 is called");
991     MockAbilityDelegatorStub::finishFlag_ = false;
992     std::map<std::string, std::string> paras;
993     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
994     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
995     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
996     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
997 
998     Want want;
999     for (auto para : paras) {
1000         want.SetParam(para.first, para.second);
1001     }
1002 
1003     std::shared_ptr<AbilityDelegatorArgs> abilityArgs = std::make_shared<AbilityDelegatorArgs>(want);
1004 
1005     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
1006     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
1007         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
1008         abilityArgs,
1009         true);
1010     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
1011     std::shared_ptr<AbilityDelegator> abilityDelegator =
1012         std::make_shared<AbilityDelegator>(context, std::move(testRunner), iRemoteObj);
1013     AbilityDelegatorRegistry::RegisterInstance(abilityDelegator, abilityArgs);
1014 
1015     abilityDelegator->abilityMonitors_.clear();
1016     std::shared_ptr<MockIabilityMonitor> mockMonitor = std::make_shared<MockIabilityMonitor>(ABILITY_NAME);
1017     abilityDelegator->abilityMonitors_.emplace_back(mockMonitor);
1018     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub);
1019     std::shared_ptr<ADelegatorAbilityProperty> ability = std::make_shared<ADelegatorAbilityProperty>();
1020     ability->token_ = token;
1021     ability->name_ = ABILITY_NAME;
1022     ability->lifecycleState_ = AbilityLifecycleExecutor::LifecycleState::STARTED_NEW;
1023     abilityDelegator->FinishUserTest(FINISH_MSG, FINISH_RESULT_CODE);
1024 
1025     EXPECT_TRUE(MockAbilityDelegatorStub::finishFlag_);
1026 }
1027 
1028 /**
1029  * @tc.number: Ability_Delegator_Args_Test_2500
1030  * @tc.name: FinishUserTest
1031  * @tc.desc: Verify the FinishUserTest is invalid.
1032  */
1033 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_2500, Function | MediumTest | Level1)
1034 {
1035     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_2500 is called");
1036     MockAbilityDelegatorStub2::finishFlag_ = false;
1037     std::map<std::string, std::string> paras;
1038     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
1039     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
1040     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
1041     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
1042 
1043     Want want;
1044     for (auto para : paras) {
1045         want.SetParam(para.first, para.second);
1046     }
1047 
1048     std::shared_ptr<AbilityDelegatorArgs> abilityArgs = std::make_shared<AbilityDelegatorArgs>(want);
1049 
1050     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
1051     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
1052         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
1053         abilityArgs,
1054         true);
1055     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub2);
1056     std::shared_ptr<AbilityDelegator> abilityDelegator =
1057         std::make_shared<AbilityDelegator>(context, std::move(testRunner), iRemoteObj);
1058     AbilityDelegatorRegistry::RegisterInstance(abilityDelegator, abilityArgs);
1059 
1060     abilityDelegator->abilityMonitors_.clear();
1061     std::shared_ptr<MockIabilityMonitor> mockMonitor = std::make_shared<MockIabilityMonitor>(ABILITY_NAME);
1062     abilityDelegator->abilityMonitors_.emplace_back(mockMonitor);
1063     sptr<IRemoteObject> token = sptr<IRemoteObject>(new MockAbilityDelegatorStub2);
1064     std::shared_ptr<ADelegatorAbilityProperty> ability = std::make_shared<ADelegatorAbilityProperty>();
1065     ability->token_ = token;
1066     ability->name_ = ABILITY_NAME;
1067     ability->lifecycleState_ = AbilityLifecycleExecutor::LifecycleState::STARTED_NEW;
1068     abilityDelegator->FinishUserTest(FINISH_MSG, FINISH_RESULT_CODE);
1069 
1070     EXPECT_FALSE(MockAbilityDelegatorStub2::finishFlag_);
1071 }
1072 
1073 /**
1074  * @tc.number: Ability_Delegator_Args_Test_2600
1075  * @tc.name: AddAbilityStageMonitor and RemoveAbilityStageMonitor and GetStageMonitorsNum
1076  * @tc.desc: Verify the AddAbilityStageMonitor and RemoveAbilityStageMonitor and GetMonitorsNum.
1077  * @tc.require: issueI5801E
1078  */
1079 HWTEST_F(AbilityDelegatorModuleTest, Ability_Delegator_Args_Test_2600, Function | MediumTest | Level1)
1080 {
1081     TAG_LOGI(AAFwkTag::TEST, "Ability_Delegator_Args_Test_2600 is called");
1082     std::map<std::string, std::string> paras;
1083     paras.emplace(KEY_TEST_BUNDLE_NAME, VALUE_TEST_BUNDLE_NAME);
1084     paras.emplace(KEY_TEST_RUNNER_CLASS, VALUE_TEST_RUNNER_CLASS);
1085     paras.emplace(KEY_TEST_CASE, VALUE_TEST_CASE);
1086     paras.emplace(KEY_TEST_WAIT_TIMEOUT, VALUE_TEST_WAIT_TIMEOUT);
1087 
1088     Want want;
1089     for (auto para : paras) {
1090         want.SetParam(para.first, para.second);
1091     }
1092     std::shared_ptr<OHOS::AbilityRuntime::Context> context = std::make_shared<OHOS::AbilityRuntime::ContextImpl>();
1093     std::unique_ptr<TestRunner> testRunner = TestRunner::Create(
1094         std::shared_ptr<OHOSApplication>(ApplicationLoader::GetInstance().GetApplicationByName())->GetRuntime(),
1095         std::make_shared<AbilityDelegatorArgs>(want),
1096         true);
1097     sptr<IRemoteObject> iRemoteObj = sptr<IRemoteObject>(new MockAbilityDelegatorStub());
1098     AbilityDelegator abilityDelegator(context, std::move(testRunner), iRemoteObj);
1099 
1100     std::shared_ptr<IAbilityStageMonitor> monitor1 = std::make_shared<IAbilityStageMonitor>(
1101         PROPERTY_ABILITY_STAGE_MODULE_NAME, PROPERTY_ABILITY_STAGE_SOURCE_ENTRANCE);
1102     std::shared_ptr<IAbilityStageMonitor> monitor2 = std::make_shared<IAbilityStageMonitor>(
1103         PROPERTY_ABILITY_STAGE_MODULE_NAME, PROPERTY_ABILITY_STAGE_SOURCE_ENTRANCE);
1104 
1105     abilityDelegator.AddAbilityStageMonitor(monitor1);
1106     EXPECT_EQ((int)(abilityDelegator.GetStageMonitorsNum()), ONE);
1107     abilityDelegator.AddAbilityStageMonitor(monitor1);
1108     EXPECT_EQ((int)(abilityDelegator.GetStageMonitorsNum()), ONE);
1109     abilityDelegator.AddAbilityStageMonitor(monitor2);
1110     EXPECT_EQ((int)(abilityDelegator.GetStageMonitorsNum()), TWO);
1111     abilityDelegator.RemoveAbilityStageMonitor(monitor1);
1112     EXPECT_EQ((int)(abilityDelegator.GetStageMonitorsNum()), ONE);
1113     abilityDelegator.RemoveAbilityStageMonitor(monitor1);
1114     EXPECT_EQ((int)(abilityDelegator.GetStageMonitorsNum()), ONE);
1115     abilityDelegator.RemoveAbilityStageMonitor(monitor2);
1116     EXPECT_EQ((int)(abilityDelegator.GetStageMonitorsNum()), ZERO);
1117     abilityDelegator.RemoveAbilityStageMonitor(monitor2);
1118     EXPECT_EQ((int)(abilityDelegator.GetStageMonitorsNum()), ZERO);
1119 }
1120