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