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 #define private public
18 #define protected public
19 #include "ability_manager_service.h"
20 #include "ability_event_handler.h"
21 #include "ability_connect_manager.h"
22 #include "ams_configuration_parameter.h"
23 #include "mission_list_manager.h"
24 #undef private
25 #undef protected
26 
27 #include "app_process_data.h"
28 #include "system_ability_definition.h"
29 #include "ability_manager_errors.h"
30 #include "ability_scheduler.h"
31 #include "bundlemgr/mock_bundle_manager.h"
32 #include "sa_mgr_client.h"
33 #include "mock_ability_connect_callback.h"
34 #include "mock_ability_token.h"
35 #include "if_system_ability_manager.h"
36 #include "iservice_registry.h"
37 #include "os_account_manager_wrapper.h"
38 using namespace testing;
39 using namespace testing::ext;
40 using namespace OHOS::AppExecFwk;
41 namespace OHOS {
42 namespace AAFwk {
WaitUntilTaskFinished()43 static void WaitUntilTaskFinished()
44 {
45     const uint32_t maxRetryCount = 1000;
46     const uint32_t sleepTime = 1000;
47     uint32_t count = 0;
48     auto handler = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance()->GetTaskHandler();
49     std::atomic<bool> taskCalled(false);
50     auto f = [&taskCalled]() { taskCalled.store(true); };
51     if (handler->SubmitTask(f)) {
52         while (!taskCalled.load()) {
53             ++count;
54             if (count >= maxRetryCount) {
55                 break;
56             }
57             usleep(sleepTime);
58         }
59     }
60 }
61 
GetMissionListTopAbility(std::shared_ptr<MissionListManagerInterface> missionListMgr)62 static std::shared_ptr<AbilityRecord> GetMissionListTopAbility(
63     std::shared_ptr<MissionListManagerInterface> missionListMgr)
64 {
65     if (!missionListMgr) {
66         return nullptr;
67     }
68     return reinterpret_cast<MissionListManager*>(missionListMgr.get()).GetCurrentTopAbilityLocked();
69 }
70 
71 namespace {
72 const int32_t USER_ID_U100 = 100;
73 const int32_t ERROR_USER_ID_U256 = 256;
74 }  // namespace
75 class AbilityManagerServiceAccountTest : public testing::Test {
76 public:
77     static void SetUpTestCase();
78     static void TearDownTestCase();
79     void SetUp();
80     void TearDown();
81 public:
82     inline static std::shared_ptr<AbilityManagerService> abilityMs_{ nullptr };
83     AbilityRequest abilityRequest_{};
84 };
85 static int32_t newUserId;
SetUpTestCase()86 void AbilityManagerServiceAccountTest::SetUpTestCase()
87 {
88     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest SetUpTestCase called";
89     OHOS::DelayedSingleton<SaMgrClient>::GetInstance()->RegisterSystemAbility(
90         OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService());
91     DelayedSingleton<OsAccountManagerWrapper>::GetInstance()->
92         CreateOsAccount("testAccount", newUserId);
93     abilityMs_ = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance();
94     abilityMs_->OnStart();
95     WaitUntilTaskFinished();
96     GTEST_LOG_(INFO) << "Create new user. UserId: " << newUserId;
97 }
98 
TearDownTestCase()99 void AbilityManagerServiceAccountTest::TearDownTestCase()
100 {
101     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest TearDownTestCase called";
102     abilityMs_->OnStop();
103     OHOS::DelayedSingleton<SaMgrClient>::DestroyInstance();
104     OHOS::DelayedSingleton<AbilityManagerService>::DestroyInstance();
105     DelayedSingleton<OsAccountManagerWrapper>::GetInstance()->RemoveOsAccount(newUserId);
106 }
107 
SetUp()108 void AbilityManagerServiceAccountTest::SetUp()
109 {}
110 
TearDown()111 void AbilityManagerServiceAccountTest::TearDown()
112 {}
113 
114 /*
115  * Feature: AbilityManagerService
116  * Function: StartAbility
117  * SubFunction: NA
118  * FunctionPoints: AbilityManagerService StartAbility
119  * EnvConditions: NA
120  * CaseDescription: 100 user and 101 user for StartAbility
121  */
122 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbility_001, TestSize.Level1)
123 {
124     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_001 start";
125     abilityMs_->StartUser(USER_ID_U100, nullptr);
126     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
127     if (topAbility) {
128         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
129     }
130     Want want;
131     ElementName element("", "com.ix.hiAccount", "AccountTest");
132     want.SetElement(element);
133     auto result = abilityMs_->StartAbility(want, USER_ID_U100);
134     WaitUntilTaskFinished();
135     EXPECT_EQ(OHOS::ERR_OK, result);
136 
137     abilityMs_->StartUser(newUserId, nullptr);
138     topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(newUserId));
139     if (topAbility) {
140         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
141     }
142 
143     result = abilityMs_->StartAbility(want, newUserId);
144     WaitUntilTaskFinished();
145     EXPECT_EQ(OHOS::ERR_OK, result);
146     abilityMs_->StartUser(USER_ID_U100, nullptr);
147     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_001 end";
148 }
149 
150 /*
151  * Feature: AbilityManagerService
152  * Function: StartAbility
153  * SubFunction: NA
154  * FunctionPoints: AbilityManagerService StartAbility
155  * EnvConditions: NA
156  * CaseDescription: Start standard PageAbility with 100 user authentication StartAbility interface
157  */
158 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbility_002, TestSize.Level1)
159 {
160     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_002 start";
161     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
162     if (topAbility) {
163         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
164     }
165     Want want;
166     ElementName element("", "com.ix.hiworld", "WorldService");
167     want.SetElement(element);
168     auto result = abilityMs_->StartAbility(want, USER_ID_U100);
169     WaitUntilTaskFinished();
170     EXPECT_EQ(OHOS::ERR_OK, result);
171 
172     topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
173     sptr<IRemoteObject> token = nullptr;
174     if (topAbility) {
175         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
176         token = topAbility->GetToken();
177     }
178 
179     Want want1;
180     ElementName element1("", "com.ix.hiMusic", "hiMusic");
181     want1.SetElement(element1);
182     auto result1 = abilityMs_->StartAbility(want1, token, USER_ID_U100);
183     EXPECT_EQ(OHOS::ERR_OK, result1);
184     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_002 end";
185 }
186 
187 /*
188  * Feature: AbilityManagerService
189  * Function: StartAbility
190  * SubFunction: NA
191  * FunctionPoints: AbilityManagerService StartAbility
192  * EnvConditions: NA
193  * CaseDescription: use 100 user and 101 user to start StartAbility in abilityStartSetting mode
194  */
195 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbility_003, TestSize.Level1)
196 {
197     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_003 start";
198     AbilityStartSetting abilityStartSetting;
199     // default user
200     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
201     if (topAbility) {
202         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
203     }
204     Want want;
205     ElementName element("", "com.ix.hiMusic", "hiMusic");
206     want.SetElement(element);
207     auto result = abilityMs_->StartAbility(want, abilityStartSetting, nullptr, USER_ID_U100, -1);
208     WaitUntilTaskFinished();
209     EXPECT_EQ(OHOS::ERR_OK, result);
210 
211     abilityMs_->StartUser(newUserId, nullptr);
212     topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(newUserId));
213     if (topAbility) {
214         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
215     }
216     result = abilityMs_->StartAbility(want, abilityStartSetting, nullptr, newUserId, -1);
217     WaitUntilTaskFinished();
218     EXPECT_EQ(OHOS::ERR_OK, result);
219     abilityMs_->StartUser(USER_ID_U100, nullptr);
220     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_003 end";
221 }
222 
223 /*
224  * Feature: AbilityManagerService
225  * Function: StartAbility
226  * SubFunction: NA
227  * FunctionPoints: AbilityManagerService StartAbility
228  * EnvConditions: NA
229  * CaseDescription: use 100 user and 101 user to start StartAbility in abilityStartOptions mode
230  */
231 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbility_004, TestSize.Level1)
232 {
233     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_004 start";
234     StartOptions abilityStartOptions;
235     // default user
236     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
237     if (topAbility) {
238         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
239     }
240     Want want;
241     ElementName element("", "com.ix.hiMusic", "hiMusic");
242     want.SetElement(element);
243     auto result = abilityMs_->StartAbility(want, abilityStartOptions, nullptr, USER_ID_U100, -1);
244     WaitUntilTaskFinished();
245     EXPECT_EQ(OHOS::ERR_OK, result);
246 
247     abilityMs_->StartUser(newUserId, nullptr);
248     topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(newUserId));
249     if (topAbility) {
250         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
251     }
252     result = abilityMs_->StartAbility(want, abilityStartOptions, nullptr, newUserId, -1);
253     WaitUntilTaskFinished();
254     EXPECT_EQ(OHOS::ERR_OK, result);
255     abilityMs_->StartUser(USER_ID_U100, nullptr);
256     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_004 end";
257 }
258 
259 /*
260  * Feature: AbilityManagerService
261  * Function: StartAbility
262  * SubFunction: NA
263  * FunctionPoints: AbilityManagerService StartAbility
264  * EnvConditions: NA
265  * CaseDescription: use 0 Standard user to start StartAbility in abilityStartOptions mode
266  * StartAbility parameter
267  */
268 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbility_005, TestSize.Level1)
269 {
270     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_005 start";
271     Want want;
272     ElementName element("", "com.ix.hiSingleMusicInfo", "SingleMusicAbility");
273     want.SetElement(element);
274     StartOptions abilityStartOptions;
275     auto result = abilityMs_->StartAbility(want, abilityStartOptions, nullptr, 0, -1);
276     EXPECT_NE(OHOS::ERR_OK, result);
277     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_005 end";
278 }
279 
280 /*
281  * Feature: AbilityManagerService
282  * Function: StartAbility
283  * SubFunction: NA
284  * FunctionPoints: AbilityManagerService StartAbility
285  * EnvConditions: NA
286  * CaseDescription: Start single ServiceAbility with 0 user authentication StartAbility interface
287  * StartAbility parameter
288  */
289 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbility_006, TestSize.Level1)
290 {
291     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_006 start";
292     Want want;
293     ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic");
294     want.SetElement(element);
295     StartOptions abilityStartOptions;
296     auto result = abilityMs_->StartAbility(want, abilityStartOptions, nullptr, 0, -1);
297     EXPECT_NE(OHOS::ERR_OK, result);
298     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_006 end";
299 }
300 
301 /*
302  * Feature: AbilityManagerService
303  * Function: StartAbility
304  * SubFunction: NA
305  * FunctionPoints: AbilityManagerService StartAbility
306  * EnvConditions: NA
307  * CaseDescription: Start single PageAbility with 100 user authentication StartAbility interface
308  * StartAbility parameter
309  */
310 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbility_007, TestSize.Level1)
311 {
312     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_007 start";
313     abilityMs_->StartUser(USER_ID_U100, nullptr);
314     Want want;
315     ElementName element("", "com.ix.hiSingleMusicInfo", "SingleMusicAbility");
316     want.SetElement(element);
317     StartOptions abilityStartOptions;
318     auto result = abilityMs_->StartAbility(want, abilityStartOptions, nullptr, USER_ID_U100, -1);
319     EXPECT_EQ(OHOS::ERR_OK, result);
320     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_007 end";
321 }
322 
323 /*
324  * Feature: AbilityManagerService
325  * Function: StartAbility
326  * SubFunction: NA
327  * FunctionPoints: AbilityManagerService StartAbility
328  * EnvConditions: NA
329  * CaseDescription: Start single ServiceAbility with 100 user authentication StartAbility interface
330  * StartAbility parameter
331  */
332 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbility_008, TestSize.Level1)
333 {
334     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_008 start";
335     abilityMs_->StartUser(USER_ID_U100, nullptr);
336     Want want;
337     ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic");
338     want.SetElement(element);
339     StartOptions abilityStartOptions;
340     auto result = abilityMs_->StartAbility(want, abilityStartOptions, nullptr, USER_ID_U100, -1);
341     EXPECT_NE(OHOS::ERR_OK, result);
342     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_008 end";
343 }
344 
345 /*
346  * Feature: AbilityManagerService
347  * Function: StartAbility
348  * SubFunction: NA
349  * FunctionPoints: AbilityManagerService StartAbility
350  * EnvConditions: NA
351  * CaseDescription: Start single PageAbility with error user authentication StartAbility interface
352  * StartAbility parameter
353  */
354 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbility_009, TestSize.Level1)
355 {
356     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_009 start";
357     Want want;
358     ElementName element("", "com.ix.hiSingleMusicInfo", "SingleMusicAbility");
359     want.SetElement(element);
360     StartOptions abilityStartOptions;
361     auto result = abilityMs_->StartAbility(want, abilityStartOptions, nullptr, ERROR_USER_ID_U256, -1);
362     EXPECT_NE(OHOS::ERR_OK, result);
363     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_009 end";
364 }
365 
366 /*
367  * Feature: AbilityManagerService
368  * Function: StartAbility
369  * SubFunction: NA
370  * FunctionPoints: AbilityManagerService StartAbility
371  * EnvConditions: NA
372  * CaseDescription: Start single ServiceAbility with error user authentication StartAbility interface
373  * StartAbility parameter
374  */
375 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbility_010, TestSize.Level1)
376 {
377     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_010 start";
378     Want want;
379     ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic");
380     want.SetElement(element);
381     StartOptions abilityStartOptions;
382     auto result = abilityMs_->StartAbility(want, abilityStartOptions, nullptr, ERROR_USER_ID_U256, -1);
383     EXPECT_NE(OHOS::ERR_OK, result);
384     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_010 end";
385 }
386 
387 /*
388  * Feature: AbilityManagerService
389  * Function: StartAbility
390  * SubFunction: NA
391  * FunctionPoints: AbilityManagerService StartAbility
392  * EnvConditions: NA
393  * CaseDescription: 100 users StartAbility start 101 users' app in non-concurrent mode
394  * StartAbility parameter
395  */
396 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbility_011, TestSize.Level1)
397 {
398     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_011 start";
399     abilityMs_->StartUser(USER_ID_U100, nullptr);
400     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
401     if (topAbility) {
402         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
403     }
404     Want want;
405     ElementName element("device", "ohos.samples.clock", "ohos.samples.clock.default");
406     want.SetElement(element);
407     auto result = abilityMs_->StartAbility(want, newUserId);
408     WaitUntilTaskFinished();
409     EXPECT_EQ(OHOS::ERR_INVALID_VALUE, result);
410     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbility_011 end";
411 }
412 
413 /*
414  * Feature: AbilityManagerService
415  * Function: TerminateAbility
416  * SubFunction: NA
417  * FunctionPoints: AbilityManagerService TerminateAbility
418  * EnvConditions: NA
419  * CaseDescription: Start standard TerminateAbility with 100 user
420  */
421 HWTEST_F(AbilityManagerServiceAccountTest, Account_TerminateAbility_001, TestSize.Level1)
422 {
423     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_TerminateAbility_001 start";
424     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
425     if (topAbility) {
426         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
427     }
428     Want want;
429     ElementName element("", "com.ix.hiAccount", "AccountTest");
430     want.SetElement(element);
431     auto result = abilityMs_->StartAbility(want, USER_ID_U100, -1);
432     WaitUntilTaskFinished();
433     EXPECT_EQ(OHOS::ERR_OK, result);
434 
435     topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
436 
437     sptr<IRemoteObject> token = nullptr;
438     if (topAbility) {
439         token = topAbility->GetToken();
440     }
441 
442     auto result1 = abilityMs_->TerminateAbility(token, -1, &want);
443     WaitUntilTaskFinished();
444     EXPECT_EQ(ERR_OK, result1);
445     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_TerminateAbility_001 end";
446 }
447 
448 /*
449  * Feature: AbilityManagerService
450  * Function: StartAbilityInner
451  * SubFunction: NA
452  * FunctionPoints: AbilityManagerService StartAbilityInner
453  * EnvConditions: NA
454  * CaseDescription: Start single PageAbility with 0 user authentication StartAbilityInner interface
455  * StartAbilityInner parameter
456  */
457 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbilityInner_001, TestSize.Level1)
458 {
459     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbilityInner_001 start";
460     Want want;
461     ElementName element("", "com.ix.hiSingleMusicInfo", "SingleMusicAbility");
462     want.SetElement(element);
463     auto result = abilityMs_->StartAbilityInner(want, nullptr, -1, false);
464     EXPECT_EQ(OHOS::ERR_OK, result);
465     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbilityInner_001 end";
466 }
467 
468 /*
469  * Feature: AbilityManagerService
470  * Function: StartAbilityInner
471  * SubFunction: NA
472  * FunctionPoints: AbilityManagerService StartAbilityInner
473  * EnvConditions: NA
474  * CaseDescription: Start single ServiceAbility with 0 user authentication StartAbilityInner interface
475  * StartAbilityInner parameter
476  */
477 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbilityInner_002, TestSize.Level1)
478 {
479     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbilityInner_002 start";
480     Want want;
481     ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic");
482     want.SetElement(element);
483     auto result = abilityMs_->StartAbilityInner(want, nullptr, -1, false);
484     EXPECT_EQ(OHOS::ERR_OK, result);
485     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbilityInner_002 end";
486 }
487 
488 /*
489  * Feature: AbilityManagerService
490  * Function: StartAbilityInner
491  * SubFunction: NA
492  * FunctionPoints: AbilityManagerService StartAbilityInner
493  * EnvConditions: NA
494  * CaseDescription: Start single PageAbility with 100 user authentication StartAbilityInner interface
495  * StartAbilityInner parameter
496  */
497 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbilityInner_003, TestSize.Level1)
498 {
499     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbilityInner_003 start";
500     Want want;
501     ElementName element("", "com.ix.hiSingleMusicInfo", "SingleMusicAbility");
502     want.SetElement(element);
503     auto result = abilityMs_->StartAbilityInner(want, nullptr, -1, false, -1, USER_ID_U100);
504     EXPECT_EQ(OHOS::ERR_OK, result);
505     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbilityInner_003 end";
506 }
507 
508 /*
509  * Feature: AbilityManagerService
510  * Function: StartAbilityInner
511  * SubFunction: NA
512  * FunctionPoints: AbilityManagerService StartAbilityInner
513  * EnvConditions: NA
514  * CaseDescription: Start single ServiceAbility with 100 user authentication StartAbilityInner interface
515  * StartAbilityInner parameter
516  */
517 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbilityInner_004, TestSize.Level1)
518 {
519     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbilityInner_004 start";
520     Want want;
521     ElementName element("", "com.ix.hiBackgroundData", "hiBackgroundData");
522     want.SetElement(element);
523     auto result = abilityMs_->StartAbilityInner(want, nullptr, -1, false, -1, USER_ID_U100);
524     EXPECT_EQ(OHOS::ERR_OK, result);
525     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbilityInner_004 end";
526 }
527 
528 /*
529  * Feature: AbilityManagerService
530  * Function: StartAbilityInner
531  * SubFunction: NA
532  * FunctionPoints: AbilityManagerService StartAbilityInner
533  * EnvConditions: NA
534  * CaseDescription: Start single PageAbility with error user authentication StartAbilityInner interface
535  * StartAbilityInner parameter
536  */
537 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbilityInner_005, TestSize.Level1)
538 {
539     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbilityInner_005 start";
540     Want want;
541     ElementName element("", "com.ix.hiSingleMusicInfo", "SingleMusicAbility");
542     want.SetElement(element);
543     auto result = abilityMs_->StartAbilityInner(want, nullptr, -1, false, -1, ERROR_USER_ID_U256);
544     EXPECT_NE(OHOS::ERR_OK, result);
545     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbilityInner_005 end";
546 }
547 
548 /*
549  * Feature: AbilityManagerService
550  * Function: StartAbilityInner
551  * SubFunction: NA
552  * FunctionPoints: AbilityManagerService StartAbilityInner
553  * EnvConditions: NA
554  * CaseDescription: Start single ServiceAbility with error user authentication StartAbilityInner interface
555  * StartAbilityInner parameter
556  */
557 HWTEST_F(AbilityManagerServiceAccountTest, Account_StartAbilityInner_006, TestSize.Level1)
558 {
559     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbilityInner_006 start";
560     Want want;
561     ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic");
562     want.SetElement(element);
563     auto result = abilityMs_->StartAbilityInner(want, nullptr, -1, false, -1, ERROR_USER_ID_U256);
564     EXPECT_NE(OHOS::ERR_OK, result);
565     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StartAbilityInner_006 end";
566 }
567 
568 /*
569  * Feature: AbilityManagerService
570  * Function: ConnectAbility
571  * SubFunction: NA
572  * FunctionPoints: AbilityManagerService ConnectAbility
573  * EnvConditions: NA
574  * CaseDescription: Verify the following:
575  * 1.user id is U100
576  * 1.callback is nullptr, connectAbility failed
577  * 2.ability type is page, connectAbility failed
578  * 3.ability type is service and callback is not nullptr, connectAbility success
579  */
580 HWTEST_F(AbilityManagerServiceAccountTest, Account_ConnectAbility_001, TestSize.Level1)
581 {
582     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ConnectAbility_001 start";
583     Want want;
584     ElementName element("", "com.ix.musicService", "MusicService");
585     want.SetElement(element);
586     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
587     auto result = abilityMs_->ConnectAbility(want, nullptr, nullptr, USER_ID_U100);
588     EXPECT_EQ(result, ERR_INVALID_VALUE);
589 
590     Want want1;
591     ElementName element1("", "com.ix.hiMusic", "MusicAbility");
592     want1.SetElement(element1);
593     auto result1 = abilityMs_->ConnectAbility(want1, callback, nullptr, USER_ID_U100);
594     EXPECT_EQ(result1, TARGET_ABILITY_NOT_SERVICE);
595 
596     auto result2 = abilityMs_->ConnectAbility(want, callback, nullptr, USER_ID_U100);
597     EXPECT_EQ(result2, ERR_OK);
598     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ConnectAbility_001 end";
599 }
600 
601 /*
602  * Feature: AbilityManagerService
603  * Function: ConnectAbility
604  * SubFunction: NA
605  * FunctionPoints: AbilityManagerService ConnectAbility
606  * EnvConditions: NA
607  * CaseDescription: Verify the following:
608  * 1.user id is new user id
609  * 1.callback is nullptr, connectAbility failed
610  * 2.ability type is page, connectAbility failed
611  * 3.ability type is service and callback is not nullptr, connectAbility success
612  */
613 HWTEST_F(AbilityManagerServiceAccountTest, Account_ConnectAbility_002, TestSize.Level1)
614 {
615     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ConnectAbility_002 start";
616     abilityMs_->StartUser(newUserId, nullptr);
617     Want want;
618     ElementName element("", "com.ix.musicService", "MusicService");
619     want.SetElement(element);
620     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
621     auto result = abilityMs_->ConnectAbility(want, nullptr, nullptr, newUserId);
622     EXPECT_EQ(result, ERR_INVALID_VALUE);
623 
624     Want want1;
625     ElementName element1("", "com.ix.hiMusic", "MusicAbility");
626     want1.SetElement(element1);
627     auto result1 = abilityMs_->ConnectAbility(want1, callback, nullptr, newUserId);
628     EXPECT_EQ(result1, TARGET_ABILITY_NOT_SERVICE);
629 
630     auto result2 = abilityMs_->ConnectAbility(want, callback, nullptr, newUserId);
631     EXPECT_EQ(result2, ERR_OK);
632     abilityMs_->StartUser(USER_ID_U100, nullptr);
633     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ConnectAbility_002 end";
634 }
635 
636 /*
637  * Feature: AbilityManagerService
638  * Function: ConnectAbility
639  * SubFunction: NA
640  * FunctionPoints: AbilityManagerService ConnectAbility
641  * EnvConditions: NA
642  * CaseDescription: Start single ServiceAbility with 0 user authentication ConnectAbility interface
643  * ConnectAbility parameter
644  */
645 HWTEST_F(AbilityManagerServiceAccountTest, Account_ConnectAbility_003, TestSize.Level1)
646 {
647     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ConnectAbility_003 start";
648     Want want;
649     ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic");
650     want.SetElement(element);
651     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
652     auto result = abilityMs_->ConnectAbility(want, callback, nullptr, 0);
653     EXPECT_EQ(OHOS::ERR_OK, result);
654     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ConnectAbility_003 end";
655 }
656 
657 /*
658  * Feature: AbilityManagerService
659  * Function: ConnectAbility
660  * SubFunction: NA
661  * FunctionPoints: AbilityManagerService ConnectAbility
662  * EnvConditions: NA
663  * CaseDescription: Start single ServiceAbility with 100 user authentication ConnectAbility interface
664  * ConnectAbility parameter
665  */
666 HWTEST_F(AbilityManagerServiceAccountTest, Account_ConnectAbility_004, TestSize.Level1)
667 {
668     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ConnectAbility_004 start";
669     Want want;
670     ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic");
671     want.SetElement(element);
672     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
673     auto result = abilityMs_->ConnectAbility(want, callback, nullptr, USER_ID_U100);
674     EXPECT_EQ(OHOS::ERR_OK, result);
675     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ConnectAbility_004 end";
676 }
677 
678 /*
679  * Feature: AbilityManagerService
680  * Function: ConnectAbility
681  * SubFunction: NA
682  * FunctionPoints: AbilityManagerService ConnectAbility
683  * EnvConditions: NA
684  * CaseDescription: Start single ServiceAbility with error user authentication ConnectAbility interface
685  * ConnectAbility parameter
686  */
687 HWTEST_F(AbilityManagerServiceAccountTest, Account_ConnectAbility_005, TestSize.Level1)
688 {
689     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ConnectAbility_005 start";
690     Want want;
691     ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic");
692     want.SetElement(element);
693     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
694     auto result = abilityMs_->ConnectAbility(want, callback, nullptr, ERROR_USER_ID_U256);
695     EXPECT_NE(OHOS::ERR_OK, result);
696     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ConnectAbility_005 end";
697 }
698 
699 /*
700  * Feature: AbilityManagerService
701  * Function: ConnectAbility
702  * SubFunction: NA
703  * FunctionPoints: AbilityManagerService ConnectAbility
704  * EnvConditions: NA
705  * CaseDescription: 100 users ConnectAbility start 101 users' app in non-concurrent mode
706  * ConnectAbility parameter
707  */
708 HWTEST_F(AbilityManagerServiceAccountTest, Account_ConnectAbility_006, TestSize.Level1)
709 {
710     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ConnectAbility_006 start";
711     Want want;
712     ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic");
713     want.SetElement(element);
714     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
715     auto result = abilityMs_->ConnectAbility(want, callback, nullptr, newUserId);
716     EXPECT_EQ(OHOS::ERR_INVALID_VALUE, result);
717     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ConnectAbility_006 end";
718 }
719 
720 /*
721  * Feature: AbilityManagerService
722  * Function: ScheduleConnectAbilityDone
723  * SubFunction: NA
724  * FunctionPoints: AbilityManagerService ScheduleConnectAbilityDone
725  * EnvConditions: NA
726  * CaseDescription: Verify the following:
727  * 1.the user id is U100
728  * 2.token is nullptr, ScheduleConnectAbilityDone failed
729  * 3.ability record is nullptr, ScheduleConnectAbilityDone failed
730  */
731 HWTEST_F(AbilityManagerServiceAccountTest, Account_ScheduleConnectAbilityDone_001, TestSize.Level1)
732 {
733     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleConnectAbilityDone_001 start";
734     Want want;
735     ElementName element("", "com.ix.musicService", "MusicService");
736     want.SetElement(element);
737     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
738     auto result = abilityMs_->ConnectAbility(want, callback, nullptr, USER_ID_U100);
739     WaitUntilTaskFinished();
740     EXPECT_EQ(result, ERR_OK);
741     auto serviceMap = abilityMs_->GetConnectManagerByUserId(USER_ID_U100)->GetServiceMap();
742     auto service = serviceMap.at(element.GetURI());
743     service->SetAbilityState(AAFwk::AbilityState::ACTIVE);
744 
745     const sptr<IRemoteObject> nulltToken = nullptr;
746     auto result1 = abilityMs_->ScheduleConnectAbilityDone(nulltToken, callback->AsObject());
747     WaitUntilTaskFinished();
748     EXPECT_EQ(result1, ERR_INVALID_VALUE);
749 
750     std::shared_ptr<AbilityRecord> ability = nullptr;
751     const sptr<IRemoteObject> token = new Token(ability);
752     auto result2 = abilityMs_->ScheduleConnectAbilityDone(token, callback->AsObject());
753     WaitUntilTaskFinished();
754     EXPECT_EQ(result2, ERR_INVALID_VALUE);
755 
756     auto result3 = abilityMs_->ScheduleConnectAbilityDone(service->GetToken(), callback->AsObject());
757     WaitUntilTaskFinished();
758     EXPECT_EQ(result3, ERR_OK);
759     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleConnectAbilityDone_001 end";
760 }
761 
762 /*
763  * Feature: AbilityManagerService
764  * Function: ScheduleConnectAbilityDone
765  * SubFunction: NA
766  * FunctionPoints: AbilityManagerService ScheduleConnectAbilityDone
767  * EnvConditions: NA
768  * CaseDescription: Verify the following:
769  * 1.the user id is U100
770  * 2.ability type is not service, ScheduleConnectAbilityDone failed
771  */
772 HWTEST_F(AbilityManagerServiceAccountTest, Account_ScheduleConnectAbilityDone_002, TestSize.Level1)
773 {
774     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleConnectAbilityDone_002 start";
775     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
776     if (topAbility) {
777         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
778     }
779     Want want;
780     ElementName element("", "com.ix.hiAccount", "AccountTest");
781     want.SetElement(element);
782     auto result = abilityMs_->StartAbility(want, USER_ID_U100, -1);
783     WaitUntilTaskFinished();
784     EXPECT_EQ(OHOS::ERR_OK, result);
785 
786     topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
787 
788     sptr<IRemoteObject> token = nullptr;
789     if (topAbility) {
790         token = topAbility->GetToken();
791     }
792     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
793     auto result1 = abilityMs_->ScheduleConnectAbilityDone(token, callback->AsObject());
794     WaitUntilTaskFinished();
795     EXPECT_EQ(result1, TARGET_ABILITY_NOT_SERVICE);
796     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleConnectAbilityDone_002 end";
797 }
798 
799 /*
800  * Feature: AbilityManagerService
801  * Function: ScheduleConnectAbilityDone
802  * SubFunction: NA
803  * FunctionPoints: AbilityManagerService ScheduleConnectAbilityDone
804  * EnvConditions: NA
805  * CaseDescription: Verify the following:
806  * 1.the user id is new user id
807  * 2.token is nullptr, ScheduleConnectAbilityDone failed
808  * 3.ability record is nullptr, ScheduleConnectAbilityDone failed
809  */
810 HWTEST_F(AbilityManagerServiceAccountTest, Account_ScheduleConnectAbilityDone_003, TestSize.Level1)
811 {
812     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleConnectAbilityDone_003 start";
813     abilityMs_->StartUser(newUserId, nullptr);
814     Want want;
815     ElementName element("", "com.ix.musicService", "MusicService");
816     want.SetElement(element);
817     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
818     auto result = abilityMs_->ConnectAbility(want, callback, nullptr, newUserId);
819     WaitUntilTaskFinished();
820     EXPECT_EQ(result, ERR_OK);
821     auto serviceMap = abilityMs_->GetConnectManagerByUserId(newUserId)->GetServiceMap();
822     auto service = serviceMap.at(element.GetURI());
823     service->SetAbilityState(AAFwk::AbilityState::ACTIVE);
824 
825     const sptr<IRemoteObject> nulltToken = nullptr;
826     auto result1 = abilityMs_->ScheduleConnectAbilityDone(nulltToken, callback->AsObject());
827     WaitUntilTaskFinished();
828     EXPECT_EQ(result1, ERR_INVALID_VALUE);
829 
830     std::shared_ptr<AbilityRecord> ability = nullptr;
831     const sptr<IRemoteObject> token = new Token(ability);
832     auto result2 = abilityMs_->ScheduleConnectAbilityDone(token, callback->AsObject());
833     WaitUntilTaskFinished();
834     EXPECT_EQ(result2, ERR_INVALID_VALUE);
835 
836     auto result3 = abilityMs_->ScheduleConnectAbilityDone(service->GetToken(), callback->AsObject());
837     WaitUntilTaskFinished();
838     EXPECT_EQ(result3, ERR_OK);
839     abilityMs_->StartUser(USER_ID_U100, nullptr);
840     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleConnectAbilityDone_003 end";
841 }
842 
843 /*
844  * Feature: AbilityManagerService
845  * Function: ScheduleConnectAbilityDone
846  * SubFunction: NA
847  * FunctionPoints: AbilityManagerService ScheduleConnectAbilityDone
848  * EnvConditions: NA
849  * CaseDescription: Verify the following:
850  * 1.the user id is new user id
851  * 2.ability type is not service, ScheduleConnectAbilityDone failed
852  */
853 HWTEST_F(AbilityManagerServiceAccountTest, Account_ScheduleConnectAbilityDone_004, TestSize.Level1)
854 {
855     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleConnectAbilityDone_004 start";
856     abilityMs_->StartUser(newUserId, nullptr);
857     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(newUserId));
858     if (topAbility) {
859         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
860     }
861     Want want;
862     ElementName element("", "com.ix.hiAccount", "AccountTest");
863     want.SetElement(element);
864     auto result = abilityMs_->StartAbility(want, newUserId, -1);
865     WaitUntilTaskFinished();
866     EXPECT_EQ(OHOS::ERR_OK, result);
867 
868     topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(newUserId));
869 
870     sptr<IRemoteObject> token = nullptr;
871     if (topAbility) {
872         token = topAbility->GetToken();
873     }
874     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
875     auto result1 = abilityMs_->ScheduleConnectAbilityDone(token, callback->AsObject());
876     WaitUntilTaskFinished();
877     EXPECT_EQ(result1, TARGET_ABILITY_NOT_SERVICE);
878     abilityMs_->StartUser(USER_ID_U100, nullptr);
879     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleConnectAbilityDone_004 end";
880 }
881 
882 /*
883  * Feature: AbilityManagerService
884  * Function: ScheduleDisconnectAbilityDone
885  * SubFunction: NA
886  * FunctionPoints: AbilityManagerService ScheduleDisconnectAbilityDone
887  * EnvConditions: NA
888  * CaseDescription: Verify the following:
889  * 1.the user id is U100
890  * 2.token is nullptr, ScheduleDisconnectAbilityDone failed
891  * 3.ability record is nullptr, ScheduleDisconnectAbilityDone failed
892  */
893 HWTEST_F(AbilityManagerServiceAccountTest, Account_ScheduleDisconnectAbilityDone_001, TestSize.Level1)
894 {
895     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleDisconnectAbilityDone_001 start";
896     Want want;
897     ElementName element("", "com.ix.musicService", "MusicService");
898     want.SetElement(element);
899     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
900     auto result = abilityMs_->ConnectAbility(want, callback, nullptr, USER_ID_U100);
901     WaitUntilTaskFinished();
902     EXPECT_EQ(result, ERR_OK);
903     auto serviceMap = abilityMs_->GetConnectManagerByUserId(USER_ID_U100)->GetServiceMap();
904     auto service = serviceMap.at(element.GetURI());
905     service->SetAbilityState(AAFwk::AbilityState::ACTIVE);
906 
907     const sptr<IRemoteObject> nulltToken = nullptr;
908     auto result1 = abilityMs_->ScheduleDisconnectAbilityDone(nulltToken);
909     WaitUntilTaskFinished();
910     EXPECT_EQ(result1, ERR_INVALID_VALUE);
911 
912     std::shared_ptr<AbilityRecord> ability = nullptr;
913     const sptr<IRemoteObject> token = new Token(ability);
914     auto result2 = abilityMs_->ScheduleDisconnectAbilityDone(token);
915     WaitUntilTaskFinished();
916     EXPECT_EQ(result2, ERR_INVALID_VALUE);
917 
918     auto result3 = abilityMs_->ScheduleDisconnectAbilityDone(service->GetToken());
919     WaitUntilTaskFinished();
920     EXPECT_EQ(result3, CONNECTION_NOT_EXIST);
921     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleDisconnectAbilityDone_001 end";
922 }
923 
924 /*
925  * Feature: AbilityManagerService
926  * Function: ScheduleDisconnectAbilityDone
927  * SubFunction: NA
928  * FunctionPoints: AbilityManagerService ScheduleDisconnectAbilityDone
929  * EnvConditions: NA
930  * CaseDescription: Verify the following:
931  * 1.the user id is U100
932  * 2.ability type is not service, ScheduleDisconnectAbilityDone failed
933  */
934 HWTEST_F(AbilityManagerServiceAccountTest, Account_ScheduleDisconnectAbilityDone_002, TestSize.Level1)
935 {
936     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleDisconnectAbilityDone_002 start";
937     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
938     if (topAbility) {
939         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
940     }
941     Want want;
942     ElementName element("", "com.ix.hiAccount", "AccountTest");
943     want.SetElement(element);
944     auto result = abilityMs_->StartAbility(want, USER_ID_U100, -1);
945     WaitUntilTaskFinished();
946     EXPECT_EQ(OHOS::ERR_OK, result);
947 
948     topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
949 
950     sptr<IRemoteObject> token = nullptr;
951     if (topAbility) {
952         token = topAbility->GetToken();
953     }
954     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
955     auto result1 = abilityMs_->ScheduleDisconnectAbilityDone(token);
956     WaitUntilTaskFinished();
957     EXPECT_EQ(result1, TARGET_ABILITY_NOT_SERVICE);
958     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleDisconnectAbilityDone_002 end";
959 }
960 
961 /*
962  * Feature: AbilityManagerService
963  * Function: ScheduleDisconnectAbilityDone
964  * SubFunction: NA
965  * FunctionPoints: AbilityManagerService ScheduleDisconnectAbilityDone
966  * EnvConditions: NA
967  * CaseDescription: Verify the following:
968  * 1.the user id is new user id
969  * 2.ability type is not service, ScheduleDisconnectAbilityDone failed
970  */
971 HWTEST_F(AbilityManagerServiceAccountTest, Account_ScheduleDisconnectAbilityDone_003, TestSize.Level1)
972 {
973     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleDisconnectAbilityDone_003 start";
974     abilityMs_->StartUser(newUserId, nullptr);
975     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(newUserId));
976     if (topAbility) {
977         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
978     }
979     Want want;
980     ElementName element("", "com.ix.hiAccount", "AccountTest");
981     want.SetElement(element);
982     auto result = abilityMs_->StartAbility(want, newUserId, -1);
983     WaitUntilTaskFinished();
984     EXPECT_EQ(OHOS::ERR_OK, result);
985 
986     topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(newUserId));
987 
988     sptr<IRemoteObject> token = nullptr;
989     if (topAbility) {
990         token = topAbility->GetToken();
991     }
992     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
993     auto result1 = abilityMs_->ScheduleDisconnectAbilityDone(token);
994     WaitUntilTaskFinished();
995     EXPECT_EQ(result1, TARGET_ABILITY_NOT_SERVICE);
996     abilityMs_->StartUser(USER_ID_U100, nullptr);
997     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleDisconnectAbilityDone_003 end";
998 }
999 
1000 /*
1001  * Feature: AbilityManagerService
1002  * Function: ScheduleCommandAbilityDone
1003  * SubFunction: NA
1004  * FunctionPoints: AbilityManagerService ScheduleCommandAbilityDone
1005  * EnvConditions: NA
1006  * CaseDescription: Verify the following:
1007  * 1.the user id is U100
1008  * 2.token is nullptr, ScheduleCommandAbilityDone failed
1009  * 3.ability record is nullptr, ScheduleCommandAbilityDone failed
1010  */
1011 HWTEST_F(AbilityManagerServiceAccountTest, Account_ScheduleCommandAbilityDone_001, TestSize.Level1)
1012 {
1013     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleCommandAbilityDone_001 start";
1014     Want want;
1015     ElementName element("", "com.ix.musicService", "MusicService");
1016     want.SetElement(element);
1017     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
1018     auto result = abilityMs_->ConnectAbility(want, callback, nullptr, USER_ID_U100);
1019     WaitUntilTaskFinished();
1020     EXPECT_EQ(result, ERR_OK);
1021     auto serviceMap = abilityMs_->GetConnectManagerByUserId(USER_ID_U100)->GetServiceMap();
1022     auto service = serviceMap.at(element.GetURI());
1023     service->SetAbilityState(AAFwk::AbilityState::ACTIVE);
1024 
1025     const sptr<IRemoteObject> nulltToken = nullptr;
1026     auto result1 = abilityMs_->ScheduleCommandAbilityDone(nulltToken);
1027     WaitUntilTaskFinished();
1028     EXPECT_EQ(result1, ERR_INVALID_VALUE);
1029 
1030     std::shared_ptr<AbilityRecord> ability = nullptr;
1031     const sptr<IRemoteObject> token = new Token(ability);
1032     auto result2 = abilityMs_->ScheduleCommandAbilityDone(token);
1033     WaitUntilTaskFinished();
1034     EXPECT_EQ(result2, ERR_INVALID_VALUE);
1035 
1036     auto result3 = abilityMs_->ScheduleCommandAbilityDone(service->GetToken());
1037     WaitUntilTaskFinished();
1038     EXPECT_EQ(result3, ERR_OK);
1039     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleCommandAbilityDone_001 end";
1040 }
1041 
1042 /*
1043  * Feature: AbilityManagerService
1044  * Function: ScheduleCommandAbilityDone
1045  * SubFunction: NA
1046  * FunctionPoints: AbilityManagerService ScheduleCommandAbilityDone
1047  * EnvConditions: NA
1048  * CaseDescription: Verify the following:
1049  * 1.the user id is U100
1050  * 2.ability type is not service, ScheduleCommandAbilityDone failed
1051  */
1052 HWTEST_F(AbilityManagerServiceAccountTest, Account_ScheduleCommandAbilityDone_002, TestSize.Level1)
1053 {
1054     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleCommandAbilityDone_002 start";
1055     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
1056     if (topAbility) {
1057         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
1058     }
1059     Want want;
1060     ElementName element("", "com.ix.hiAccount", "AccountTest");
1061     want.SetElement(element);
1062     auto result = abilityMs_->StartAbility(want, USER_ID_U100, -1);
1063     WaitUntilTaskFinished();
1064     EXPECT_EQ(OHOS::ERR_OK, result);
1065 
1066     topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
1067 
1068     sptr<IRemoteObject> token = nullptr;
1069     if (topAbility) {
1070         token = topAbility->GetToken();
1071     }
1072     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
1073     auto result1 = abilityMs_->ScheduleCommandAbilityDone(token);
1074     WaitUntilTaskFinished();
1075     EXPECT_EQ(result1, TARGET_ABILITY_NOT_SERVICE);
1076     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleCommandAbilityDone_002 end";
1077 }
1078 
1079 /*
1080  * Feature: AbilityManagerService
1081  * Function: ScheduleCommandAbilityDone
1082  * SubFunction: NA
1083  * FunctionPoints: AbilityManagerService ScheduleCommandAbilityDone
1084  * EnvConditions: NA
1085  * CaseDescription: Verify the following:
1086  * 1.the user id is new user id
1087  * 2.token is nullptr, ScheduleCommandAbilityDone failed
1088  * 3.ability record is nullptr, ScheduleCommandAbilityDone failed
1089  */
1090 HWTEST_F(AbilityManagerServiceAccountTest, Account_ScheduleCommandAbilityDone_003, TestSize.Level1)
1091 {
1092     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleCommandAbilityDone_003 start";
1093     abilityMs_->StartUser(newUserId, nullptr);
1094     Want want;
1095     ElementName element("", "com.ix.musicService", "MusicService");
1096     want.SetElement(element);
1097     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
1098     auto result = abilityMs_->ConnectAbility(want, callback, nullptr, newUserId);
1099     WaitUntilTaskFinished();
1100     EXPECT_EQ(result, ERR_OK);
1101     auto serviceMap = abilityMs_->GetConnectManagerByUserId(newUserId)->GetServiceMap();
1102     auto service = serviceMap.at(element.GetURI());
1103     service->SetAbilityState(AAFwk::AbilityState::ACTIVE);
1104 
1105     const sptr<IRemoteObject> nulltToken = nullptr;
1106     auto result1 = abilityMs_->ScheduleCommandAbilityDone(nulltToken);
1107     WaitUntilTaskFinished();
1108     EXPECT_EQ(result1, ERR_INVALID_VALUE);
1109 
1110     std::shared_ptr<AbilityRecord> ability = nullptr;
1111     const sptr<IRemoteObject> token = new Token(ability);
1112     auto result2 = abilityMs_->ScheduleCommandAbilityDone(token);
1113     WaitUntilTaskFinished();
1114     EXPECT_EQ(result2, ERR_INVALID_VALUE);
1115 
1116     auto result3 = abilityMs_->ScheduleCommandAbilityDone(service->GetToken());
1117     WaitUntilTaskFinished();
1118     EXPECT_EQ(result3, ERR_OK);
1119     abilityMs_->StartUser(USER_ID_U100, nullptr);
1120     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleCommandAbilityDone_003 end";
1121 }
1122 
1123 /*
1124  * Feature: AbilityManagerService
1125  * Function: ScheduleCommandAbilityDone
1126  * SubFunction: NA
1127  * FunctionPoints: AbilityManagerService ScheduleCommandAbilityDone
1128  * EnvConditions: NA
1129  * CaseDescription: Verify the following:
1130  * 1.the user id is new user id
1131  * 2.ability type is not service, ScheduleCommandAbilityDone failed
1132  */
1133 HWTEST_F(AbilityManagerServiceAccountTest, Account_ScheduleCommandAbilityDone_004, TestSize.Level1)
1134 {
1135     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleCommandAbilityDone_004 start";
1136     abilityMs_->StartUser(newUserId, nullptr);
1137     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(newUserId));
1138     if (topAbility) {
1139         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
1140     }
1141     Want want;
1142     ElementName element("", "com.ix.hiAccount", "AccountTest");
1143     want.SetElement(element);
1144     auto result = abilityMs_->StartAbility(want, newUserId, -1);
1145     WaitUntilTaskFinished();
1146     EXPECT_EQ(OHOS::ERR_OK, result);
1147 
1148     topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(newUserId));
1149 
1150     sptr<IRemoteObject> token = nullptr;
1151     if (topAbility) {
1152         token = topAbility->GetToken();
1153     }
1154     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
1155     auto result1 = abilityMs_->ScheduleCommandAbilityDone(token);
1156     WaitUntilTaskFinished();
1157     EXPECT_EQ(result1, TARGET_ABILITY_NOT_SERVICE);
1158     abilityMs_->StartUser(USER_ID_U100, nullptr);
1159     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_ScheduleCommandAbilityDone_004 end";
1160 }
1161 
1162 /*
1163  * Feature: AbilityManagerService
1164  * Function: StopServiceAbility
1165  * SubFunction: NA
1166  * FunctionPoints: AbilityManagerService StopServiceAbility
1167  * EnvConditions: NA
1168  * CaseDescription: the user id is U100, verify StopServiceAbility results
1169  */
1170 HWTEST_F(AbilityManagerServiceAccountTest, Account_StopServiceAbility_001, TestSize.Level1)
1171 {
1172     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StopServiceAbility_001 start";
1173     Want want;
1174     ElementName element("", "com.ix.musicService", "MusicService");
1175     want.SetElement(element);
1176     auto result = abilityMs_->StartAbility(want, USER_ID_U100, -1);
1177     WaitUntilTaskFinished();
1178     EXPECT_EQ(OHOS::ERR_OK, result);
1179     auto serviceMap = abilityMs_->GetConnectManagerByUserId(USER_ID_U100)->GetServiceMap();
1180     EXPECT_EQ(1, static_cast<int>(serviceMap.size()));
1181     for (auto& it : serviceMap) {
1182         EXPECT_EQ(it.first, element.GetURI());
1183     }
1184     auto service = serviceMap.at(element.GetURI());
1185     service->SetAbilityState(AAFwk::AbilityState::ACTIVE);
1186 
1187     Want want1;
1188     ElementName element1("device", "com.ix.hiMusic", "MusicAbility");
1189     want1.SetElement(element1);
1190     auto result1 = abilityMs_->StopServiceAbility(want1, USER_ID_U100);
1191     WaitUntilTaskFinished();
1192     EXPECT_EQ(CHECK_PERMISSION_FAILED, result1);
1193 
1194     auto result2 = abilityMs_->StopServiceAbility(want, USER_ID_U100);
1195     WaitUntilTaskFinished();
1196     EXPECT_EQ(CHECK_PERMISSION_FAILED, result2);
1197     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StopServiceAbility_001 end";
1198 }
1199 
1200 /*
1201  * Feature: AbilityManagerService
1202  * Function: StopServiceAbility
1203  * SubFunction: NA
1204  * FunctionPoints: AbilityManagerService StopServiceAbility
1205  * EnvConditions: NA
1206  * CaseDescription: the user id is new user id, verify StopServiceAbility results
1207  */
1208 HWTEST_F(AbilityManagerServiceAccountTest, Account_StopServiceAbility_002, TestSize.Level1)
1209 {
1210     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StopServiceAbility_002 start";
1211     abilityMs_->StartUser(newUserId, nullptr);
1212     Want want;
1213     ElementName element("", "com.ix.musicService", "MusicService");
1214     want.SetElement(element);
1215     auto result = abilityMs_->StartAbility(want, newUserId, -1);
1216     WaitUntilTaskFinished();
1217     EXPECT_EQ(OHOS::ERR_OK, result);
1218     auto serviceMap = abilityMs_->GetConnectManagerByUserId(newUserId)->GetServiceMap();
1219     EXPECT_EQ(1, static_cast<int>(serviceMap.size()));
1220     for (auto& it : serviceMap) {
1221         EXPECT_EQ(it.first, element.GetURI());
1222     }
1223     auto service = serviceMap.at(element.GetURI());
1224     service->SetAbilityState(AAFwk::AbilityState::ACTIVE);
1225 
1226     Want want1;
1227     ElementName element1("device", "com.ix.hiMusic", "MusicAbility");
1228     want1.SetElement(element1);
1229     auto result1 = abilityMs_->StopServiceAbility(want1, newUserId);
1230     WaitUntilTaskFinished();
1231     EXPECT_EQ(CHECK_PERMISSION_FAILED, result1);
1232 
1233     auto result2 = abilityMs_->StopServiceAbility(want, newUserId);
1234     WaitUntilTaskFinished();
1235     EXPECT_EQ(CHECK_PERMISSION_FAILED, result2);
1236     abilityMs_->StartUser(USER_ID_U100, nullptr);
1237     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StopServiceAbility_002 end";
1238 }
1239 
1240 /*
1241  * Feature: AbilityManagerService
1242  * Function: StopServiceAbility
1243  * SubFunction: NA
1244  * FunctionPoints: AbilityManagerService StopServiceAbility
1245  * EnvConditions: NA
1246  * CaseDescription: Use single ServiceAbility with 0 user authentication StopServiceAbility interface
1247  * StopServiceAbility parameter
1248  */
1249 HWTEST_F(AbilityManagerServiceAccountTest, Account_StopServiceAbility_003, TestSize.Level1)
1250 {
1251     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StopServiceAbility_003 start";
1252     Want want;
1253     ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic");
1254     want.SetElement(element);
1255     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
1256     auto result = abilityMs_->ConnectAbility(want, callback, nullptr, 0);
1257     EXPECT_EQ(OHOS::ERR_OK, result);
1258     result = abilityMs_->StopServiceAbility(want, 0);
1259     EXPECT_EQ(OHOS::CHECK_PERMISSION_FAILED, result);
1260     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StopServiceAbility_003 end";
1261 }
1262 
1263 /*
1264  * Feature: AbilityManagerService
1265  * Function: StopServiceAbility
1266  * SubFunction: NA
1267  * FunctionPoints: AbilityManagerService StopServiceAbility
1268  * EnvConditions: NA
1269  * CaseDescription: Use single ServiceAbility with 100 user authentication StopServiceAbility interface
1270  * StopServiceAbility parameter
1271  */
1272 HWTEST_F(AbilityManagerServiceAccountTest, Account_StopServiceAbility_004, TestSize.Level1)
1273 {
1274     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StopServiceAbility_004 start";
1275     Want want;
1276     ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic");
1277     want.SetElement(element);
1278     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
1279     auto result = abilityMs_->ConnectAbility(want, callback, nullptr, USER_ID_U100);
1280     EXPECT_EQ(OHOS::ERR_OK, result);
1281     result = abilityMs_->StopServiceAbility(want, USER_ID_U100);
1282     EXPECT_EQ(OHOS::CHECK_PERMISSION_FAILED, result);
1283     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StopServiceAbility_004 end";
1284 }
1285 
1286 /*
1287  * Feature: AbilityManagerService
1288  * Function: StopServiceAbility
1289  * SubFunction: NA
1290  * FunctionPoints: AbilityManagerService StopServiceAbility
1291  * EnvConditions: NA
1292  * CaseDescription: Use single ServiceAbility with error user authentication StopServiceAbility interface
1293  * StopServiceAbility parameter
1294  */
1295 HWTEST_F(AbilityManagerServiceAccountTest, Account_StopServiceAbility_005, TestSize.Level1)
1296 {
1297     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StopServiceAbility_005 start";
1298     Want want;
1299     ElementName element("", "com.ix.hiBackgroundMusic", "hiBackgroundMusic");
1300     want.SetElement(element);
1301     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
1302     auto result = abilityMs_->ConnectAbility(want, callback, nullptr, ERROR_USER_ID_U256);
1303     EXPECT_NE(OHOS::ERR_OK, result);
1304     result = abilityMs_->StopServiceAbility(want, ERROR_USER_ID_U256);
1305     EXPECT_NE(OHOS::CHECK_PERMISSION_FAILED, result);
1306     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_StopServiceAbility_005 end";
1307 }
1308 
1309 /*
1310  * Function: MinimizeAbility
1311  * SubFunction: NA
1312  * FunctionPoints: AbilityManagerService MinimizeAbility
1313  * EnvConditions: NA
1314  * CaseDescription: Verify function MinimizeAbility
1315  */
1316 HWTEST_F(AbilityManagerServiceAccountTest, Account_MinimizeAbility_001, TestSize.Level1)
1317 {
1318     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_MinimizeAbility_001 start";
1319     // default user
1320     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
1321     if (topAbility) {
1322         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
1323     }
1324     Want want;
1325     ElementName element("", "com.ix.hiAccount", "AccountTest");
1326     want.SetElement(element);
1327     auto result = abilityMs_->StartAbility(want, USER_ID_U100, -1);
1328     WaitUntilTaskFinished();
1329     EXPECT_EQ(ERR_OK, result);
1330 
1331     topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
1332 
1333     sptr<IRemoteObject> token = nullptr;
1334     if (topAbility) {
1335         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
1336         token = topAbility->GetToken();
1337     }
1338     auto resultFunction = abilityMs_->MinimizeAbility(token, true);
1339     EXPECT_EQ(resultFunction, ERR_OK);
1340     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_MinimizeAbility_001 end";
1341 }
1342 
1343 /*
1344  * Function: AttachAbilityThread
1345  * SubFunction: NA
1346  * FunctionPoints: AbilityManagerService AttachAbilityThread
1347  * EnvConditions: NA
1348  * CaseDescription: Verify function AttachAbilityThread
1349  */
1350 HWTEST_F(AbilityManagerServiceAccountTest, Account_AttachAbilityThread_001, TestSize.Level1)
1351 {
1352     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_AttachAbilityThread_001 start";
1353     // default user
1354     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
1355     if (topAbility) {
1356         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
1357     }
1358     Want want;
1359     ElementName element("", "com.ix.hiAccount", "AccountTest");
1360     want.SetElement(element);
1361     auto result = abilityMs_->StartAbility(want, USER_ID_U100, -1);
1362     WaitUntilTaskFinished();
1363     EXPECT_EQ(OHOS::ERR_OK, result);
1364     OHOS::sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
1365     topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
1366     sptr<IRemoteObject> token = nullptr;
1367     if (topAbility) {
1368         token = topAbility->GetToken();
1369     }
1370     auto resultFunction = abilityMs_->AttachAbilityThread(scheduler, token);
1371     EXPECT_EQ(resultFunction, ERR_OK);
1372     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_AttachAbilityThread_001 end";
1373 }
1374 
1375 /*
1376  * Function: OnAbilityRequestDone
1377  * SubFunction: NA
1378  * FunctionPoints: AbilityManagerService OnAbilityRequestDone
1379  * EnvConditions: NA
1380  * CaseDescription: Verify function OnAbilityRequestDone
1381  */
1382 HWTEST_F(AbilityManagerServiceAccountTest, Account_OnAbilityRequestDone_001, TestSize.Level1)
1383 {
1384     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_OnAbilityRequestDone_001 start";
1385     // default user
1386     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
1387     if (topAbility) {
1388         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
1389     }
1390     Want want;
1391     ElementName element("", "com.ix.hiAccount", "AccountTest");
1392     want.SetElement(element);
1393     auto result = abilityMs_->StartAbility(want, USER_ID_U100, -1);
1394     WaitUntilTaskFinished();
1395     EXPECT_EQ(ERR_OK, result);
1396     topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
1397     sptr<IRemoteObject> token = nullptr;
1398     if (topAbility) {
1399         token = topAbility->GetToken();
1400     }
1401     abilityMs_->OnAbilityRequestDone(token, 2);
1402     EXPECT_EQ(topAbility->GetAbilityState(), OHOS::AAFwk::AbilityState::FOREGROUNDING);
1403     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_OnAbilityRequestDone_001 end";
1404 }
1405 
1406 /*
1407  * Function: KillProcess
1408  * SubFunction: NA
1409  * FunctionPoints: AbilityManagerService KillProcess
1410  * EnvConditions: NA
1411  * CaseDescription: Verify function KillProcess
1412  */
1413 HWTEST_F(AbilityManagerServiceAccountTest, Account_KillProcess_001, TestSize.Level1)
1414 {
1415     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_KillProcess_001 start";
1416     // default user
1417     auto topAbility = GetMissionListTopAbility(abilityMs_->GetMissionListManagerByUserId(USER_ID_U100));
1418     if (topAbility) {
1419         topAbility->SetAbilityState(AAFwk::AbilityState::FOREGROUND);
1420     }
1421     Want want;
1422     ElementName element("", "com.ix.hiAccount", "AccountTest");
1423     want.SetElement(element);
1424     auto result = abilityMs_->StartAbility(want, USER_ID_U100, -1);
1425     WaitUntilTaskFinished();
1426     EXPECT_EQ(ERR_OK, result);
1427     auto resultFunction = abilityMs_->KillProcess("bundle");
1428     EXPECT_EQ(ERR_OK, resultFunction);
1429     GTEST_LOG_(INFO) << "AbilityManagerServiceAccountTest Account_KillProcess_001 end";
1430 }
1431 }  // namespace AAFwk
1432 }  // namespace OHOS
1433