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