1 /*
2 * Copyright (c) 2021-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "app_process_data.h"
18 #define private public
19 #define protected public
20 #include "lifecycle_deal.h"
21 #undef private
22 #undef protected
23 #include "ability_scheduler_mock.h"
24 #include "session_info.h"
25
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace AAFwk {
30 class LifecycleDealTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp();
35 void TearDown();
36
37 std::shared_ptr<LifecycleDeal> lifecycleDeal_{ nullptr };
38 sptr<AbilitySchedulerMock> abilityScheduler_{ nullptr };
39 };
40
SetUpTestCase(void)41 void LifecycleDealTest::SetUpTestCase(void)
42 {}
TearDownTestCase(void)43 void LifecycleDealTest::TearDownTestCase(void)
44 {}
TearDown()45 void LifecycleDealTest::TearDown()
46 {}
47
SetUp()48 void LifecycleDealTest::SetUp()
49 {
50 lifecycleDeal_ = std::make_shared<LifecycleDeal>();
51 abilityScheduler_ = new AbilitySchedulerMock();
52 }
53
54 /*
55 * Feature: LifecycleDeal
56 * Function: Activate
57 * SubFunction: NA
58 * FunctionPoints: LifecycleDeal Activate
59 * EnvConditions:NA
60 * CaseDescription: Verify activate operation and call mock once
61 */
62 HWTEST_F(LifecycleDealTest, LifecycleDeal_oprator_001, TestSize.Level1)
63 {
64 LifeCycleStateInfo val;
65 EXPECT_CALL(*abilityScheduler_, ScheduleAbilityTransaction(::testing::_, ::testing::_, ::testing::_))
66 .Times(1)
67 .WillOnce(testing::DoAll(testing::SaveArg<1>(&val), testing::Return(true)));
68
69 const Want want;
70 CallerInfo caller;
71 caller.deviceId = "device";
72 caller.bundleName = "bundle";
73 caller.abilityName = "LifecycleDealTest";
74
75 LifeCycleStateInfo info;
76 info.caller = caller;
77 lifecycleDeal_->Activate(want, info);
78 lifecycleDeal_->SetScheduler(abilityScheduler_);
79 lifecycleDeal_->Activate(want, info);
80
81 EXPECT_EQ(val.caller.deviceId, caller.deviceId);
82 EXPECT_EQ(val.caller.bundleName, caller.bundleName);
83 EXPECT_EQ(val.caller.abilityName, caller.abilityName);
84 }
85
86 /*
87 * Feature: LifecycleDeal
88 * Function: Inactivate
89 * SubFunction: NA
90 * FunctionPoints: LifecycleDeal Inactivate
91 * EnvConditions:NA
92 * CaseDescription: Verify Inactivate operation and call mock once
93 */
94 HWTEST_F(LifecycleDealTest, LifecycleDeal_oprator_002, TestSize.Level1)
95 {
96 LifeCycleStateInfo val;
97 EXPECT_CALL(*abilityScheduler_, ScheduleAbilityTransaction(::testing::_, ::testing::_, ::testing::_))
98 .Times(1)
99 .WillOnce(testing::DoAll(testing::SaveArg<1>(&val), testing::Return(true)));
100
101 const Want want;
102 CallerInfo caller;
103 caller.deviceId = "device";
104 caller.bundleName = "bundle";
105 caller.abilityName = "LifecycleDealTest";
106
107 LifeCycleStateInfo info;
108 info.caller = caller;
109 lifecycleDeal_->Inactivate(want, info);
110 lifecycleDeal_->SetScheduler(abilityScheduler_);
111 lifecycleDeal_->Inactivate(want, info);
112
113 EXPECT_EQ(val.caller.deviceId, caller.deviceId);
114 EXPECT_EQ(val.caller.bundleName, caller.bundleName);
115 EXPECT_EQ(val.caller.abilityName, caller.abilityName);
116 }
117
118 /*
119 * Feature: LifecycleDeal
120 * Function: MoveToBackground
121 * SubFunction: NA
122 * FunctionPoints: LifecycleDeal MoveToBackground
123 * EnvConditions:NA
124 * CaseDescription: Verify MoveToBackground operation and call mock once
125 */
126 HWTEST_F(LifecycleDealTest, LifecycleDeal_oprator_003, TestSize.Level1)
127 {
128 LifeCycleStateInfo val;
129 EXPECT_CALL(*abilityScheduler_, ScheduleAbilityTransaction(::testing::_, ::testing::_, ::testing::_))
130 .Times(1)
131 .WillOnce(testing::DoAll(testing::SaveArg<1>(&val), testing::Return(true)));
132
133 const Want want;
134 CallerInfo caller;
135 caller.deviceId = "device";
136 caller.bundleName = "bundle";
137 caller.abilityName = "LifecycleDealTest";
138
139 LifeCycleStateInfo info;
140 info.caller = caller;
141 lifecycleDeal_->MoveToBackground(want, info);
142 lifecycleDeal_->SetScheduler(abilityScheduler_);
143 lifecycleDeal_->MoveToBackground(want, info);
144
145 EXPECT_EQ(val.caller.deviceId, caller.deviceId);
146 EXPECT_EQ(val.caller.bundleName, caller.bundleName);
147 EXPECT_EQ(val.caller.abilityName, caller.abilityName);
148 }
149
150 /*
151 * Feature: LifecycleDeal
152 * Function: ConnectAbility
153 * SubFunction: NA
154 * FunctionPoints: LifecycleDeal ConnectAbility
155 * EnvConditions:NA
156 * CaseDescription: Verify ConnectAbility operation and call mock once
157 */
158 HWTEST_F(LifecycleDealTest, LifecycleDeal_oprator_004, TestSize.Level1)
159 {
160 EXPECT_CALL(*abilityScheduler_, ScheduleConnectAbility(::testing::_)).Times(1);
161 const Want want;
162 lifecycleDeal_->ConnectAbility(want);
163 lifecycleDeal_->SetScheduler(abilityScheduler_);
164 lifecycleDeal_->ConnectAbility(want);
165 }
166
167 /*
168 * Feature: LifecycleDeal
169 * Function: DisconnectAbility
170 * SubFunction: NA
171 * FunctionPoints: LifecycleDeal DisconnectAbility
172 * EnvConditions:NA
173 * CaseDescription: Verify DisconnectAbility operation and call mock once
174 */
175 HWTEST_F(LifecycleDealTest, LifecycleDeal_oprator_005, TestSize.Level1)
176 {
177 EXPECT_CALL(*abilityScheduler_, ScheduleDisconnectAbility(::testing::_)).Times(1);
178
179 const Want want;
180 lifecycleDeal_->DisconnectAbility(want);
181 lifecycleDeal_->SetScheduler(abilityScheduler_);
182 lifecycleDeal_->DisconnectAbility(want);
183 }
184
185 /*
186 * Feature: LifecycleDeal
187 * Function: Terminate
188 * SubFunction: NA
189 * FunctionPoints: LifecycleDeal Terminate
190 * EnvConditions:NA
191 * CaseDescription: Verify Terminate operation and call mock once
192 */
193 HWTEST_F(LifecycleDealTest, LifecycleDeal_oprator_006, TestSize.Level1)
194 {
195 EXPECT_CALL(*abilityScheduler_, ScheduleAbilityTransaction(::testing::_, ::testing::_, ::testing::_))
196 .Times(1);
197
198 const Want want;
199 CallerInfo caller;
200 caller.deviceId = "device";
201 caller.bundleName = "bundle";
202 caller.abilityName = "LifecycleDealTest";
203
204 LifeCycleStateInfo info;
205 info.caller = caller;
206 lifecycleDeal_->Activate(want, info);
207 lifecycleDeal_->SetScheduler(abilityScheduler_);
208 lifecycleDeal_->Activate(want, info);
209 }
210
211 /*
212 * Feature: LifecycleDeal
213 * Function: CommandAbility
214 * SubFunction: NA
215 * FunctionPoints: LifecycleDeal CommandAbility
216 * EnvConditions:NA
217 * CaseDescription: Verify CommandAbility operation and call mock once
218 */
219 HWTEST_F(LifecycleDealTest, LifecycleDeal_oprator_007, TestSize.Level1)
220 {
221 EXPECT_CALL(*abilityScheduler_, ScheduleCommandAbility(::testing::_, ::testing::_, ::testing::_)).Times(1);
222 const Want want;
223 LifeCycleStateInfo info;
224 lifecycleDeal_->CommandAbility(want, false, 1);
225 lifecycleDeal_->SetScheduler(abilityScheduler_);
226 lifecycleDeal_->CommandAbility(want, false, 1);
227 }
228
229 /*
230 * Feature: LifecycleDeal
231 * Function: CommandAbilityWindow
232 * SubFunction: NA
233 * FunctionPoints: LifecycleDeal CommandAbilityWindow
234 * EnvConditions:NA
235 * CaseDescription: Verify CommandAbilityWindow operation and call mock once
236 * @tc.require: AR000I8B26
237 */
238 HWTEST_F(LifecycleDealTest, LifecycleDeal_oprator_008, TestSize.Level1)
239 {
240 EXPECT_CALL(*abilityScheduler_, ScheduleCommandAbilityWindow(::testing::_, ::testing::_, ::testing::_)).Times(1);
241 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
242 EXPECT_NE(sessionInfo, nullptr);
243 const Want want;
244 lifecycleDeal_->CommandAbilityWindow(want, sessionInfo, AAFwk::WIN_CMD_FOREGROUND);
245 lifecycleDeal_->SetScheduler(abilityScheduler_);
246 lifecycleDeal_->CommandAbilityWindow(want, sessionInfo, AAFwk::WIN_CMD_FOREGROUND);
247 }
248
249 /*
250 * Feature: LifecycleDeal
251 * Function: SaveAbilityState
252 * SubFunction: NA
253 * FunctionPoints: LifecycleDeal SaveAbilityState
254 * EnvConditions:NA
255 * CaseDescription: Verify SaveAbilityState operation and call mock once
256 * @tc.require: AR000I8B26
257 */
258 HWTEST_F(LifecycleDealTest, SaveAbilityStateTest_001, TestSize.Level1)
259 {
260 EXPECT_CALL(*abilityScheduler_, ScheduleSaveAbilityState()).Times(1);
261 lifecycleDeal_->SetScheduler(abilityScheduler_);
262 lifecycleDeal_->SaveAbilityState();
263 }
264
265 /*
266 * Feature: LifecycleDeal
267 * Function: RestoreAbilityState
268 * SubFunction: NA
269 * FunctionPoints: LifecycleDeal RestoreAbilityState
270 * EnvConditions:NA
271 * CaseDescription: Verify RestoreAbilityState operation and call mock once
272 * @tc.require: AR000I8B26
273 */
274 HWTEST_F(LifecycleDealTest, RestoreAbilityState_001, TestSize.Level1)
275 {
276 EXPECT_CALL(*abilityScheduler_, ScheduleRestoreAbilityState(::testing::_)).Times(1);
277 PacMap inState;
278 lifecycleDeal_->SetScheduler(abilityScheduler_);
279 lifecycleDeal_->RestoreAbilityState(inState);
280 }
281
282 /*
283 * Feature: LifecycleDeal
284 * Function: ForegroundNew
285 * SubFunction: NA
286 * FunctionPoints: LifecycleDeal ForegroundNew
287 * EnvConditions:NA
288 * CaseDescription: Verify ForegroundNew operation and call mock once
289 * @tc.require: AR000I8B26
290 */
291 HWTEST_F(LifecycleDealTest, ForegroundNew_001, TestSize.Level1)
292 {
293 EXPECT_CALL(*abilityScheduler_, ScheduleAbilityTransaction(::testing::_, ::testing::_, ::testing::_)).Times(1);
294 Want want;
295 LifeCycleStateInfo stateInfo;
296 sptr<SessionInfo> sessionInfo;
297 lifecycleDeal_->SetScheduler(abilityScheduler_);
298 lifecycleDeal_->ForegroundNew(want, stateInfo, sessionInfo);
299 }
300
301 /*
302 * Feature: LifecycleDeal
303 * Function: BackgroundNew
304 * SubFunction: NA
305 * FunctionPoints: LifecycleDeal BackgroundNew
306 * EnvConditions:NA
307 * CaseDescription: Verify BackgroundNew operation and call mock once
308 * @tc.require: AR000I8B26
309 */
310 HWTEST_F(LifecycleDealTest, BackgroundNew_001, TestSize.Level1)
311 {
312 EXPECT_CALL(*abilityScheduler_, ScheduleAbilityTransaction(::testing::_, ::testing::_, ::testing::_)).Times(1);
313 Want want;
314 LifeCycleStateInfo stateInfo;
315 sptr<SessionInfo> sessionInfo;
316 lifecycleDeal_->SetScheduler(abilityScheduler_);
317 lifecycleDeal_->BackgroundNew(want, stateInfo, sessionInfo);
318 }
319
320 /*
321 * Feature: LifecycleDeal
322 * Function: ContinueAbility
323 * SubFunction: NA
324 * FunctionPoints: LifecycleDeal ContinueAbility
325 * EnvConditions:NA
326 * CaseDescription: Verify ContinueAbility operation and call mock once
327 * @tc.require: AR000I8B26
328 */
329 HWTEST_F(LifecycleDealTest, ContinueAbility_001, TestSize.Level1)
330 {
331 EXPECT_CALL(*abilityScheduler_, ContinueAbility(::testing::_, ::testing::_)).Times(1);
332 std::string deviceId = "101";
333 uint32_t versionCode = 1;
334 lifecycleDeal_->SetScheduler(abilityScheduler_);
335 lifecycleDeal_->ContinueAbility(deviceId, versionCode);
336 }
337
338 /*
339 * Feature: LifecycleDeal
340 * Function: NotifyContinuationResult
341 * SubFunction: NA
342 * FunctionPoints: LifecycleDeal NotifyContinuationResult
343 * EnvConditions:NA
344 * CaseDescription: Verify NotifyContinuationResult operation and call mock once
345 * @tc.require: AR000I8B26
346 */
347 HWTEST_F(LifecycleDealTest, NotifyContinuationResult_001, TestSize.Level1)
348 {
349 EXPECT_CALL(*abilityScheduler_, NotifyContinuationResult(::testing::_)).Times(1);
350 int32_t result = 1;
351 lifecycleDeal_->SetScheduler(abilityScheduler_);
352 lifecycleDeal_->NotifyContinuationResult(result);
353 }
354
355 /*
356 * Feature: LifecycleDeal
357 * Function: ShareData
358 * SubFunction: NA
359 * FunctionPoints: LifecycleDeal ShareData
360 * EnvConditions:NA
361 * CaseDescription: Verify ShareData operation and call mock once
362 * @tc.require: AR000I8B26
363 */
364 HWTEST_F(LifecycleDealTest, ShareData_001, TestSize.Level1)
365 {
366 EXPECT_CALL(*abilityScheduler_, ScheduleShareData(::testing::_)).Times(1);
367 int32_t result = 1;
368 lifecycleDeal_->SetScheduler(abilityScheduler_);
369 lifecycleDeal_->ShareData(result);
370 }
371
372 /*
373 * Feature: LifecycleDeal
374 * Function: PrepareTerminateAbility
375 * SubFunction: NA
376 * FunctionPoints: LifecycleDeal PrepareTerminateAbility
377 * EnvConditions:NA
378 * CaseDescription: Verify PrepareTerminateAbility operation and call mock once
379 * @tc.require: AR000I8B26
380 */
381 HWTEST_F(LifecycleDealTest, PrepareTerminateAbility_001, TestSize.Level1)
382 {
383 bool result = lifecycleDeal_->PrepareTerminateAbility();
384 EXPECT_FALSE(result);
385 }
386
387 /*
388 * Feature: LifecycleDeal
389 * Function: PrepareTerminateAbility
390 * SubFunction: NA
391 * FunctionPoints: LifecycleDeal PrepareTerminateAbility
392 * EnvConditions:NA
393 * CaseDescription: Verify PrepareTerminateAbility operation and call mock once
394 * @tc.require: AR000I8B26
395 */
396 HWTEST_F(LifecycleDealTest, PrepareTerminateAbility_002, TestSize.Level1)
397 {
398 EXPECT_CALL(*abilityScheduler_, SchedulePrepareTerminateAbility()).Times(1);
399 lifecycleDeal_->SetScheduler(abilityScheduler_);
400 EXPECT_FALSE(lifecycleDeal_->PrepareTerminateAbility());
401 }
402
403 /*
404 * Feature: UpdateSessionToken
405 * Function: ShareData
406 * SubFunction: NA
407 * FunctionPoints: UpdateSessionToken ShareData
408 * EnvConditions:NA
409 * CaseDescription: Verify UpdateSessionToken operation and call mock once
410 * @tc.require: AR000I8B26
411 */
412 HWTEST_F(LifecycleDealTest, UpdateSessionToken_001, TestSize.Level1)
413 {
414 sptr<IRemoteObject> sessionToken = nullptr;
415 lifecycleDeal_->SetScheduler(abilityScheduler_);
416 EXPECT_EQ(abilityScheduler_->code_, 0);
417 lifecycleDeal_->UpdateSessionToken(sessionToken);
418 EXPECT_EQ(abilityScheduler_->code_, ABILITY_SCHEDULER_MOCK_VALUE);
419 }
420
421 /*
422 * Feature: NotifyAbilitiesRequestDone
423 * Function: ShareData
424 * SubFunction: NA
425 * FunctionPoints: NotifyAbilitiesRequestDone
426 * EnvConditions:NA
427 * CaseDescription: Verify NotifyAbilitiesRequestDone operation and call mock once
428 */
429 HWTEST_F(LifecycleDealTest, NotifyAbilitiesRequestDone_001, TestSize.Level1)
430 {
431 lifecycleDeal_->SetScheduler(abilityScheduler_);
432 EXPECT_EQ(abilityScheduler_->code_, 0);
433 std::string requestKey = "12345";
434 int32_t requestCode = 0;
435 lifecycleDeal_->NotifyAbilitiesRequestDone(requestKey, requestCode);
436 EXPECT_EQ(abilityScheduler_->code_, ABILITY_SCHEDULER_MOCK_VALUE);
437 }
438
439 /*
440 * Feature: NotifyAbilitiesRequestDone
441 * Function: ShareData
442 * SubFunction: NA
443 * FunctionPoints: NotifyAbilitiesRequestDone
444 * EnvConditions:NA
445 * CaseDescription: Verify NotifyAbilitiesRequestDone abilityScheduler nullptr
446 */
447 HWTEST_F(LifecycleDealTest, NotifyAbilitiesRequestDone_002, TestSize.Level1)
448 {
449 lifecycleDeal_->SetScheduler(nullptr);
450 std::string requestKey = "12345";
451 EXPECT_EQ(lifecycleDeal_->GetScheduler(), nullptr);
452 int32_t requestCode = 0;
453 lifecycleDeal_->NotifyAbilitiesRequestDone(requestKey, requestCode);
454 }
455
456 /*
457 * Feature: ScheduleCollaborate
458 * Function: ShareData
459 * SubFunction: NA
460 * FunctionPoints: ScheduleCollaborate ShareData
461 * EnvConditions:NA
462 * CaseDescription: Verify ScheduleCollaborate operation and call mock once
463 * @tc.require: AR000I8B26
464 */
465 HWTEST_F(LifecycleDealTest, ScheduleCollaborate_001, TestSize.Level1)
466 {
467 sptr<IRemoteObject> sessionToken = nullptr;
468 Want want;
469 lifecycleDeal_->SetScheduler(abilityScheduler_);
470 EXPECT_EQ(abilityScheduler_->code_, 0);
471 lifecycleDeal_->ScheduleCollaborate(want);
472 EXPECT_EQ(abilityScheduler_->code_, ABILITY_SCHEDULER_MOCK_VALUE);
473 }
474 } // namespace AAFwk
475 } // namespace OHOS
476