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