1 /*
2 * Copyright (c) 2021-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
18 #define private public
19 #include "ams_mgr_scheduler.h"
20 #undef private
21
22 #include "app_state_callback_host.h"
23 #include "hilog_wrapper.h"
24 #include "mock_ability_token.h"
25 #include "mock_app_mgr_service_inner.h"
26 #include "mock_bundle_manager.h"
27 #include "application_state_observer_stub.h"
28
29 using namespace testing;
30 using namespace testing::ext;
31 using testing::_;
32 using testing::Return;
33
34 namespace OHOS {
35 namespace AppExecFwk {
36 class AmsMgrSchedulerTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp();
41 void TearDown();
42 public:
43 protected:
GetTestAppName()44 static const std::string GetTestAppName()
45 {
46 return "test_app_name";
47 }
GetTestAbilityName()48 static const std::string GetTestAbilityName()
49 {
50 return "test_ability_name";
51 }
52
53 std::shared_ptr<MockAppMgrServiceInner> GetMockAppMgrServiceInner();
54 std::shared_ptr<AAFwk::TaskHandlerWrap> GetAmsTaskHandler();
55
56 private:
57 std::shared_ptr<MockAppMgrServiceInner> mockAppMgrServiceInner_;
58 std::shared_ptr<AAFwk::TaskHandlerWrap> amsTaskHandler_;
59 };
60
SetUpTestCase()61 void AmsMgrSchedulerTest::SetUpTestCase()
62 {}
63
TearDownTestCase()64 void AmsMgrSchedulerTest::TearDownTestCase()
65 {}
66
SetUp()67 void AmsMgrSchedulerTest::SetUp()
68 {}
69
TearDown()70 void AmsMgrSchedulerTest::TearDown()
71 {
72 amsTaskHandler_.reset();
73 mockAppMgrServiceInner_.reset();
74 }
75
GetMockAppMgrServiceInner()76 std::shared_ptr<MockAppMgrServiceInner> AmsMgrSchedulerTest::GetMockAppMgrServiceInner()
77 {
78 if (!mockAppMgrServiceInner_) {
79 mockAppMgrServiceInner_ = std::make_shared<MockAppMgrServiceInner>();
80 }
81 return mockAppMgrServiceInner_;
82 }
83
GetAmsTaskHandler()84 std::shared_ptr<AAFwk::TaskHandlerWrap> AmsMgrSchedulerTest::GetAmsTaskHandler()
85 {
86 if (!amsTaskHandler_) {
87 amsTaskHandler_ = AAFwk::TaskHandlerWrap::CreateQueueHandler("AmsMgrSchedulerTest");
88 }
89 return amsTaskHandler_;
90 }
91
92 /*
93 * Feature: AMS
94 * Function: AmsMgrScheduler
95 * SubFunction: LoadAbility
96 * FunctionPoints: Act normal
97 * EnvConditions: Mobile that can run ohos test framework.
98 * CaseDescription: Verify the function LoadAbility can works.
99 */
100 HWTEST_F(AmsMgrSchedulerTest, AmsMgrScheduler_001, TestSize.Level1)
101 {
102 HILOG_DEBUG("AmsMgrScheduler_001 start.");
103
104 auto mockAppMgrServiceInner = GetMockAppMgrServiceInner();
105 std::unique_ptr<AmsMgrScheduler> amsMgrScheduler =
106 std::make_unique<AmsMgrScheduler>(mockAppMgrServiceInner, GetAmsTaskHandler());
107 ASSERT_NE(amsMgrScheduler, nullptr);
108
109 sptr<IRemoteObject> token = new MockAbilityToken();
110 sptr<IRemoteObject> preToken = new MockAbilityToken();
111 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
112 abilityInfo->name = GetTestAbilityName();
113 std::shared_ptr<ApplicationInfo> applicationInfo = std::make_shared<ApplicationInfo>();
114 applicationInfo->name = GetTestAppName();
115
116 EXPECT_CALL(*mockAppMgrServiceInner, LoadAbility(_, _, _, _, _))
117 .WillOnce(InvokeWithoutArgs(mockAppMgrServiceInner.get(), &MockAppMgrServiceInner::Post));
118 amsMgrScheduler->LoadAbility(token, preToken, abilityInfo, applicationInfo, nullptr);
119 mockAppMgrServiceInner->Wait();
120
121 HILOG_DEBUG("AmsMgrScheduler_001 end.");
122 }
123
124 /*
125 * Feature: AMS
126 * Function: AmsMgrScheduler
127 * SubFunction: LoadAbility
128 * FunctionPoints: Check params
129 * EnvConditions: Mobile that can run ohos test framework.
130 * CaseDescription: Verify the function LoadAbility can check appInfo and abilityInfo.
131 */
132 HWTEST_F(AmsMgrSchedulerTest, AmsMgrScheduler_002, TestSize.Level1)
133 {
134 HILOG_DEBUG("AmsMgrScheduler_002 start.");
135
136 auto mockAppMgrServiceInner = std::make_shared<MockAppMgrServiceInner>();
137 auto taskHandler = AAFwk::TaskHandlerWrap::CreateQueueHandler("AmsMgrSchedulerTest");
138 std::unique_ptr<AmsMgrScheduler> amsMgrScheduler =
139 std::make_unique<AmsMgrScheduler>(mockAppMgrServiceInner, taskHandler);
140 ASSERT_NE(amsMgrScheduler, nullptr);
141
142 sptr<IRemoteObject> token = new MockAbilityToken();
143 sptr<IRemoteObject> preToken = new MockAbilityToken();
144 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
145 abilityInfo->name = GetTestAbilityName();
146 std::shared_ptr<ApplicationInfo> applicationInfo = std::make_shared<ApplicationInfo>();
147 applicationInfo->name = GetTestAppName();
148
149 // check token parameter
150 EXPECT_CALL(*mockAppMgrServiceInner, LoadAbility(_, _, _, _, _)).Times(0);
151 amsMgrScheduler->LoadAbility(token, preToken, nullptr, applicationInfo, nullptr);
152
153 // check pretoken parameter
154 EXPECT_CALL(*mockAppMgrServiceInner, LoadAbility(_, _, _, _, _)).Times(0);
155 amsMgrScheduler->LoadAbility(token, preToken, abilityInfo, nullptr, nullptr);
156
157 HILOG_DEBUG("AmsMgrScheduler_002 end.");
158 }
159
160 /*
161 * Feature: AMS
162 * Function: AmsMgrScheduler
163 * SubFunction: UpdateAbilityState
164 * FunctionPoints: Act normal
165 * EnvConditions: Mobile that can run ohos test framework.
166 * CaseDescription: Verify the function UpdateAbilityState can works.
167 */
168 HWTEST_F(AmsMgrSchedulerTest, AmsMgrScheduler_003, TestSize.Level1)
169 {
170 HILOG_DEBUG("AmsMgrScheduler_003 start.");
171
172 auto mockAppMgrServiceInner = GetMockAppMgrServiceInner();
173 std::unique_ptr<AmsMgrScheduler> amsMgrScheduler =
174 std::make_unique<AmsMgrScheduler>(mockAppMgrServiceInner, GetAmsTaskHandler());
175 ASSERT_NE(amsMgrScheduler, nullptr);
176
177 sptr<IRemoteObject> token = new MockAbilityToken();
178 AbilityState abilityState = AbilityState::ABILITY_STATE_CREATE;
179
180 EXPECT_CALL(*mockAppMgrServiceInner, UpdateAbilityState(_, _))
181 .WillOnce(InvokeWithoutArgs(mockAppMgrServiceInner.get(), &MockAppMgrServiceInner::Post));
182 amsMgrScheduler->UpdateAbilityState(token, abilityState);
183 mockAppMgrServiceInner->Wait();
184
185 HILOG_DEBUG("AmsMgrScheduler_003 end.");
186 }
187
188 /*
189 * Feature: AMS
190 * Function: AmsMgrScheduler
191 * SubFunction: TerminateAbility
192 * FunctionPoints: Act normal
193 * EnvConditions: Mobile that can run ohos test framework.
194 * CaseDescription: Verify the function TerminateAbility can works.
195 */
196 HWTEST_F(AmsMgrSchedulerTest, AmsMgrScheduler_004, TestSize.Level1)
197 {
198 HILOG_DEBUG("AmsMgrScheduler_004 start.");
199
200 auto mockAppMgrServiceInner = GetMockAppMgrServiceInner();
201 std::unique_ptr<AmsMgrScheduler> amsMgrScheduler =
202 std::make_unique<AmsMgrScheduler>(mockAppMgrServiceInner, GetAmsTaskHandler());
203 ASSERT_NE(amsMgrScheduler, nullptr);
204 sptr<IRemoteObject> token = new MockAbilityToken();
205 bool clearMissionFlag = true;
206 EXPECT_CALL(*mockAppMgrServiceInner, TerminateAbility(_, _))
207 .WillOnce(InvokeWithoutArgs(mockAppMgrServiceInner.get(), &MockAppMgrServiceInner::Post));
208 amsMgrScheduler->TerminateAbility(token, clearMissionFlag);
209 mockAppMgrServiceInner->Wait();
210
211 HILOG_DEBUG("AmsMgrScheduler_004 end.");
212 }
213
214 /*
215 * Feature: AMS
216 * Function: AmsMgrScheduler
217 * SubFunction: RegisterAppStateCallback
218 * FunctionPoints: Act normal
219 * EnvConditions: Mobile that can run ohos test framework.
220 * CaseDescription: Verify the function RegisterAppStateCallback can works.
221 */
222 HWTEST_F(AmsMgrSchedulerTest, AmsMgrScheduler_005, TestSize.Level1)
223 {
224 HILOG_DEBUG("AmsMgrScheduler_005 start.");
225
226 auto mockAppMgrServiceInner = GetMockAppMgrServiceInner();
227 std::unique_ptr<AmsMgrScheduler> amsMgrScheduler =
228 std::make_unique<AmsMgrScheduler>(mockAppMgrServiceInner, GetAmsTaskHandler());
229 ASSERT_NE(amsMgrScheduler, nullptr);
230
231 sptr<AppStateCallbackHost> appStateCallbackHost = new AppStateCallbackHost();
232 EXPECT_CALL(*mockAppMgrServiceInner, RegisterAppStateCallback(_))
233 .WillOnce(InvokeWithoutArgs(mockAppMgrServiceInner.get(), &MockAppMgrServiceInner::Post));
234 amsMgrScheduler->RegisterAppStateCallback(appStateCallbackHost);
235 mockAppMgrServiceInner->Wait();
236
237 HILOG_DEBUG("AmsMgrScheduler_005 end.");
238 }
239
240 /*
241 * Feature: AMS
242 * Function: AmsMgrScheduler
243 * SubFunction: IsReady
244 * FunctionPoints: Check Params
245 * EnvConditions: Mobile that can run ohos test framework.
246 * CaseDescription: Verify the function IsReady can check params.
247 */
248 HWTEST_F(AmsMgrSchedulerTest, AmsMgrScheduler_007, TestSize.Level1)
249 {
250 HILOG_DEBUG("AmsMgrScheduler_007 start.");
251
252 auto mockAppMgrServiceInner = GetMockAppMgrServiceInner();
253 auto amsTaskHandler = GetAmsTaskHandler();
254
255 // act normal
256 std::unique_ptr<AmsMgrScheduler> amsMgrScheduler =
257 std::make_unique<AmsMgrScheduler>(mockAppMgrServiceInner, amsTaskHandler);
258 EXPECT_EQ(true, amsMgrScheduler->IsReady());
259
260 // check params AppMgrServiceInner
261 std::unique_ptr<AmsMgrScheduler> amsMgrScheduler2 = std::make_unique<AmsMgrScheduler>(nullptr, amsTaskHandler);
262 EXPECT_EQ(false, amsMgrScheduler2->IsReady());
263
264 // check params amsTaskHandler
265 std::unique_ptr<AmsMgrScheduler> amsMgrScheduler3 =
266 std::make_unique<AmsMgrScheduler>(mockAppMgrServiceInner, nullptr);
267 EXPECT_EQ(false, amsMgrScheduler3->IsReady());
268
269 HILOG_DEBUG("AmsMgrScheduler_007 end.");
270 }
271
272 /*
273 * Feature: AMS
274 * Function: KillApplication
275 * SubFunction: IsReady
276 * FunctionPoints: Check Params
277 * EnvConditions: Mobile that can run ohos test framework.
278 * CaseDescription: Kill apps by name
279 */
280 HWTEST_F(AmsMgrSchedulerTest, AmsMgrScheduler_008, TestSize.Level1)
281 {
282 HILOG_DEBUG("AmsMgrScheduler_008 start.");
283
284 auto mockAppMgrServiceInner = GetMockAppMgrServiceInner();
285 auto amsTaskHandler = GetAmsTaskHandler();
286
287 EXPECT_CALL(*mockAppMgrServiceInner, KillApplication(_)).Times(1).WillOnce(Return(ERR_OK));
288
289 // check params AppMgrServiceInner
290 std::unique_ptr<AmsMgrScheduler> amsMgrScheduler2 = std::make_unique<AmsMgrScheduler>(nullptr, amsTaskHandler);
291 EXPECT_EQ(false, amsMgrScheduler2->IsReady());
292
293 EXPECT_EQ(ERR_INVALID_OPERATION, amsMgrScheduler2->KillApplication(GetTestAppName()));
294
295 // check params amsTaskHandler
296 std::unique_ptr<AmsMgrScheduler> amsMgrScheduler3 =
297 std::make_unique<AmsMgrScheduler>(mockAppMgrServiceInner, nullptr);
298 EXPECT_EQ(false, amsMgrScheduler3->IsReady());
299
300 EXPECT_EQ(ERR_INVALID_OPERATION, amsMgrScheduler3->KillApplication(GetTestAppName()));
301
302 // act normal
303 std::unique_ptr<AmsMgrScheduler> amsMgrScheduler4 =
304 std::make_unique<AmsMgrScheduler>(mockAppMgrServiceInner, amsTaskHandler);
305 EXPECT_EQ(true, amsMgrScheduler4->IsReady());
306
307 EXPECT_EQ(ERR_OK, amsMgrScheduler4->KillApplication(GetTestAppName()));
308
309 HILOG_DEBUG("AmsMgrScheduler_008 end.");
310 }
311
312 /*
313 * Feature: AMS
314 * Function: AbilityBehaviorAnalysis
315 * SubFunction: IsReady
316 * FunctionPoints: Check Params
317 * EnvConditions: Mobile that can run ohos test framework.
318 * CaseDescription: Optimize based on visibility and perception
319 */
320 HWTEST_F(AmsMgrSchedulerTest, AmsMgrScheduler_009, TestSize.Level1)
321 {
322 HILOG_DEBUG("AmsMgrScheduler_009 start.");
323
324 auto mockAppMgrServiceInner = GetMockAppMgrServiceInner();
325 std::unique_ptr<AmsMgrScheduler> amsMgrScheduler =
326 std::make_unique<AmsMgrScheduler>(mockAppMgrServiceInner, GetAmsTaskHandler());
327 EXPECT_EQ(true, amsMgrScheduler->IsReady());
328
329 EXPECT_CALL(*mockAppMgrServiceInner, AbilityBehaviorAnalysis(_, _, _, _, _))
330 .Times(1)
331 .WillOnce(InvokeWithoutArgs(mockAppMgrServiceInner.get(), &MockAppMgrServiceInner::Post));
332
333 sptr<IRemoteObject> token;
334 sptr<IRemoteObject> preToken;
335 int32_t visibility = 0;
336 int32_t perceptibility = 0;
337 int32_t connectionState = 0;
338
339 amsMgrScheduler->AbilityBehaviorAnalysis(token, preToken, visibility, perceptibility, connectionState);
340
341 mockAppMgrServiceInner->Wait();
342
343 mockAppMgrServiceInner.reset();
344
345 HILOG_DEBUG("AmsMgrScheduler_009 end.");
346 }
347
348 /*
349 * Feature: AMS
350 * Function: AbilityBehaviorAnalysis
351 * SubFunction: IsReady
352 * FunctionPoints: Check Params
353 * EnvConditions: Mobile that can run ohos test framework.
354 * CaseDescription: Optimize based on visibility and perception
355 */
356 HWTEST_F(AmsMgrSchedulerTest, AmsMgrScheduler_010, TestSize.Level1)
357 {
358 HILOG_DEBUG("AmsMgrScheduler_010 start.");
359
360 auto mockAppMgrServiceInner = GetMockAppMgrServiceInner();
361
362 std::unique_ptr<AmsMgrScheduler> amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
363 EXPECT_EQ(false, amsMgrScheduler->IsReady());
364
365 EXPECT_CALL(*mockAppMgrServiceInner, AbilityBehaviorAnalysis(_, _, _, _, _)).Times(0);
366
367 sptr<IRemoteObject> token;
368 sptr<IRemoteObject> preToken;
369 int32_t visibility = 0;
370 int32_t perceptibility = 0;
371 int32_t connectionState = 0;
372
373 amsMgrScheduler->AbilityBehaviorAnalysis(token, preToken, visibility, perceptibility, connectionState);
374
375 HILOG_DEBUG("AmsMgrScheduler_010 end.");
376 }
377
378 /*
379 * Feature: AMS
380 * Function: IPC
381 * SubFunction: appmgr interface
382 * FunctionPoints: KillApplication interface
383 * CaseDescription: test IPC can transact data
384 */
385 HWTEST_F(AmsMgrSchedulerTest, RegisterApplicationStateObserver_001, TestSize.Level0)
386 {
387 HILOG_DEBUG("RegisterApplicationStateObserver_001 start");
388 sptr<IApplicationStateObserver> observer = new ApplicationStateObserverStub();
389 auto mockAppMgrServiceInner = std::make_shared<MockAppMgrServiceInner>();
390 mockAppMgrServiceInner->RegisterApplicationStateObserver(observer);
391 int32_t err = mockAppMgrServiceInner->RegisterApplicationStateObserver(observer);
392 // repeat register return ERR_INVALID_VALUE
393 EXPECT_EQ(1, err);
394 HILOG_DEBUG("RegisterApplicationStateObserver_001 end");
395 }
396
397 /*
398 * Feature: AMS
399 * Function: IPC
400 * SubFunction: appmgr interface
401 * FunctionPoints: KillApplication interface
402 * CaseDescription: test IPC can transact data
403 */
404 HWTEST_F(AmsMgrSchedulerTest, UnregisterApplicationStateObserver_001, TestSize.Level0)
405 {
406 HILOG_DEBUG("UnregisterApplicationStateObserver_001 start");
407 sptr<IApplicationStateObserver> observer = new ApplicationStateObserverStub();
408 auto mockAppMgrServiceInner = std::make_shared<MockAppMgrServiceInner>();
409 int32_t err1 = mockAppMgrServiceInner->UnregisterApplicationStateObserver(observer);
410 // unregister not exist return ERR_INVALID_VALUE
411 EXPECT_EQ(1, err1);
412 int32_t err2 = mockAppMgrServiceInner->UnregisterApplicationStateObserver(nullptr);
413 // unregister null return ERR_INVALID_VALUE
414 EXPECT_EQ(1, err2);
415 HILOG_DEBUG("UnregisterApplicationStateObserver_001 end");
416 }
417
418 /*
419 * Feature: AmsMgrScheduler
420 * Function: LoadAbility
421 * SubFunction: NA
422 * FunctionPoints: AmsMgrScheduler LoadAbility
423 * EnvConditions: NA
424 * CaseDescription: Verify LoadAbility
425 */
426 HWTEST_F(AmsMgrSchedulerTest, LoadAbility_001, TestSize.Level0)
427 {
428 auto amsMgrScheduler = std::make_shared<AmsMgrScheduler>(nullptr, nullptr);
429 ASSERT_NE(amsMgrScheduler, nullptr);
430 sptr<IRemoteObject> token = nullptr;
431 sptr<IRemoteObject> preToken = nullptr;
432 std::shared_ptr<AbilityInfo> abilityInfo = nullptr;
433 std::shared_ptr<ApplicationInfo> appInfo = nullptr;
434 std::shared_ptr<Want> want = nullptr;
435 amsMgrScheduler->LoadAbility(token, preToken, abilityInfo, appInfo, want);
436 }
437
438 /*
439 * Feature: AmsMgrScheduler
440 * Function: LoadAbility
441 * SubFunction: NA
442 * FunctionPoints: AmsMgrScheduler LoadAbility
443 * EnvConditions: NA
444 * CaseDescription: Verify LoadAbility
445 */
446 HWTEST_F(AmsMgrSchedulerTest, LoadAbility_002, TestSize.Level0)
447 {
448 auto amsMgrScheduler = std::make_shared<AmsMgrScheduler>(nullptr, nullptr);
449 ASSERT_NE(amsMgrScheduler, nullptr);
450 sptr<IRemoteObject> token = nullptr;
451 sptr<IRemoteObject> preToken = nullptr;
452 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
453 std::shared_ptr<ApplicationInfo> appInfo = nullptr;
454 std::shared_ptr<Want> want = nullptr;
455 amsMgrScheduler->LoadAbility(token, preToken, abilityInfo, appInfo, want);
456 }
457
458 /*
459 * Feature: AmsMgrScheduler
460 * Function: LoadAbility
461 * SubFunction: NA
462 * FunctionPoints: AmsMgrScheduler LoadAbility
463 * EnvConditions: NA
464 * CaseDescription: Verify LoadAbility
465 */
466 HWTEST_F(AmsMgrSchedulerTest, LoadAbility_003, TestSize.Level0)
467 {
468 auto amsMgrScheduler = std::make_shared<AmsMgrScheduler>(nullptr, nullptr);
469 ASSERT_NE(amsMgrScheduler, nullptr);
470 sptr<IRemoteObject> token = nullptr;
471 sptr<IRemoteObject> preToken = nullptr;
472 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
473 std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
474 std::shared_ptr<Want> want = nullptr;
475 amsMgrScheduler->LoadAbility(token, preToken, abilityInfo, appInfo, want);
476 }
477
478 /*
479 * Feature: AmsMgrScheduler
480 * Function: LoadAbility
481 * SubFunction: NA
482 * FunctionPoints: AmsMgrScheduler LoadAbility
483 * EnvConditions: NA
484 * CaseDescription: Verify LoadAbility
485 */
486 HWTEST_F(AmsMgrSchedulerTest, LoadAbility_004, TestSize.Level0)
487 {
488 auto mockAppMgrServiceInner = GetMockAppMgrServiceInner();
489 std::unique_ptr<AmsMgrScheduler> amsMgrScheduler =
490 std::make_unique<AmsMgrScheduler>(mockAppMgrServiceInner, GetAmsTaskHandler());
491 ASSERT_NE(amsMgrScheduler, nullptr);
492 sptr<IRemoteObject> token = nullptr;
493 sptr<IRemoteObject> preToken = nullptr;
494 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
495 std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
496 std::shared_ptr<Want> want = nullptr;
497 amsMgrScheduler->LoadAbility(token, preToken, abilityInfo, appInfo, want);
498 }
499
500 /*
501 * Feature: AmsMgrScheduler
502 * Function: UpdateAbilityState
503 * SubFunction: NA
504 * FunctionPoints: AmsMgrScheduler UpdateAbilityState
505 * EnvConditions: NA
506 * CaseDescription: Verify UpdateAbilityState
507 */
508 HWTEST_F(AmsMgrSchedulerTest, UpdateAbilityState_001, TestSize.Level0)
509 {
510 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
511 ASSERT_NE(amsMgrScheduler, nullptr);
512 sptr<IRemoteObject> token = nullptr;
513 AbilityState state = AbilityState::ABILITY_STATE_READY;
514 amsMgrScheduler->UpdateAbilityState(token, state);
515 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
516 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
517 amsMgrScheduler->UpdateAbilityState(token, state);
518 }
519
520 /*
521 * Feature: AmsMgrScheduler
522 * Function: UpdateExtensionState
523 * SubFunction: NA
524 * FunctionPoints: AmsMgrScheduler UpdateExtensionState
525 * EnvConditions: NA
526 * CaseDescription: Verify UpdateExtensionState
527 */
528 HWTEST_F(AmsMgrSchedulerTest, UpdateExtensionState_001, TestSize.Level0)
529 {
530 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
531 ASSERT_NE(amsMgrScheduler, nullptr);
532 sptr<IRemoteObject> token = nullptr;
533 ExtensionState state = ExtensionState::EXTENSION_STATE_READY;
534 amsMgrScheduler->UpdateExtensionState(token, state);
535 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
536 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
537 amsMgrScheduler->UpdateExtensionState(token, state);
538 }
539
540 /*
541 * Feature: AmsMgrScheduler
542 * Function: TerminateAbility
543 * SubFunction: NA
544 * FunctionPoints: AmsMgrScheduler TerminateAbility
545 * EnvConditions: NA
546 * CaseDescription: Verify TerminateAbility
547 */
548 HWTEST_F(AmsMgrSchedulerTest, TerminateAbility_001, TestSize.Level0)
549 {
550 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
551 ASSERT_NE(amsMgrScheduler, nullptr);
552 sptr<IRemoteObject> token = nullptr;
553 bool clearMissionFlag = true;
554 amsMgrScheduler->TerminateAbility(token, clearMissionFlag);
555 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
556 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
557 amsMgrScheduler->TerminateAbility(token, clearMissionFlag);
558 }
559
560 /*
561 * Feature: AmsMgrScheduler
562 * Function: RegisterAppStateCallback
563 * SubFunction: NA
564 * FunctionPoints: AmsMgrScheduler RegisterAppStateCallback
565 * EnvConditions: NA
566 * CaseDescription: Verify RegisterAppStateCallback
567 */
568 HWTEST_F(AmsMgrSchedulerTest, RegisterAppStateCallback_001, TestSize.Level0)
569 {
570 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
571 ASSERT_NE(amsMgrScheduler, nullptr);
572 sptr<IAppStateCallback> callback = nullptr;
573 amsMgrScheduler->RegisterAppStateCallback(callback);
574 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
575 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
576 amsMgrScheduler->RegisterAppStateCallback(callback);
577 }
578
579 /*
580 * Feature: AmsMgrScheduler
581 * Function: AbilityBehaviorAnalysis
582 * SubFunction: NA
583 * FunctionPoints: AmsMgrScheduler AbilityBehaviorAnalysis
584 * EnvConditions: NA
585 * CaseDescription: Verify AbilityBehaviorAnalysis
586 */
587 HWTEST_F(AmsMgrSchedulerTest, AbilityBehaviorAnalysis_001, TestSize.Level0)
588 {
589 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
590 ASSERT_NE(amsMgrScheduler, nullptr);
591 sptr<IRemoteObject> token = nullptr;
592 sptr<IRemoteObject> preToken = nullptr;
593 int32_t visibility = 0;
594 int32_t perceptibility = 0;
595 int32_t connectionState = 0;
596 amsMgrScheduler->AbilityBehaviorAnalysis(token, preToken, visibility, perceptibility, connectionState);
597 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
598 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
599 amsMgrScheduler->AbilityBehaviorAnalysis(token, preToken, visibility, perceptibility, connectionState);
600 }
601
602 /*
603 * Feature: AmsMgrScheduler
604 * Function: KillProcessesByUserId
605 * SubFunction: NA
606 * FunctionPoints: AmsMgrScheduler KillProcessesByUserId
607 * EnvConditions: NA
608 * CaseDescription: Verify KillProcessesByUserId
609 */
610 HWTEST_F(AmsMgrSchedulerTest, KillProcessesByUserId_001, TestSize.Level0)
611 {
612 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
613 ASSERT_NE(amsMgrScheduler, nullptr);
614 int32_t userId = 0;
615 amsMgrScheduler->KillProcessesByUserId(userId);
616 }
617
618 /*
619 * Feature: AmsMgrScheduler
620 * Function: KillProcessWithAccount
621 * SubFunction: NA
622 * FunctionPoints: AmsMgrScheduler KillProcessWithAccount
623 * EnvConditions: NA
624 * CaseDescription: Verify KillProcessWithAccount
625 */
626 HWTEST_F(AmsMgrSchedulerTest, KillProcessWithAccount_001, TestSize.Level0)
627 {
628 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
629 ASSERT_NE(amsMgrScheduler, nullptr);
630 std::string bundleName = "bundleName";
631 int accountId = 0;
632 int32_t res1 = amsMgrScheduler->KillProcessWithAccount(bundleName, accountId);
633 EXPECT_EQ(res1, ERR_INVALID_OPERATION);
634 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
635 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
636 int32_t res2 = amsMgrScheduler->KillProcessWithAccount(bundleName, accountId);
637 EXPECT_NE(res2, ERR_INVALID_OPERATION);
638 }
639
640 /*
641 * Feature: AmsMgrScheduler
642 * Function: AbilityAttachTimeOut
643 * SubFunction: NA
644 * FunctionPoints: AmsMgrScheduler AbilityAttachTimeOut
645 * EnvConditions: NA
646 * CaseDescription: Verify AbilityAttachTimeOut
647 */
648 HWTEST_F(AmsMgrSchedulerTest, AbilityAttachTimeOut_001, TestSize.Level0)
649 {
650 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
651 ASSERT_NE(amsMgrScheduler, nullptr);
652 sptr<IRemoteObject> token = nullptr;
653 amsMgrScheduler->AbilityAttachTimeOut(token);
654 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
655 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
656 amsMgrScheduler->AbilityAttachTimeOut(token);
657 }
658
659 /*
660 * Feature: AmsMgrScheduler
661 * Function: PrepareTerminate
662 * SubFunction: NA
663 * FunctionPoints: AmsMgrScheduler PrepareTerminate
664 * EnvConditions: NA
665 * CaseDescription: Verify PrepareTerminate
666 */
667 HWTEST_F(AmsMgrSchedulerTest, PrepareTerminate_001, TestSize.Level0)
668 {
669 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
670 ASSERT_NE(amsMgrScheduler, nullptr);
671 sptr<IRemoteObject> token = nullptr;
672 amsMgrScheduler->PrepareTerminate(token);
673 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
674 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
675 amsMgrScheduler->PrepareTerminate(token);
676 }
677
678 /*
679 * Feature: AmsMgrScheduler
680 * Function: KillApplication
681 * SubFunction: NA
682 * FunctionPoints: AmsMgrScheduler KillApplication
683 * EnvConditions: NA
684 * CaseDescription: Verify KillApplication
685 */
686 HWTEST_F(AmsMgrSchedulerTest, KillApplication_001, TestSize.Level0)
687 {
688 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
689 ASSERT_NE(amsMgrScheduler, nullptr);
690 std::string bundleName = "bundleName";
691 amsMgrScheduler->KillApplication(bundleName);
692 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
693 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
694 amsMgrScheduler->KillApplication(bundleName);
695 }
696
697 /*
698 * Feature: AmsMgrScheduler
699 * Function: KillApplicationByUid
700 * SubFunction: NA
701 * FunctionPoints: AmsMgrScheduler KillApplicationByUid
702 * EnvConditions: NA
703 * CaseDescription: Verify KillApplicationByUid
704 */
705 HWTEST_F(AmsMgrSchedulerTest, KillApplicationByUid_001, TestSize.Level0)
706 {
707 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
708 ASSERT_NE(amsMgrScheduler, nullptr);
709 std::string bundleName = "bundleName";
710 int uid = 0;
711 amsMgrScheduler->KillApplicationByUid(bundleName, uid);
712 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
713 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
714 amsMgrScheduler->KillApplicationByUid(bundleName, uid);
715 }
716
717 /*
718 * Feature: AmsMgrScheduler
719 * Function: KillApplicationSelf
720 * SubFunction: NA
721 * FunctionPoints: AmsMgrScheduler KillApplicationSelf
722 * EnvConditions: NA
723 * CaseDescription: Verify KillApplicationSelf
724 */
725 HWTEST_F(AmsMgrSchedulerTest, KillApplicationSelf_001, TestSize.Level0)
726 {
727 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
728 ASSERT_NE(amsMgrScheduler, nullptr);
729 amsMgrScheduler->KillApplicationSelf();
730 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
731 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
732 amsMgrScheduler->KillApplicationSelf();
733 }
734
735 /*
736 * Feature: AmsMgrScheduler
737 * Function: GetRunningProcessInfoByToken
738 * SubFunction: NA
739 * FunctionPoints: AmsMgrScheduler GetRunningProcessInfoByToken
740 * EnvConditions: NA
741 * CaseDescription: Verify GetRunningProcessInfoByToken
742 */
743 HWTEST_F(AmsMgrSchedulerTest, GetRunningProcessInfoByToken_001, TestSize.Level0)
744 {
745 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
746 ASSERT_NE(amsMgrScheduler, nullptr);
747 sptr<IRemoteObject> token = nullptr;
748 RunningProcessInfo info;
749 amsMgrScheduler->GetRunningProcessInfoByToken(token, info);
750 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
751 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
752 amsMgrScheduler->GetRunningProcessInfoByToken(token, info);
753 }
754
755 /*
756 * Feature: AmsMgrScheduler
757 * Function: GetRunningProcessInfoByPid
758 * SubFunction: NA
759 * FunctionPoints: AmsMgrScheduler GetRunningProcessInfoByPid
760 * EnvConditions: NA
761 * CaseDescription: Verify GetRunningProcessInfoByPid
762 */
763 HWTEST_F(AmsMgrSchedulerTest, GetRunningProcessInfoByPid_001, TestSize.Level0)
764 {
765 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
766 ASSERT_NE(amsMgrScheduler, nullptr);
767 pid_t pid = 0;
768 RunningProcessInfo info;
769 amsMgrScheduler->GetRunningProcessInfoByPid(pid, info);
770 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
771 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
772 amsMgrScheduler->GetRunningProcessInfoByPid(pid, info);
773 }
774
775 /*
776 * Feature: AmsMgrScheduler
777 * Function: StartSpecifiedAbility
778 * SubFunction: NA
779 * FunctionPoints: AmsMgrScheduler StartSpecifiedAbility
780 * EnvConditions: NA
781 * CaseDescription: Verify StartSpecifiedAbility
782 */
783 HWTEST_F(AmsMgrSchedulerTest, StartSpecifiedAbility_001, TestSize.Level0)
784 {
785 auto mockBundleMgr = new (std::nothrow) BundleMgrService();
786 auto remoteClientManager = std::make_shared<RemoteClientManager>();
787 remoteClientManager->SetBundleManager(mockBundleMgr);
788 auto amsMgrServiceInner = std::make_shared<AppMgrServiceInner>();
789 amsMgrServiceInner->remoteClientManager_ = remoteClientManager;
790 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(amsMgrServiceInner, nullptr);
791 ASSERT_NE(amsMgrScheduler, nullptr);
792 Want want;
793 AbilityInfo abilityInfo;
794 amsMgrScheduler->StartSpecifiedAbility(want, abilityInfo);
795 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
796 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
797 amsMgrScheduler->StartSpecifiedAbility(want, abilityInfo);
798 }
799
800 /*
801 * Feature: AmsMgrScheduler
802 * Function: RegisterStartSpecifiedAbilityResponse
803 * SubFunction: NA
804 * FunctionPoints: AmsMgrScheduler RegisterStartSpecifiedAbilityResponse
805 * EnvConditions: NA
806 * CaseDescription: Verify RegisterStartSpecifiedAbilityResponse
807 */
808 HWTEST_F(AmsMgrSchedulerTest, RegisterStartSpecifiedAbilityResponse_001, TestSize.Level0)
809 {
810 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
811 ASSERT_NE(amsMgrScheduler, nullptr);
812 sptr<IStartSpecifiedAbilityResponse> response = nullptr;
813 amsMgrScheduler->RegisterStartSpecifiedAbilityResponse(response);
814 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
815 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
816 amsMgrScheduler->RegisterStartSpecifiedAbilityResponse(response);
817 }
818
819 /*
820 * Feature: AmsMgrScheduler
821 * Function: GetApplicationInfoByProcessID
822 * SubFunction: NA
823 * FunctionPoints: AmsMgrScheduler GetApplicationInfoByProcessID
824 * EnvConditions: NA
825 * CaseDescription: Verify GetApplicationInfoByProcessID
826 */
827 HWTEST_F(AmsMgrSchedulerTest, GetApplicationInfoByProcessID_001, TestSize.Level0)
828 {
829 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
830 int pid = 0;
831 ApplicationInfo application;
832 bool debug = true;
833 int res1 = amsMgrScheduler->GetApplicationInfoByProcessID(pid, application, debug);
834 EXPECT_EQ(res1, ERR_INVALID_OPERATION);
835 amsMgrScheduler->amsMgrServiceInner_ = GetMockAppMgrServiceInner();
836 amsMgrScheduler->amsHandler_ = GetAmsTaskHandler();
837 int res2 = amsMgrScheduler->GetApplicationInfoByProcessID(pid, application, debug);
838 EXPECT_NE(res2, ERR_INVALID_OPERATION);
839 }
840
841 /**
842 * @tc.name: SetCurrentUserId_001
843 * @tc.desc: set current userId.
844 * @tc.type: FUNC
845 */
846 HWTEST_F(AmsMgrSchedulerTest, SetCurrentUserId_001, TestSize.Level0)
847 {
848 auto amsMgrScheduler = std::make_unique<AmsMgrScheduler>(nullptr, nullptr);
849 ASSERT_NE(amsMgrScheduler, nullptr);
850 int userId = 1;
851 amsMgrScheduler->SetCurrentUserId(userId);
852 }
853 } // namespace AppExecFwk
854 } // namespace OHOS
855