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