1 /*
2 * Copyright (c) 2023-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #define private public
19 #define protected public
20 #include "ability_manager_service.h"
21 #include "ability_connect_manager.h"
22 #include "ability_connection.h"
23 #include "ability_start_setting.h"
24 #include "recovery_param.h"
25 #undef private
26 #undef protected
27
28 #include "ability_manager_errors.h"
29 #include "app_utils.h"
30 #include "connection_observer_errors.h"
31 #include "hilog_tag_wrapper.h"
32 #include "session/host/include/session.h"
33 #include "scene_board_judgement.h"
34 #include "mock_sa_call.h"
35 #include "unlock_screen_manager.h"
36
37 using namespace testing;
38 using namespace testing::ext;
39 using namespace OHOS::AppExecFwk;
40 using OHOS::AppExecFwk::AbilityType;
41 using OHOS::AppExecFwk::ExtensionAbilityType;
42 namespace OHOS {
43 namespace AAFwk {
44 namespace {
45 const int32_t USER_ID_U100 = 100;
46 const int32_t APP_MEMORY_SIZE = 512;
47 } // namespace
48 class AbilityManagerServiceSecondTest : public testing::Test {
49 public:
50 static void SetUpTestCase();
51 static void TearDownTestCase();
52 void SetUp();
53 void TearDown();
54
55 AbilityRequest GenerateAbilityRequest(const std::string& deviceName, const std::string& abilityName,
56 const std::string& appName, const std::string& bundleName, const std::string& moduleName);
57
58 public:
59 AbilityRequest abilityRequest_{};
60 Want want_{};
61 };
62
63 class MockIRemoteMissionListener : public IRemoteMissionListener {
64 public:
~MockIRemoteMissionListener()65 virtual ~MockIRemoteMissionListener() {}
NotifyMissionsChanged(const std::string & deviceId)66 void NotifyMissionsChanged(const std::string& deviceId) override
67 {}
68
NotifySnapshot(const std::string & deviceId,int32_t missionId)69 void NotifySnapshot(const std::string& deviceId, int32_t missionId) override
70 {}
71
NotifyNetDisconnect(const std::string & deviceId,int32_t state)72 void NotifyNetDisconnect(const std::string& deviceId, int32_t state) override
73 {}
74
AsObject()75 sptr<IRemoteObject> AsObject() override
76 {
77 return nullptr;
78 }
79 };
80
GenerateAbilityRequest(const std::string & deviceName,const std::string & abilityName,const std::string & appName,const std::string & bundleName,const std::string & moduleName)81 AbilityRequest AbilityManagerServiceSecondTest::GenerateAbilityRequest(const std::string& deviceName,
82 const std::string& abilityName, const std::string& appName, const std::string& bundleName,
83 const std::string& moduleName)
84 {
85 ElementName element(deviceName, bundleName, abilityName, moduleName);
86 want_.SetElement(element);
87
88 AbilityInfo abilityInfo;
89 abilityInfo.visible = true;
90 abilityInfo.applicationName = appName;
91 abilityInfo.type = AbilityType::EXTENSION;
92 abilityInfo.name = abilityName;
93 abilityInfo.bundleName = bundleName;
94 abilityInfo.moduleName = moduleName;
95 abilityInfo.deviceId = deviceName;
96 ApplicationInfo appinfo;
97 appinfo.name = appName;
98 appinfo.bundleName = bundleName;
99 abilityInfo.applicationInfo = appinfo;
100 AbilityRequest abilityRequest;
101 abilityRequest.want = want_;
102 abilityRequest.abilityInfo = abilityInfo;
103 abilityRequest.appInfo = appinfo;
104
105 return abilityRequest;
106 }
107
SetUpTestCase()108 void AbilityManagerServiceSecondTest::SetUpTestCase() {}
109
TearDownTestCase()110 void AbilityManagerServiceSecondTest::TearDownTestCase() {}
111
SetUp()112 void AbilityManagerServiceSecondTest::SetUp() {}
113
TearDown()114 void AbilityManagerServiceSecondTest::TearDown() {}
115
116 /*
117 * Feature: AbilityManagerService
118 * Function: StartSwitchUserDialog
119 * SubFunction: NA
120 * FunctionPoints: AbilityManagerService StartSwitchUserDialog
121 */
122 HWTEST_F(AbilityManagerServiceSecondTest, StartSwitchUserDialog_001, TestSize.Level1)
123 {
124 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartSwitchUserDialog_001 start");
125 auto abilityMs_ = std::make_shared<AbilityManagerService>();
126 EXPECT_NE(abilityMs_, nullptr);
127 abilityMs_->StartSwitchUserDialog();
128
129 abilityMs_->userController_ = nullptr;
130 abilityMs_->StartSwitchUserDialog();
131 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartSwitchUserDialog_001 end");
132 }
133
134 /*
135 * Feature: AbilityManagerService
136 * Function: StartSwitchUserDialogInner
137 * SubFunction: NA
138 * FunctionPoints: AbilityManagerService StartSwitchUserDialogInner
139 */
140 HWTEST_F(AbilityManagerServiceSecondTest, StartSwitchUserDialogInner_001, TestSize.Level1)
141 {
142 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartSwitchUserDialogInner_001 start");
143 auto abilityMs_ = std::make_shared<AbilityManagerService>();
144 Want want;
145 ASSERT_NE(abilityMs_, nullptr);
146 abilityMs_->StartSwitchUserDialogInner(want, 100);
147 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartSwitchUserDialogInner_001 end");
148 }
149
150 /*
151 * Feature: AbilityManagerService
152 * Function: StopSwitchUserDialog
153 * SubFunction: NA
154 * FunctionPoints: AbilityManagerService StopSwitchUserDialog
155 */
156 HWTEST_F(AbilityManagerServiceSecondTest, StopSwitchUserDialog_001, TestSize.Level1)
157 {
158 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StopSwitchUserDialog_001 start");
159 auto abilityMs_ = std::make_shared<AbilityManagerService>();
160 EXPECT_NE(abilityMs_, nullptr);
161 abilityMs_->StopSwitchUserDialog();
162
163 abilityMs_->userController_ = nullptr;
164 abilityMs_->StopSwitchUserDialog();
165 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StopSwitchUserDialog_001 end");
166 }
167
168 /*
169 * Feature: AbilityManagerService
170 * Function: StopSwitchUserDialogInner
171 * SubFunction: NA
172 * FunctionPoints: AbilityManagerService StopSwitchUserDialogInner
173 */
174 HWTEST_F(AbilityManagerServiceSecondTest, StopSwitchUserDialogInner_001, TestSize.Level1)
175 {
176 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StopSwitchUserDialogInner_001 start");
177 auto abilityMs_ = std::make_shared<AbilityManagerService>();
178 Want want;
179 ASSERT_NE(abilityMs_, nullptr);
180 abilityMs_->StopSwitchUserDialogInner(want, 100);
181 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StopSwitchUserDialogInner_001 end");
182 }
183
184 /*
185 * Feature: AbilityManagerService
186 * Function: CheckOptExtensionAbility
187 * SubFunction: NA
188 * FunctionPoints: AbilityManagerService CheckOptExtensionAbility
189 */
190 HWTEST_F(AbilityManagerServiceSecondTest, CheckOptExtensionAbility_002, TestSize.Level1)
191 {
192 auto abilityMs_ = std::make_shared<AbilityManagerService>();
193 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckOptExtensionAbility_002 start");
194 abilityRequest_.abilityInfo.type = AbilityType::EXTENSION;
195 abilityRequest_.abilityInfo.extensionAbilityType = ExtensionAbilityType::SERVICE;
196 ExtensionAbilityType extensionType = ExtensionAbilityType::DATASHARE;
197 auto ret = abilityMs_->CheckOptExtensionAbility(want_, abilityRequest_, 100, extensionType);
198 EXPECT_EQ(ret, ERR_WRONG_INTERFACE_CALL);
199
200 extensionType = ExtensionAbilityType::SERVICE;
201 abilityMs_->CheckOptExtensionAbility(want_, abilityRequest_, 100, extensionType);
202
203 abilityRequest_.abilityInfo.extensionAbilityType = ExtensionAbilityType::FORM;
204 extensionType = ExtensionAbilityType::FORM;
205 abilityMs_->CheckOptExtensionAbility(want_, abilityRequest_, 100, extensionType);
206 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckOptExtensionAbility_002 end");
207 }
208
209 /*
210 * Feature: AbilityManagerService
211 * Function: CheckOptExtensionAbility
212 * SubFunction: NA
213 * FunctionPoints: AbilityManagerService CheckOptExtensionAbility
214 */
215 HWTEST_F(AbilityManagerServiceSecondTest, CheckOptExtensionAbility_003, TestSize.Level1)
216 {
217 auto abilityMs_ = std::make_shared<AbilityManagerService>();
218 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckOptExtensionAbility_003 start");
219 abilityRequest_.abilityInfo.type = AbilityType::PAGE;
220 auto result = abilityMs_->CheckOptExtensionAbility(want_, abilityRequest_, USER_ID_U100,
221 ExtensionAbilityType::FORM);
222 EXPECT_EQ(ERR_WRONG_INTERFACE_CALL, result);
223 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckOptExtensionAbility_003 end");
224 }
225
226 /*
227 * Feature: AbilityManagerService
228 * Function: CheckOptExtensionAbility
229 * SubFunction: NA
230 * FunctionPoints: AbilityManagerService CheckOptExtensionAbility
231 */
232 HWTEST_F(AbilityManagerServiceSecondTest, CheckOptExtensionAbility_004, TestSize.Level1)
233 {
234 auto abilityMs_ = std::make_shared<AbilityManagerService>();
235 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckOptExtensionAbility_004 start");
236 abilityRequest_.abilityInfo.extensionAbilityType = ExtensionAbilityType::DATASHARE;
237 auto result = abilityMs_->CheckOptExtensionAbility(want_, abilityRequest_, USER_ID_U100,
238 ExtensionAbilityType::FORM);
239 EXPECT_EQ(ERR_WRONG_INTERFACE_CALL, result);
240 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckOptExtensionAbility_004 end");
241 }
242
243 /*
244 * Feature: AbilityManagerService
245 * Function: StartAbilityByCall
246 * SubFunction: NA
247 * FunctionPoints: AbilityManagerService StartAbilityByCall
248 */
249 HWTEST_F(AbilityManagerServiceSecondTest, StartAbilityByCall_001, TestSize.Level1)
250 {
251 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartAbilityByCall_001 start");
252 auto abilityMs_ = std::make_shared<AbilityManagerService>();
253 Want want;
254 EXPECT_EQ(abilityMs_->StartAbilityByCall(want, nullptr, nullptr), ERR_INVALID_VALUE);
255 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartAbilityByCall_001 end");
256 }
257
258 /*
259 * Feature: AbilityManagerService
260 * Function: CheckCallDataAbilityPermission
261 * SubFunction: NA
262 * FunctionPoints: AbilityManagerService CheckCallDataAbilityPermission
263 */
264 HWTEST_F(AbilityManagerServiceSecondTest, CheckCallDataAbilityPermission_001, TestSize.Level1)
265 {
266 auto abilityMs_ = std::make_shared<AbilityManagerService>();
267 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckCallDataAbilityPermission_001 start");
268 AbilityRequest abilityRequest;
269 EXPECT_EQ(abilityMs_->CheckCallDataAbilityPermission(abilityRequest, false), ERR_INVALID_VALUE);
270 abilityRequest.abilityInfo.applicationInfo.name = "test";
271 EXPECT_EQ(abilityMs_->CheckCallDataAbilityPermission(abilityRequest, false), ERR_INVALID_VALUE);
272
273 abilityRequest.abilityInfo.applicationInfo.name = "test";
274 abilityRequest.abilityInfo.applicationInfo.bundleName = "test";
275 abilityRequest.abilityInfo.type = AbilityType::SERVICE;
276 EXPECT_EQ(abilityMs_->CheckCallDataAbilityPermission(abilityRequest, false), ERR_WRONG_INTERFACE_CALL);
277
278 abilityRequest_.abilityInfo.type = AbilityType::DATA;
279 abilityMs_->startUpNewRule_ = false;
280 EXPECT_EQ(abilityMs_->CheckCallDataAbilityPermission(abilityRequest, false), ERR_WRONG_INTERFACE_CALL);
281 abilityMs_->startUpNewRule_ = true;
282
283 abilityRequest_.abilityInfo.type = AbilityType::DATA;
284 EXPECT_EQ(abilityMs_->CheckCallDataAbilityPermission(abilityRequest_, false), ERR_INVALID_VALUE);
285 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckCallDataAbilityPermission_001 end");
286 }
287
288 /*
289 * Feature: AbilityManagerService
290 * Function: CheckCallDataAbilityPermission
291 * SubFunction: NA
292 * FunctionPoints: AbilityManagerService CheckCallDataAbilityPermission
293 */
294 HWTEST_F(AbilityManagerServiceSecondTest, CheckCallDataAbilityPermission_002, TestSize.Level1)
295 {
296 auto abilityMs_ = std::make_shared<AbilityManagerService>();
297 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckCallDataAbilityPermission_002 start");
298 abilityRequest_.abilityInfo.type = AbilityType::DATA;
299 EXPECT_EQ(abilityMs_->CheckCallDataAbilityPermission(abilityRequest_, false), ERR_INVALID_VALUE);
300 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckCallDataAbilityPermission_002 end");
301 }
302
303 /*
304 * Feature: AbilityManagerService
305 * Function: CheckCallOtherExtensionPermission
306 * SubFunction: NA
307 * FunctionPoints: AbilityManagerService CheckCallOtherExtensionPermission
308 */
309 HWTEST_F(AbilityManagerServiceSecondTest, CheckCallOtherExtensionPermission_001, TestSize.Level1)
310 {
311 auto abilityMs_ = std::make_shared<AbilityManagerService>();
312 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckCallOtherExtensionPermission_001 start");
313 bool oldFlag = abilityMs_->startUpNewRule_;
314 abilityMs_->startUpNewRule_ = true;
315 AbilityRequest abilityRequest;
316 EXPECT_EQ(abilityMs_->CheckCallOtherExtensionPermission(abilityRequest), ERR_OK);
317 abilityMs_->startUpNewRule_ = oldFlag;
318 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckCallOtherExtensionPermission_001 end");
319 }
320
321 /*
322 * Feature: AbilityManagerService
323 * Function: CheckCallOtherExtensionPermission
324 * SubFunction: NA
325 * FunctionPoints: AbilityManagerService CheckCallOtherExtensionPermission
326 */
327 HWTEST_F(AbilityManagerServiceSecondTest, CheckCallOtherExtensionPermission_002, TestSize.Level1)
328 {
329 auto abilityMs_ = std::make_shared<AbilityManagerService>();
330 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckCallOtherExtensionPermission_002 start");
331 AbilityRequest abilityRequest;
332 abilityRequest.abilityInfo.visible = false;
333 bool oldFlag = abilityMs_->startUpNewRule_;
334 abilityMs_->startUpNewRule_ = true;
335 EXPECT_EQ(abilityMs_->CheckCallOtherExtensionPermission(abilityRequest), ERR_OK);
336 abilityMs_->startUpNewRule_ = oldFlag;
337 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckCallOtherExtensionPermission_002 end");
338 }
339
340 /**
341 * @tc.name: CheckCallOtherExtensionPermission_003
342 * @tc.desc: Check can't start non-system app when extension type is some specified uiextension.
343 * @tc.type: FUNC
344 */
345 HWTEST_F(AbilityManagerServiceSecondTest, CheckCallOtherExtensionPermission_003, TestSize.Level1)
346 {
347 auto abilityMs_ = std::make_shared<AbilityManagerService>();
348 TAG_LOGI(AAFwkTag::TEST, "testcase begin.");
349 AbilityRequest abilityRequest;
350 abilityRequest.abilityInfo.visible = true;
351 abilityRequest.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
352 abilityRequest.appInfo.isSystemApp = false;
353 abilityRequest.appInfo.bundleName = "test.bundleName";
354 EXPECT_EQ(abilityMs_->CheckCallOtherExtensionPermission(abilityRequest), ERR_OK);
355 TAG_LOGI(AAFwkTag::TEST, "testcase end.");
356 }
357
358 /**
359 * @tc.name: CheckCallOtherExtensionPermission_004
360 * @tc.desc: Check can't start non-system app when extension type is some specified uiextension.
361 * @tc.type: FUNC
362 */
363 HWTEST_F(AbilityManagerServiceSecondTest, CheckCallOtherExtensionPermission_004, TestSize.Level1)
364 {
365 auto abilityMs_ = std::make_shared<AbilityManagerService>();
366 TAG_LOGI(AAFwkTag::TEST, "testcase begin.");
367 AbilityRequest abilityRequest;
368 abilityRequest.abilityInfo.visible = true;
369 abilityRequest.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
370 abilityRequest.appInfo.isSystemApp = true;
371 abilityRequest.appInfo.bundleName = "test.bundleName";
372 EXPECT_EQ(abilityMs_->CheckCallOtherExtensionPermission(abilityRequest), ERR_OK);
373 TAG_LOGI(AAFwkTag::TEST, "testcase end.");
374 }
375
376 /*
377 * Feature: AbilityManagerService
378 * Function: CheckStartByCallPermission
379 * SubFunction: NA
380 * FunctionPoints: AbilityManagerService CheckStartByCallPermission
381 */
382 HWTEST_F(AbilityManagerServiceSecondTest, CheckStartByCallPermission_001, TestSize.Level1)
383 {
384 auto abilityMs_ = std::make_shared<AbilityManagerService>();
385 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckStartByCallPermission_001 start");
386 EXPECT_EQ(abilityMs_->CheckStartByCallPermission(abilityRequest_), RESOLVE_CALL_ABILITY_TYPE_ERR);
387 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckStartByCallPermission_001 end");
388 }
389
390 /*
391 * Feature: AbilityManagerService
392 * Function: StartAbility
393 * SubFunction: NA
394 * FunctionPoints: AbilityManagerService StartAbility
395 */
396 HWTEST_F(AbilityManagerServiceSecondTest, StartAbility_001, TestSize.Level1)
397 {
398 auto abilityMs_ = std::make_shared<AbilityManagerService>();
399 abilityMs_->Init();
400 Want want;
401 EXPECT_NE(abilityMs_->StartAbility(want, nullptr, 100, 0), ERR_OK);
402
403 want.SetFlags(Want::FLAG_ABILITY_CONTINUATION);
404 EXPECT_EQ(abilityMs_->StartAbility(want, nullptr, 100, 0), ERR_INVALID_CONTINUATION_FLAG);
405 }
406
407 /*
408 * Feature: AbilityManagerService
409 * Function: StartAbility
410 * SubFunction: NA
411 * FunctionPoints: AbilityManagerService StartAbility
412 */
413 HWTEST_F(AbilityManagerServiceSecondTest, StartAbility_002, TestSize.Level1)
414 {
415 auto abilityMs_ = std::make_shared<AbilityManagerService>();
416 abilityMs_->Init();
417 Want want;
418 AbilityStartSetting abilityStartSetting;
419 sptr<IRemoteObject> callerToken = nullptr;
420 int requestCode = 0;
421 auto ret = abilityMs_->StartAbility(want, abilityStartSetting, callerToken, 0, requestCode);
422 EXPECT_NE(ret, ERR_OK);
423 }
424
425 /*
426 * Feature: AbilityManagerService
427 * Function: StartAbilityDetails
428 * SubFunction: NA
429 * FunctionPoints: AbilityManagerService StartAbilityDetails
430 */
431 HWTEST_F(AbilityManagerServiceSecondTest, StartAbility_003, TestSize.Level1)
432 {
433 auto abilityMs_ = std::make_shared<AbilityManagerService>();
434 abilityMs_->Init();
435 Want want;
436 AbilityStartSetting abilityStartSetting;
437 sptr<IRemoteObject> callerToken = nullptr;
438 int requestCode = 0;
439 auto ret = abilityMs_->StartAbilityDetails(want, abilityStartSetting, callerToken, 0, requestCode);
440 EXPECT_NE(ret, ERR_OK);
441 }
442
443 /*
444 * Feature: AbilityManagerService
445 * Function: StartAbility
446 * SubFunction: NA
447 * FunctionPoints: AbilityManagerService StartAbilityWithSpecifyTokenIdInner
448 */
449 HWTEST_F(AbilityManagerServiceSecondTest, StartAbility_004, TestSize.Level1)
450 {
451 auto abilityMs_ = std::make_shared<AbilityManagerService>();
452 abilityMs_->Init();
453 Want want;
454 ElementName element("", "com.ix.hiMusic", "MusicAbility");
455 want.SetElement(element);
456 StartOptions startOptions;
457 sptr<IRemoteObject> callerToken = nullptr;
458 int requestCode = 0;
459 EXPECT_NE(abilityMs_->StartAbilityWithSpecifyTokenIdInner(want, startOptions, callerToken,
460 USER_ID_U100, requestCode), ERR_OK);
461 }
462
463 /*
464 * Feature: AbilityManagerService
465 * Function: StartAbilityAsCaller
466 * SubFunction: NA
467 * FunctionPoints: AbilityManagerService StartAbilityAsCaller
468 */
469 HWTEST_F(AbilityManagerServiceSecondTest, StartAbilityAsCaller_001, TestSize.Level1)
470 {
471 auto abilityMs_ = std::make_shared<AbilityManagerService>();
472 abilityMs_->Init();
473 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartAbilityAsCaller_001 start");
474 Want want;
475 int requestCode = 0;
476 sptr<IRemoteObject> callerToken = nullptr;
477 EXPECT_NE(abilityMs_->StartAbility(want, callerToken, USER_ID_U100, requestCode), ERR_OK);
478
479 want.SetFlags(Want::FLAG_ABILITY_CONTINUATION);
480 EXPECT_EQ(abilityMs_->StartAbilityAsCaller(want, callerToken, nullptr, USER_ID_U100, requestCode),
481 ERR_INVALID_CONTINUATION_FLAG);
482 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartAbilityAsCaller_001 end");
483 }
484
485 /*
486 * Feature: AbilityManagerService
487 * Function: StartAbilityAsCaller
488 * SubFunction: NA
489 * FunctionPoints: AbilityManagerService StartAbilityAsCaller
490 */
491 HWTEST_F(AbilityManagerServiceSecondTest, StartAbilityAsCaller_002, TestSize.Level1)
492 {
493 auto abilityMs_ = std::make_shared<AbilityManagerService>();
494 abilityMs_->Init();
495 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartAbilityAsCaller_002 start");
496 Want want;
497 StartOptions startOptions;
498 sptr<IRemoteObject> callerToken = nullptr;
499 int requestCode = 0;
500 EXPECT_NE(abilityMs_->StartAbilityAsCaller(want, startOptions, callerToken, nullptr, USER_ID_U100, requestCode),
501 ERR_OK);
502 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartAbilityAsCaller_002 end");
503 }
504
505 /*
506 * Feature: AbilityManagerService
507 * Function: StartAbilityForResultAsCaller
508 * SubFunction: NA
509 * FunctionPoints: AbilityManagerService StartAbilityForResultAsCaller
510 */
511 HWTEST_F(AbilityManagerServiceSecondTest, StartAbilityForResultAsCaller_001, TestSize.Level1)
512 {
513 auto abilityMs_ = std::make_shared<AbilityManagerService>();
514 abilityMs_->Init();
515 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartAbilityForResultAsCaller_001 start");
516 Want want;
517 StartOptions startOptions;
518 sptr<IRemoteObject> callerToken = nullptr;
519 int requestCode = 0;
520 EXPECT_EQ(abilityMs_->StartAbilityForResultAsCaller(want, callerToken, requestCode, USER_ID_U100), ERR_NO_INIT);
521 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartAbilityForResultAsCaller_001 end");
522 }
523
524 /*
525 * Feature: AbilityManagerService
526 * Function: StartAbilityForResultAsCaller
527 * SubFunction: NA
528 * FunctionPoints: AbilityManagerService StartAbilityForResultAsCaller
529 */
530 HWTEST_F(AbilityManagerServiceSecondTest, StartAbilityForResultAsCaller_002, TestSize.Level1)
531 {
532 auto abilityMs_ = std::make_shared<AbilityManagerService>();
533 abilityMs_->Init();
534 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartAbilityForResultAsCaller_002 start");
535 Want want;
536 StartOptions startOptions;
537 sptr<IRemoteObject> callerToken = nullptr;
538 int requestCode = 0;
539 EXPECT_EQ(abilityMs_->StartAbilityForResultAsCaller(want, startOptions, callerToken, requestCode, USER_ID_U100),
540 ERR_NO_INIT);
541 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartAbilityForResultAsCaller_002 end");
542 }
543
544 /*
545 * Feature: AbilityManagerService
546 * Function: IsBackgroundTaskUid
547 * SubFunction: NA
548 * FunctionPoints: AbilityManagerService IsBackgroundTaskUid
549 */
550 HWTEST_F(AbilityManagerServiceSecondTest, IsBackgroundTaskUid_001, TestSize.Level1)
551 {
552 auto abilityMs_ = std::make_shared<AbilityManagerService>();
553 int uid = USER_ID_U100;
554 EXPECT_FALSE(abilityMs_->IsBackgroundTaskUid(uid));
555 }
556
557 /*
558 * Feature: AbilityManagerService
559 * Function: TerminateAbility
560 * SubFunction: NA
561 * FunctionPoints: AbilityManagerService TerminateAbility
562 */
563 HWTEST_F(AbilityManagerServiceSecondTest, TerminateAbility_001, TestSize.Level1)
564 {
565 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest TerminateAbility_001 start");
566 auto abilityMs_ = std::make_shared<AbilityManagerService>();
567 Want* resultWant = nullptr;
568 EXPECT_EQ(abilityMs_->TerminateAbility(nullptr, 1, resultWant), ERR_INVALID_VALUE);
569 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest TerminateAbility_001 end");
570 }
571
572 /*
573 * Feature: AbilityManagerService
574 * Function: CloseAbility
575 * SubFunction: NA
576 * FunctionPoints: AbilityManagerService CloseAbility
577 */
578 HWTEST_F(AbilityManagerServiceSecondTest, CloseAbility_001, TestSize.Level1)
579 {
580 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CloseAbility_001 start");
581 auto abilityMs_ = std::make_shared<AbilityManagerService>();
582 Want* resultWant = nullptr;
583 EXPECT_EQ(abilityMs_->CloseAbility(nullptr, 1, resultWant), ERR_INVALID_VALUE);
584 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CloseAbility_001 end");
585 }
586
587 /*
588 * Feature: AbilityManagerService
589 * Function: SendResultToAbility
590 * SubFunction: NA
591 * FunctionPoints: AbilityManagerService SendResultToAbility
592 */
593 HWTEST_F(AbilityManagerServiceSecondTest, SendResultToAbility_001, TestSize.Level1)
594 {
595 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest SendResultToAbility_001 start");
596 auto abilityMs_ = std::make_shared<AbilityManagerService>();
597 int32_t requestCode = 1;
598 int32_t resultCode = 1;
599 Want resultWant;
600 EXPECT_EQ(abilityMs_->SendResultToAbility(requestCode, resultCode, resultWant), ERR_INVALID_VALUE);
601 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest SendResultToAbility_001 end");
602 }
603
604 /*
605 * Feature: AbilityManagerService
606 * Function: CheckIsRemote
607 * SubFunction: NA
608 * FunctionPoints: AbilityManagerService CheckIsRemote
609 */
610 HWTEST_F(AbilityManagerServiceSecondTest, CheckIsRemote_001, TestSize.Level1)
611 {
612 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckIsRemote_001 start");
613 auto abilityMs_ = std::make_shared<AbilityManagerService>();
614 EXPECT_FALSE(abilityMs_->CheckIsRemote(""));
615 std::string deviceId = "test";
616 EXPECT_FALSE(abilityMs_->CheckIsRemote(deviceId));
617 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckIsRemote_001 end");
618 }
619
620 /*
621 * Feature: AbilityManagerService
622 * Function: CheckIfOperateRemote
623 * SubFunction: NA
624 * FunctionPoints: AbilityManagerService CheckIfOperateRemote
625 */
626 HWTEST_F(AbilityManagerServiceSecondTest, CheckIfOperateRemote_001, TestSize.Level1)
627 {
628 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckIfOperateRemote_001 start");
629 auto abilityMs_ = std::make_shared<AbilityManagerService>();
630 Want want;
631 EXPECT_FALSE(abilityMs_->CheckIfOperateRemote(want));
632 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckIfOperateRemote_001 end");
633 }
634
635 /*
636 * Feature: AbilityManagerService
637 * Function: CloseUIAbilityBySCB
638 * SubFunction: NA
639 * FunctionPoints: AbilityManagerService CloseUIAbilityBySCB
640 */
641 HWTEST_F(AbilityManagerServiceSecondTest, CloseUIAbilityBySCB_001, TestSize.Level1)
642 {
643 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CloseUIAbilityBySCB_001 start");
644 auto abilityMs_ = std::make_shared<AbilityManagerService>();
645 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
646 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
647 EXPECT_EQ(abilityMs_->CloseUIAbilityBySCB(nullptr, false), ERR_INVALID_VALUE);
648
649 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
650 EXPECT_EQ(abilityMs_->CloseUIAbilityBySCB(sessionInfo, false), ERR_INVALID_VALUE);
651 }
652
653 /*
654 * Feature: AbilityManagerService
655 * Function: ConnectAbility
656 * SubFunction: NA
657 * FunctionPoints: AbilityManagerService ConnectAbility
658 */
659 HWTEST_F(AbilityManagerServiceSecondTest, ConnectAbility_001, TestSize.Level1)
660 {
661 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ConnectAbility_001 start");
662 auto abilityMs_ = std::make_shared<AbilityManagerService>();
663 Want want;
664 EXPECT_EQ(abilityMs_->ConnectAbility(want, nullptr, nullptr, 100), ERR_INVALID_VALUE);
665 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ConnectAbility_001 end");
666 }
667
668 /*
669 * Feature: AbilityManagerService
670 * Function: ConnectAbilityCommon
671 * SubFunction: NA
672 * FunctionPoints: AbilityManagerService ConnectAbilityCommon
673 */
674 HWTEST_F(AbilityManagerServiceSecondTest, ConnectAbilityCommon_001, TestSize.Level1)
675 {
676 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ConnectAbilityCommon_001 start");
677 auto abilityMs_ = std::make_shared<AbilityManagerService>();
678 Want want;
679 ExtensionAbilityType extensionType = ExtensionAbilityType::SERVICE;
680 EXPECT_EQ(abilityMs_->ConnectAbilityCommon(want, nullptr, nullptr, extensionType, 100), ERR_INVALID_VALUE);
681 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ConnectAbilityCommon_001 end");
682 }
683
684 /*
685 * Feature: AbilityManagerService
686 * Function: DisconnectAbility
687 * SubFunction: NA
688 * FunctionPoints: AbilityManagerService DisconnectAbility
689 */
690 HWTEST_F(AbilityManagerServiceSecondTest, DisconnectAbility_001, TestSize.Level1)
691 {
692 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DisconnectAbility_001 start");
693 auto abilityMs_ = std::make_shared<AbilityManagerService>();
694 EXPECT_EQ(abilityMs_->DisconnectAbility(nullptr), ERR_INVALID_VALUE);
695 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DisconnectAbility_001 end");
696 }
697
698 /*
699 * Feature: AbilityManagerService
700 * Function: ConnectLocalAbility
701 * SubFunction: NA
702 * FunctionPoints: AbilityManagerService ConnectLocalAbility
703 */
704 HWTEST_F(AbilityManagerServiceSecondTest, ConnectLocalAbility_001, TestSize.Level1)
705 {
706 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ConnectLocalAbility_001 start");
707 auto abilityMs_ = std::make_shared<AbilityManagerService>();
708 Want want;
709 ExtensionAbilityType extensionType = ExtensionAbilityType::FORM;
710 EXPECT_EQ(abilityMs_->ConnectLocalAbility(want, 100, nullptr, nullptr, extensionType), ERR_CROSS_USER);
711 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ConnectLocalAbility_001 end");
712 }
713
714 /*
715 * Feature: AbilityManagerService
716 * Function: ConnectLocalAbility
717 * SubFunction: NA
718 * FunctionPoints: AbilityManagerService ConnectLocalAbility
719 */
720 HWTEST_F(AbilityManagerServiceSecondTest, ConnectLocalAbility_002, TestSize.Level1)
721 {
722 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ConnectLocalAbility_002 start");
723 auto abilityMs_ = std::make_shared<AbilityManagerService>();
724 Want want;
725 ExtensionAbilityType extensionType = ExtensionAbilityType::SERVICE;
726 auto ret = abilityMs_->ConnectLocalAbility(want, 100, nullptr, nullptr, extensionType);
727 if (AppUtils::GetInstance().IsConnectSupportCrossUser()) {
728 EXPECT_EQ(ret, ERR_INVALID_VALUE);
729 } else {
730 EXPECT_EQ(ret, ERR_CROSS_USER);
731 }
732
733 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ConnectLocalAbility_002 end");
734 }
735
736 /*
737 * Feature: AbilityManagerService
738 * Function: DisconnectRemoteAbility
739 * SubFunction: NA
740 * FunctionPoints: AbilityManagerService DisconnectRemoteAbility
741 */
742 HWTEST_F(AbilityManagerServiceSecondTest, DisconnectRemoteAbility_001, TestSize.Level1)
743 {
744 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DisconnectRemoteAbility_001 start");
745 auto abilityMs_ = std::make_shared<AbilityManagerService>();
746 EXPECT_EQ(abilityMs_->DisconnectRemoteAbility(nullptr), ERR_NULL_OBJECT);
747 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DisconnectRemoteAbility_001 end");
748 }
749
750 /*
751 * Feature: AbilityManagerService
752 * Function: ContinueMission
753 * SubFunction: NA
754 * FunctionPoints: AbilityManagerService ContinueMission
755 */
756 HWTEST_F(AbilityManagerServiceSecondTest, ContinueMission_001, TestSize.Level1)
757 {
758 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueMission_001 start");
759 auto abilityMs_ = std::make_shared<AbilityManagerService>();
760 std::string srcDeviceId = "test";
761 std::string dstDeviceId = "test";
762 AAFwk::WantParams wantParams;
763 EXPECT_NE(abilityMs_->ContinueMission(srcDeviceId, dstDeviceId, 1, nullptr, wantParams),
764 ERR_OK);
765 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueMission_001 end");
766 }
767
768 /*
769 * Feature: AbilityManagerService
770 * Function: ContinueMissionBundleName
771 * SubFunction: NA
772 * FunctionPoints: AbilityManagerService ContinueMissionBundleName
773 */
774 HWTEST_F(AbilityManagerServiceSecondTest, ContinueMissionBundleName_001, TestSize.Level1)
775 {
776 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueMissionBundleName_001 start");
777 auto abilityMs_ = std::make_shared<AbilityManagerService>();
778 std::string srcDeviceId = "";
779 std::string dstDeviceId = "";
780 const sptr<IRemoteObject> callback = nullptr;
781 AAFwk::WantParams wantParams;
782 ContinueMissionInfo continueMissionInfo;
783 continueMissionInfo.dstDeviceId = dstDeviceId;
784 continueMissionInfo.srcDeviceId = srcDeviceId;
785 continueMissionInfo.bundleName = "bundleName";
786 continueMissionInfo.wantParams = wantParams;
787 EXPECT_NE(abilityMs_->ContinueMission(continueMissionInfo, callback), ERR_OK);
788 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueMissionBundleName_001 end");
789 }
790
791 /*
792 * Feature: AbilityManagerService
793 * Function: ContinueMissionBundleName
794 * SubFunction: NA
795 * FunctionPoints: AbilityManagerService ContinueMissionBundleName
796 */
797 HWTEST_F(AbilityManagerServiceSecondTest, ContinueMissionBundleName_002, TestSize.Level1)
798 {
799 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueMissionBundleName_002 start");
800 auto abilityMs_ = std::make_shared<AbilityManagerService>();
801 std::string srcDeviceId = "";
802 std::string dstDeviceId = "";
803 const sptr<IRemoteObject> callback = nullptr;
804 AAFwk::WantParams wantParams;
805 ContinueMissionInfo continueMissionInfo;
806 continueMissionInfo.dstDeviceId = dstDeviceId;
807 continueMissionInfo.srcDeviceId = srcDeviceId;
808 continueMissionInfo.bundleName = "";
809 continueMissionInfo.wantParams = wantParams;
810 EXPECT_NE(abilityMs_->ContinueMission(continueMissionInfo, callback), ERR_OK);
811 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueMissionBundleName_002 end");
812 }
813
814 /*
815 * Feature: AbilityManagerService
816 * Function: ContinueAbility
817 * SubFunction: NA
818 * FunctionPoints: AbilityManagerService ContinueAbility
819 */
820 HWTEST_F(AbilityManagerServiceSecondTest, ContinueAbility_001, TestSize.Level1)
821 {
822 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueAbility_001 start");
823 auto abilityMs_ = std::make_shared<AbilityManagerService>();
824 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
825 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
826 std::string deviceId = "test";
827 EXPECT_EQ(abilityMs_->ContinueAbility(deviceId, 1, 1), ERR_INVALID_VALUE);
828 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueAbility_001 end");
829 }
830
831 /*
832 * Feature: AbilityManagerService
833 * Function: StartContinuation
834 * SubFunction: NA
835 * FunctionPoints: AbilityManagerService StartContinuation
836 */
837 HWTEST_F(AbilityManagerServiceSecondTest, StartContinuation_001, TestSize.Level1)
838 {
839 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartContinuation_001 start");
840 auto abilityMs_ = std::make_shared<AbilityManagerService>();
841 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
842 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
843 Want want;
844 EXPECT_EQ(abilityMs_->StartContinuation(want, nullptr, 1), ERR_INVALID_VALUE);
845 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartContinuation_001 end");
846 }
847
848 /*
849 * Feature: AbilityManagerService
850 * Function: NotifyCompleteContinuation
851 * SubFunction: NA
852 * FunctionPoints: AbilityManagerService NotifyCompleteContinuation
853 */
854 HWTEST_F(AbilityManagerServiceSecondTest, NotifyCompleteContinuation_001, TestSize.Level1)
855 {
856 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest NotifyCompleteContinuation_001 start");
857 auto abilityMs_ = std::make_shared<AbilityManagerService>();
858 std::string deviceId = "test";
859 ASSERT_NE(abilityMs_, nullptr);
860 abilityMs_->NotifyCompleteContinuation(deviceId, 1, true);
861 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest NotifyCompleteContinuation_001 end");
862 }
863
864 /*
865 * Feature: AbilityManagerService
866 * Function: NotifyContinuationResult
867 * SubFunction: NA
868 * FunctionPoints: AbilityManagerService NotifyContinuationResult
869 */
870 HWTEST_F(AbilityManagerServiceSecondTest, NotifyContinuationResult_001, TestSize.Level1)
871 {
872 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest NotifyContinuationResult_001 start");
873 auto abilityMs_ = std::make_shared<AbilityManagerService>();
874 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
875 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
876 EXPECT_EQ(abilityMs_->NotifyContinuationResult(1, 1), ERR_INVALID_VALUE);
877 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest NotifyContinuationResult_001 end");
878 }
879
880 /*
881 * Feature: AbilityManagerService
882 * Function: StopSyncRemoteMissions
883 * SubFunction: NA
884 * FunctionPoints: AbilityManagerService StopSyncRemoteMissions
885 */
886 HWTEST_F(AbilityManagerServiceSecondTest, StopSyncRemoteMissions_001, TestSize.Level1)
887 {
888 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StopSyncRemoteMissions_001 start");
889 auto abilityMs_ = std::make_shared<AbilityManagerService>();
890 std::string devId = "test";
891 EXPECT_NE(abilityMs_->StopSyncRemoteMissions(devId), ERR_OK);
892 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StopSyncRemoteMissions_001 end");
893 }
894
895 /*
896 * Feature: AbilityManagerService
897 * Function: RegisterObserver
898 * SubFunction: NA
899 * FunctionPoints: AbilityManagerService RegisterObserver
900 */
901 HWTEST_F(AbilityManagerServiceSecondTest, RegisterObserver_001, TestSize.Level1)
902 {
903 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterObserver_001 start");
904 AAFwk::IsMockSaCall::IsMockCheckObserverCallerPermission();
905 auto abilityMs_ = std::make_shared<AbilityManagerService>();
906 abilityMs_->RegisterObserver(nullptr);
907 EXPECT_NE(abilityMs_, nullptr);
908 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterObserver_001 end");
909 }
910
911 /*
912 * Feature: AbilityManagerService
913 * Function: UnregisterObserver
914 * SubFunction: NA
915 * FunctionPoints: AbilityManagerService UnregisterObserver
916 */
917 HWTEST_F(AbilityManagerServiceSecondTest, UnregisterObserver_001, TestSize.Level1)
918 {
919 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnregisterObserver_001 start");
920 AAFwk::IsMockSaCall::IsMockCheckObserverCallerPermission();
921 auto abilityMs_ = std::make_shared<AbilityManagerService>();
922 abilityMs_->UnregisterObserver(nullptr);
923 EXPECT_NE(abilityMs_, nullptr);
924 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnregisterObserver_001 end");
925 }
926
927 /*
928 * Feature: AbilityManagerService
929 * Function: RegisterMissionListener
930 * SubFunction: NA
931 * FunctionPoints: AbilityManagerService RegisterMissionListener
932 */
933 HWTEST_F(AbilityManagerServiceSecondTest, RegisterMissionListener_001, TestSize.Level1)
934 {
935 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterMissionListener_001 start");
936 auto abilityMs_ = std::make_shared<AbilityManagerService>();
937 std::string deviceId = "test";
938 EXPECT_NE(abilityMs_->RegisterMissionListener(deviceId, nullptr), ERR_OK);
939 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterMissionListener_001 end");
940 }
941
942 /*
943 * Feature: AbilityManagerService
944 * Function: RegisterMissionListener
945 * SubFunction: NA
946 * FunctionPoints: AbilityManagerService RegisterMissionListener
947 */
948 HWTEST_F(AbilityManagerServiceSecondTest, RegisterMissionListener_002, TestSize.Level1)
949 {
950 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterMissionListener_002 start");
951 auto abilityMs_ = std::make_shared<AbilityManagerService>();
952 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
953 auto temp_ = abilityMs_->subManagersHelper_->currentMissionListManager_;
954 abilityMs_->subManagersHelper_->currentMissionListManager_ = nullptr;
955 abilityMs_->RegisterMissionListener(nullptr);
956 EXPECT_TRUE(abilityMs_ != nullptr);
957 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterMissionListener_002 end");
958 }
959
960 /*
961 * Feature: AbilityManagerService
962 * Function: RegisterMissionListener
963 * SubFunction: NA
964 * FunctionPoints: AbilityManagerService RegisterMissionListener
965 */
966 HWTEST_F(AbilityManagerServiceSecondTest, RegisterMissionListener_003, TestSize.Level1)
967 {
968 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterMissionListener_003 start");
969 auto abilityMs_ = std::make_shared<AbilityManagerService>();
970 std::string deviceId = "test";
971 sptr<MockIRemoteMissionListener> listener = new (std::nothrow) MockIRemoteMissionListener();
972 EXPECT_NE(listener, nullptr);
973 EXPECT_NE(abilityMs_->RegisterMissionListener(deviceId, listener), ERR_OK);
974 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterMissionListener_003 end");
975 }
976
977 /*
978 * Feature: AbilityManagerService
979 * Function: UnRegisterMissionListener
980 * SubFunction: NA
981 * FunctionPoints: AbilityManagerService UnRegisterMissionListener
982 */
983 HWTEST_F(AbilityManagerServiceSecondTest, UnRegisterMissionListener_001, TestSize.Level1)
984 {
985 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnRegisterMissionListener_001 start");
986 auto abilityMs_ = std::make_shared<AbilityManagerService>();
987 std::string deviceId = "test";
988 EXPECT_NE(abilityMs_->UnRegisterMissionListener(deviceId, nullptr), ERR_OK);
989 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnRegisterMissionListener_001 end");
990 }
991
992 /*
993 * Feature: AbilityManagerService
994 * Function: UnRegisterMissionListener
995 * SubFunction: NA
996 * FunctionPoints: AbilityManagerService UnRegisterMissionListener
997 */
998 HWTEST_F(AbilityManagerServiceSecondTest, UnRegisterMissionListener_002, TestSize.Level1)
999 {
1000 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnRegisterMissionListener_002 start");
1001 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1002 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1003 auto temp_ = abilityMs_->subManagersHelper_->currentMissionListManager_;
1004 abilityMs_->subManagersHelper_->currentMissionListManager_ = nullptr;
1005 EXPECT_EQ(abilityMs_->UnRegisterMissionListener(nullptr), ERR_NO_INIT);
1006 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnRegisterMissionListener_002 end");
1007 }
1008
1009 /*
1010 * Feature: AbilityManagerService
1011 * Function: UnRegisterMissionListener
1012 * SubFunction: NA
1013 * FunctionPoints: AbilityManagerService UnRegisterMissionListener
1014 */
1015 HWTEST_F(AbilityManagerServiceSecondTest, UnRegisterMissionListener_003, TestSize.Level1)
1016 {
1017 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnRegisterMissionListener_003 start");
1018 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1019 std::string deviceId = "test";
1020 sptr<MockIRemoteMissionListener> listener = new (std::nothrow) MockIRemoteMissionListener();
1021 EXPECT_NE(listener, nullptr);
1022 EXPECT_NE(abilityMs_->UnRegisterMissionListener(deviceId, listener), ERR_OK);
1023 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnRegisterMissionListener_003 end");
1024 }
1025
1026 /*
1027 * Feature: AbilityManagerService
1028 * Function: GetWantSender
1029 * SubFunction: NA
1030 * FunctionPoints: AbilityManagerService GetWantSender
1031 */
1032 HWTEST_F(AbilityManagerServiceSecondTest, GetWantSender_001, TestSize.Level1)
1033 {
1034 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetWantSender_001 start");
1035 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1036 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1037 WantSenderInfo wantSenderInfo;
1038 auto temp = abilityMs_->subManagersHelper_->currentPendingWantManager_;
1039 abilityMs_->subManagersHelper_->currentPendingWantManager_ = nullptr;
1040 EXPECT_EQ(abilityMs_->GetWantSender(wantSenderInfo, nullptr), nullptr);
1041 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetWantSender_001 end");
1042 }
1043
1044 /*
1045 * Feature: AbilityManagerService
1046 * Function: SendWantSender
1047 * SubFunction: NA
1048 * FunctionPoints: AbilityManagerService SendWantSender
1049 */
1050 HWTEST_F(AbilityManagerServiceSecondTest, SendWantSender_001, TestSize.Level1)
1051 {
1052 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest SendWantSender_001 start");
1053 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1054 SenderInfo senderInfo;
1055 EXPECT_EQ(abilityMs_->SendWantSender(nullptr, senderInfo), ERR_INVALID_VALUE);
1056 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest SendWantSender_001 end");
1057 }
1058
1059 /*
1060 * Feature: AbilityManagerService
1061 * Function: CancelWantSender
1062 * SubFunction: NA
1063 * FunctionPoints: AbilityManagerService CancelWantSender
1064 */
1065 HWTEST_F(AbilityManagerServiceSecondTest, CancelWantSender_001, TestSize.Level1)
1066 {
1067 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CancelWantSender_001 start");
1068 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1069 ASSERT_NE(abilityMs_, nullptr);
1070 abilityMs_->CancelWantSender(nullptr);
1071 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CancelWantSender_001 end");
1072 }
1073
1074 /*
1075 * Feature: AbilityManagerService
1076 * Function: GetPendingWantUid
1077 * SubFunction: NA
1078 * FunctionPoints: AbilityManagerService GetPendingWantUid
1079 */
1080 HWTEST_F(AbilityManagerServiceSecondTest, GetPendingWantUid_001, TestSize.Level1)
1081 {
1082 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantUid_001 start");
1083 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1084 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1085 auto temp = abilityMs_->subManagersHelper_->currentPendingWantManager_;
1086 abilityMs_->subManagersHelper_->currentPendingWantManager_.reset();
1087 EXPECT_EQ(abilityMs_->GetPendingWantUid(nullptr), -1);
1088
1089 abilityMs_->subManagersHelper_->currentPendingWantManager_ = temp;
1090 EXPECT_EQ(abilityMs_->GetPendingWantUid(nullptr), -1);
1091 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantUid_001 end");
1092 }
1093
1094 /*
1095 * Feature: AbilityManagerService
1096 * Function: GetPendingWantUserId
1097 * SubFunction: NA
1098 * FunctionPoints: AbilityManagerService GetPendingWantUserId
1099 */
1100 HWTEST_F(AbilityManagerServiceSecondTest, GetPendingWantUserId_001, TestSize.Level1)
1101 {
1102 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantUserId_001 start");
1103 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1104 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1105 auto temp = abilityMs_->subManagersHelper_->currentPendingWantManager_;
1106 abilityMs_->subManagersHelper_->currentPendingWantManager_.reset();
1107 EXPECT_EQ(abilityMs_->GetPendingWantUserId(nullptr), -1);
1108
1109 abilityMs_->subManagersHelper_->currentPendingWantManager_ = temp;
1110 EXPECT_EQ(abilityMs_->GetPendingWantUserId(nullptr), -1);
1111 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantUserId_001 end");
1112 }
1113
1114 /*
1115 * Feature: AbilityManagerService
1116 * Function: GetPendingWantBundleName
1117 * SubFunction: NA
1118 * FunctionPoints: AbilityManagerService GetPendingWantBundleName
1119 */
1120 HWTEST_F(AbilityManagerServiceSecondTest, GetPendingWantBundleName_001, TestSize.Level1)
1121 {
1122 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantBundleName_001 start");
1123 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1124 EXPECT_EQ(abilityMs_->GetPendingWantBundleName(nullptr), "");
1125 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantBundleName_001 end");
1126 }
1127
1128 /*
1129 * Feature: AbilityManagerService
1130 * Function: GetPendingWantCode
1131 * SubFunction: NA
1132 * FunctionPoints: AbilityManagerService GetPendingWantCode
1133 */
1134 HWTEST_F(AbilityManagerServiceSecondTest, GetPendingWantCode_001, TestSize.Level1)
1135 {
1136 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantCode_001 start");
1137 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1138 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1139 auto temp = abilityMs_->subManagersHelper_->currentPendingWantManager_;
1140 abilityMs_->subManagersHelper_->currentPendingWantManager_.reset();
1141 EXPECT_EQ(abilityMs_->GetPendingWantCode(nullptr), -1);
1142
1143 abilityMs_->subManagersHelper_->currentPendingWantManager_ = temp;
1144 EXPECT_EQ(abilityMs_->GetPendingWantCode(nullptr), -1);
1145 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantCode_001 end");
1146 }
1147
1148 /*
1149 * Feature: AbilityManagerService
1150 * Function: GetPendingWantType
1151 * SubFunction: NA
1152 * FunctionPoints: AbilityManagerService GetPendingWantType
1153 */
1154 HWTEST_F(AbilityManagerServiceSecondTest, GetPendingWantType_001, TestSize.Level1)
1155 {
1156 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantType_001 start");
1157 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1158 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1159 auto temp = abilityMs_->subManagersHelper_->currentPendingWantManager_;
1160 abilityMs_->subManagersHelper_->currentPendingWantManager_.reset();
1161 EXPECT_EQ(abilityMs_->GetPendingWantType(nullptr), -1);
1162
1163 abilityMs_->subManagersHelper_->currentPendingWantManager_ = temp;
1164 EXPECT_EQ(abilityMs_->GetPendingWantType(nullptr), -1);
1165 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantType_001 end");
1166 }
1167
1168 /*
1169 * Feature: AbilityManagerService
1170 * Function: RegisterCancelListener
1171 * SubFunction: NA
1172 * FunctionPoints: AbilityManagerService RegisterCancelListener
1173 */
1174 HWTEST_F(AbilityManagerServiceSecondTest, RegisterCancelListener_001, TestSize.Level1)
1175 {
1176 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterCancelListener_001 start");
1177 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1178 ASSERT_NE(abilityMs_, nullptr);
1179 abilityMs_->RegisterCancelListener(nullptr, nullptr);
1180 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterCancelListener_001 end");
1181 }
1182
1183 /*
1184 * Feature: AbilityManagerService
1185 * Function: UnregisterCancelListener
1186 * SubFunction: NA
1187 * FunctionPoints: AbilityManagerService UnregisterCancelListener
1188 */
1189 HWTEST_F(AbilityManagerServiceSecondTest, UnregisterCancelListener_001, TestSize.Level1)
1190 {
1191 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnregisterCancelListener_001 start");
1192 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1193 ASSERT_NE(abilityMs_, nullptr);
1194 abilityMs_->UnregisterCancelListener(nullptr, nullptr);
1195 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnregisterCancelListener_001 end");
1196 }
1197
1198 /*
1199 * Feature: AbilityManagerService
1200 * Function: GetPendingRequestWant
1201 * SubFunction: NA
1202 * FunctionPoints: AbilityManagerService GetPendingRequestWant
1203 */
1204 HWTEST_F(AbilityManagerServiceSecondTest, GetPendingRequestWant_001, TestSize.Level1)
1205 {
1206 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingRequestWant_001 start");
1207 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1208 std::shared_ptr<Want> want;
1209 EXPECT_EQ(abilityMs_->GetPendingRequestWant(nullptr, want), ERR_INVALID_VALUE);
1210 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingRequestWant_001 end");
1211 }
1212
1213 /*
1214 * Feature: AbilityManagerService
1215 * Function: UnlockMissionForCleanup
1216 * SubFunction: NA
1217 * FunctionPoints: AbilityManagerService UnlockMissionForCleanup
1218 */
1219 HWTEST_F(AbilityManagerServiceSecondTest, UnlockMissionForCleanup_001, TestSize.Level1)
1220 {
1221 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnlockMissionForCleanup_001 start");
1222 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1223 EXPECT_NE(abilityMs_->UnlockMissionForCleanup(1), CHECK_PERMISSION_FAILED);
1224 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnlockMissionForCleanup_001 end");
1225 }
1226
1227 /*
1228 * Feature: AbilityManagerService
1229 * Function: GetMissionInfos
1230 * SubFunction: NA
1231 * FunctionPoints: AbilityManagerService GetMissionInfos
1232 */
1233 HWTEST_F(AbilityManagerServiceSecondTest, GetMissionInfos_001, TestSize.Level1)
1234 {
1235 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetMissionInfos_001 start");
1236 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1237 std::vector<MissionInfo> missionInfos;
1238 EXPECT_NE(abilityMs_->GetMissionInfos("", 10, missionInfos), CHECK_PERMISSION_FAILED);
1239 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetMissionInfos_001 end");
1240 }
1241
1242 /*
1243 * Feature: AbilityManagerService
1244 * Function: GetRemoteMissionInfos
1245 * SubFunction: NA
1246 * FunctionPoints: AbilityManagerService GetRemoteMissionInfos
1247 */
1248 HWTEST_F(AbilityManagerServiceSecondTest, GetRemoteMissionInfos_001, TestSize.Level1)
1249 {
1250 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetRemoteMissionInfos_001 start");
1251 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1252 std::vector<MissionInfo> missionInfos;
1253 EXPECT_NE(abilityMs_->GetRemoteMissionInfos("", 10, missionInfos), ERR_OK);
1254 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetRemoteMissionInfos_001 end");
1255 }
1256
1257 /*
1258 * Feature: AbilityManagerService
1259 * Function: GetMissionInfo
1260 * SubFunction: NA
1261 * FunctionPoints: AbilityManagerService GetMissionInfo
1262 */
1263 HWTEST_F(AbilityManagerServiceSecondTest, GetMissionInfo_001, TestSize.Level1)
1264 {
1265 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetMissionInfo_001 start");
1266 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1267 MissionInfo missionInfo;
1268 EXPECT_NE(abilityMs_->GetMissionInfo("", 10, missionInfo), CHECK_PERMISSION_FAILED);
1269 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetMissionInfo_001 end");
1270 }
1271
1272 /*
1273 * Feature: AbilityManagerService
1274 * Function: GetRemoteMissionInfo
1275 * SubFunction: NA
1276 * FunctionPoints: AbilityManagerService GetRemoteMissionInfo
1277 */
1278 HWTEST_F(AbilityManagerServiceSecondTest, GetRemoteMissionInfo_001, TestSize.Level1)
1279 {
1280 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetRemoteMissionInfo_001 start");
1281 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1282 MissionInfo missionInfo;
1283 EXPECT_NE(abilityMs_->GetRemoteMissionInfo("", 10, missionInfo), ERR_OK);
1284 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetRemoteMissionInfo_001 end");
1285 }
1286
1287 /*
1288 * Feature: AbilityManagerService
1289 * Function: CleanMission
1290 * SubFunction: NA
1291 * FunctionPoints: AbilityManagerService CleanMission
1292 */
1293 HWTEST_F(AbilityManagerServiceSecondTest, CleanMission_001, TestSize.Level1)
1294 {
1295 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CleanMission_001 start");
1296 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1297 EXPECT_NE(abilityMs_->CleanMission(1), CHECK_PERMISSION_FAILED);
1298 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CleanMission_001 end");
1299 }
1300
1301 /*
1302 * Feature: AbilityManagerService
1303 * Function: MoveMissionToFront
1304 * SubFunction: NA
1305 * FunctionPoints: AbilityManagerService MoveMissionToFront
1306 */
1307 HWTEST_F(AbilityManagerServiceSecondTest, MoveMissionToFront_001, TestSize.Level1)
1308 {
1309 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionToFront_001 start");
1310 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1311 abilityMs_->MoveMissionToFront(100);
1312 EXPECT_TRUE(abilityMs_ != nullptr);
1313 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionToFront_001 end");
1314 }
1315
1316 /*
1317 * Feature: AbilityManagerService
1318 * Function: MoveMissionToFront
1319 * SubFunction: NA
1320 * FunctionPoints: AbilityManagerService MoveMissionToFront
1321 */
1322 HWTEST_F(AbilityManagerServiceSecondTest, MoveMissionToFront_002, TestSize.Level1)
1323 {
1324 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionToFront_002 start");
1325 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1326 StartOptions startOptions;
1327 EXPECT_NE(abilityMs_->MoveMissionToFront(100, startOptions), ERR_OK);
1328 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionToFront_002 end");
1329 }
1330
1331 /*
1332 * Feature: AbilityManagerService
1333 * Function: MoveMissionToFront
1334 * SubFunction: NA
1335 * FunctionPoints: AbilityManagerService MoveMissionToFront
1336 */
1337 HWTEST_F(AbilityManagerServiceSecondTest, MoveMissionToFront_003, TestSize.Level1)
1338 {
1339 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionToFront_003 start");
1340 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1341 EXPECT_TRUE(abilityMs_ != nullptr);
1342 StartOptions startOptions;
1343 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1344 EXPECT_NE(abilityMs_->MoveMissionToFront(100, startOptions), ERR_OK);
1345 }
1346 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionToFront_002 end");
1347 }
1348
1349 /*
1350 * Feature: AbilityManagerService
1351 * Function: MoveMissionsToForeground
1352 * SubFunction: NA
1353 * FunctionPoints: AbilityManagerService MoveMissionToFront
1354 */
1355 HWTEST_F(AbilityManagerServiceSecondTest, MoveMissionsToForeground_001, TestSize.Level1)
1356 {
1357 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionsToForeground_001 start");
1358 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1359 EXPECT_NE(abilityMs_->MoveMissionsToForeground({1, 2, 3}, 1), ERR_OK);
1360 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionsToForeground_001 end");
1361 }
1362
1363 /*
1364 * Feature: AbilityManagerService
1365 * Function: MoveMissionsToBackground
1366 * SubFunction: NA
1367 * FunctionPoints: AbilityManagerService MoveMissionToFront
1368 */
1369 HWTEST_F(AbilityManagerServiceSecondTest, MoveMissionsToBackground_001, TestSize.Level1)
1370 {
1371 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionsToBackground_001 start");
1372 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1373 std::vector<int32_t> rs;
1374 EXPECT_NE(abilityMs_->MoveMissionsToBackground({1, 2, 3}, rs), ERR_OK);
1375 EXPECT_TRUE(rs.empty());
1376 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionsToBackground_001 end");
1377 }
1378
1379 /*
1380 * Feature: AbilityManagerService
1381 * Function: IsAbilityControllerStartById
1382 * SubFunction: NA
1383 * FunctionPoints: AbilityManagerService IsAbilityControllerStartById
1384 */
1385 HWTEST_F(AbilityManagerServiceSecondTest, IsAbilityControllerStartById_001, TestSize.Level1)
1386 {
1387 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsAbilityControllerStartById_001 start");
1388 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1389 EXPECT_TRUE(abilityMs_->IsAbilityControllerStartById(1));
1390 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsAbilityControllerStartById_001 end");
1391 }
1392
1393 /*
1394 * Feature: AbilityManagerService
1395 * Function: GetConnectRecordListByCallback
1396 * SubFunction: NA
1397 * FunctionPoints: AbilityManagerService GetConnectRecordListByCallback
1398 */
1399 HWTEST_F(AbilityManagerServiceSecondTest, GetConnectRecordListByCallback_001, TestSize.Level1)
1400 {
1401 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetConnectRecordListByCallback_001 start");
1402 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1403 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1404 auto temp = abilityMs_->subManagersHelper_->currentConnectManager_;
1405 abilityMs_->subManagersHelper_->currentConnectManager_.reset();
1406 std::list<std::shared_ptr<ConnectionRecord>> connectList;
1407 EXPECT_EQ(abilityMs_->GetConnectRecordListByCallback(nullptr), connectList);
1408 abilityMs_->subManagersHelper_->currentConnectManager_ = temp;
1409 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetConnectRecordListByCallback_001 end");
1410 }
1411
1412 /*
1413 * Feature: AbilityManagerService
1414 * Function: AcquireDataAbility
1415 * SubFunction: NA
1416 * FunctionPoints: AbilityManagerService AcquireDataAbility
1417 */
1418 HWTEST_F(AbilityManagerServiceSecondTest, AcquireDataAbility_001, TestSize.Level1)
1419 {
1420 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest AcquireDataAbility_001 start");
1421 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1422 Uri uri("test");
1423 EXPECT_EQ(abilityMs_->AcquireDataAbility(uri, true, nullptr), nullptr);
1424 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest AcquireDataAbility_001 end");
1425 }
1426
1427 /*
1428 * Feature: AbilityManagerService
1429 * Function: ReleaseDataAbility
1430 * SubFunction: NA
1431 * FunctionPoints: AbilityManagerService ReleaseDataAbility
1432 */
1433 HWTEST_F(AbilityManagerServiceSecondTest, ReleaseDataAbility_001, TestSize.Level1)
1434 {
1435 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ReleaseDataAbility_001 start");
1436 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1437 EXPECT_EQ(abilityMs_->ReleaseDataAbility(nullptr, nullptr), ERR_INVALID_VALUE);
1438 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ReleaseDataAbility_001 end");
1439 }
1440
1441 /*
1442 * Feature: AbilityManagerService
1443 * Function: AttachAbilityThread
1444 * SubFunction: NA
1445 * FunctionPoints: AbilityManagerService AttachAbilityThread
1446 */
1447 HWTEST_F(AbilityManagerServiceSecondTest, AttachAbilityThread_001, TestSize.Level1)
1448 {
1449 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest AttachAbilityThread_001 start");
1450 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1451 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1452 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
1453 EXPECT_EQ(abilityMs_->AttachAbilityThread(nullptr, nullptr), ERR_INVALID_VALUE);
1454 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest AttachAbilityThread_001 end");
1455 }
1456
1457 /*
1458 * Feature: AbilityManagerService
1459 * Function: DumpInner
1460 * SubFunction: NA
1461 * FunctionPoints: AbilityManagerService DumpInner
1462 */
1463 HWTEST_F(AbilityManagerServiceSecondTest, DumpInner_001, TestSize.Level1)
1464 {
1465 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpInner_001 start");
1466 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1467 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1468 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
1469 std::vector<std::string> info;
1470 ASSERT_NE(abilityMs_, nullptr);
1471 abilityMs_->DumpInner("", info);
1472 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpInner_001 end");
1473 }
1474
1475 /*
1476 * Feature: AbilityManagerService
1477 * Function: DumpMissionListInner
1478 * SubFunction: NA
1479 * FunctionPoints: AbilityManagerService DumpMissionListInner
1480 */
1481 HWTEST_F(AbilityManagerServiceSecondTest, DumpMissionListInner_001, TestSize.Level1)
1482 {
1483 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpMissionListInner_001 start");
1484 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1485 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1486 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
1487 std::vector<std::string> info;
1488 ASSERT_NE(abilityMs_, nullptr);
1489 abilityMs_->DumpMissionListInner("", info);
1490 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpMissionListInner_001 end");
1491 }
1492
1493 /*
1494 * Feature: AbilityManagerService
1495 * Function: DumpMissionInfosInner
1496 * SubFunction: NA
1497 * FunctionPoints: AbilityManagerService DumpMissionInfosInner
1498 */
1499 HWTEST_F(AbilityManagerServiceSecondTest, DumpMissionInfosInner_001, TestSize.Level1)
1500 {
1501 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpMissionInfosInner_001 start");
1502 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1503 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1504 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
1505 std::vector<std::string> info;
1506 ASSERT_NE(abilityMs_, nullptr);
1507 abilityMs_->DumpMissionInfosInner("", info);
1508 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpMissionInfosInner_001 end");
1509 }
1510
1511 /*
1512 * Feature: AbilityManagerService
1513 * Function: SetResidentProcessEnabled
1514 * SubFunction: NA
1515 * FunctionPoints: AbilityManagerService SetResidentProcessEnabled
1516 */
1517 HWTEST_F(AbilityManagerServiceSecondTest, SetResidentProcessEnable_001, TestSize.Level1)
1518 {
1519 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1520 std::string bundleName = "ability.manager.service.test";
1521 bool enable = false;
1522 abilityMs_->SetResidentProcessEnabled(bundleName, enable);
1523 ASSERT_NE(abilityMs_, nullptr);
1524 }
1525
1526 /*
1527 * Feature: AbilityManagerService
1528 * Function: DumpMissionInner
1529 * SubFunction: NA
1530 * FunctionPoints: AbilityManagerService DumpMissionInner
1531 */
1532 HWTEST_F(AbilityManagerServiceSecondTest, DumpMissionInner_001, TestSize.Level1)
1533 {
1534 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpMissionInner_001 start");
1535 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1536 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1537 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
1538 std::vector<std::string> info;
1539 ASSERT_NE(abilityMs_, nullptr);
1540 abilityMs_->DumpMissionInner("", info);
1541 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpMissionInner_001 end");
1542 }
1543
1544 /*
1545 * Feature: AbilityManagerService
1546 * Function: DumpStateInner
1547 * SubFunction: NA
1548 * FunctionPoints: AbilityManagerService DumpStateInner
1549 */
1550 HWTEST_F(AbilityManagerServiceSecondTest, DumpStateInner_001, TestSize.Level1)
1551 {
1552 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpStateInner_001 start");
1553 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1554 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1555 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
1556 std::vector<std::string> info;
1557 ASSERT_NE(abilityMs_, nullptr);
1558 abilityMs_->DumpStateInner("", info);
1559 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpStateInner_001 end");
1560 }
1561
1562 /*
1563 * Feature: AbilityManagerService
1564 * Function: DataDumpStateInner
1565 * SubFunction: NA
1566 * FunctionPoints: AbilityManagerService DataDumpStateInner
1567 */
1568 HWTEST_F(AbilityManagerServiceSecondTest, DataDumpStateInner_001, TestSize.Level1)
1569 {
1570 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DataDumpStateInner_001 start");
1571 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1572 std::vector<std::string> info;
1573 ASSERT_NE(abilityMs_, nullptr);
1574 abilityMs_->DataDumpStateInner("", info);
1575 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DataDumpStateInner_001 end");
1576 }
1577
1578 /*
1579 * Feature: AbilityManagerService
1580 * Function: DumpState
1581 * SubFunction: NA
1582 * FunctionPoints: AbilityManagerService DumpState
1583 */
1584 HWTEST_F(AbilityManagerServiceSecondTest, DumpState_001, TestSize.Level1)
1585 {
1586 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpState_001 start");
1587 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1588 std::vector<std::string> info;
1589 ASSERT_NE(abilityMs_, nullptr);
1590 abilityMs_->DumpState("", info);
1591 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpState_001 end");
1592 }
1593
1594 /*
1595 * Feature: AbilityManagerService
1596 * Function: DumpSysState
1597 * SubFunction: NA
1598 * FunctionPoints: AbilityManagerService DumpSysState
1599 */
1600 HWTEST_F(AbilityManagerServiceSecondTest, DumpSysState_001, TestSize.Level1)
1601 {
1602 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpSysState_001 start");
1603 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1604 std::vector<std::string> info;
1605 ASSERT_NE(abilityMs_, nullptr);
1606 abilityMs_->DumpSysState("", info, true, true, 100);
1607 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpSysState_001 end");
1608 }
1609
1610 /*
1611 * Feature: AbilityManagerService
1612 * Function: AbilityTransitionDone
1613 * SubFunction: NA
1614 * FunctionPoints: AbilityManagerService AbilityTransitionDone
1615 */
1616 HWTEST_F(AbilityManagerServiceSecondTest, AbilityTransitionDone_001, TestSize.Level1)
1617 {
1618 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest AbilityTransitionDone_001 start");
1619 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1620 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1621 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
1622 PacMap saveData;
1623 EXPECT_EQ(abilityMs_->AbilityTransitionDone(nullptr, 1, saveData), ERR_INVALID_VALUE);
1624 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest AbilityTransitionDone_001 end");
1625 }
1626
1627 /*
1628 * Feature: AbilityManagerService
1629 * Function: OnAppStateChanged
1630 * SubFunction: NA
1631 * FunctionPoints: AbilityManagerService OnAppStateChanged
1632 */
1633 HWTEST_F(AbilityManagerServiceSecondTest, OnAppStateChanged_001, TestSize.Level1)
1634 {
1635 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest OnAppStateChanged_001 start");
1636 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1637 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1638 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
1639 AppInfo info;
1640 ASSERT_NE(abilityMs_, nullptr);
1641 abilityMs_->OnAppStateChanged(info);
1642 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest OnAppStateChanged_001 end");
1643 }
1644
1645 /*
1646 * Feature: AbilityManagerService
1647 * Function: GetTaskHandler
1648 * SubFunction: NA
1649 * FunctionPoints: AbilityManagerService GetTaskHandler
1650 */
1651 HWTEST_F(AbilityManagerServiceSecondTest, GetTaskHandler_001, TestSize.Level1)
1652 {
1653 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetTaskHandler_001 start");
1654 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1655 ASSERT_NE(abilityMs_, nullptr);
1656 EXPECT_EQ(abilityMs_->GetTaskHandler(), nullptr);
1657 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetTaskHandler_001 end");
1658 }
1659
1660 /*
1661 * Feature: AbilityManagerService
1662 * Function: GetEventHandler
1663 * SubFunction: NA
1664 * FunctionPoints: AbilityManagerService GetEventHandler
1665 */
1666 HWTEST_F(AbilityManagerServiceSecondTest, GetEventHandler_001, TestSize.Level1)
1667 {
1668 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetEventHandler_001 start");
1669 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1670 ASSERT_NE(abilityMs_, nullptr);
1671 EXPECT_EQ(abilityMs_->GetEventHandler(), nullptr);
1672 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetEventHandler_001 end");
1673 }
1674
1675 /*
1676 * Feature: AbilityManagerService
1677 * Function: GetUserId
1678 * SubFunction: NA
1679 * FunctionPoints: AbilityManagerService GetUserId
1680 */
1681 HWTEST_F(AbilityManagerServiceSecondTest, GetUserId_001, TestSize.Level1)
1682 {
1683 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetUserId_001 start");
1684 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1685 EXPECT_NE(abilityMs_->GetUserId(), 100);
1686 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetUserId_001 end");
1687 }
1688
1689 /*
1690 * Feature: AbilityManagerService
1691 * Function: GenerateAbilityRequest
1692 * SubFunction: NA
1693 * FunctionPoints: AbilityManagerService GenerateAbilityRequest
1694 */
1695 HWTEST_F(AbilityManagerServiceSecondTest, GenerateAbilityRequest_001, TestSize.Level1)
1696 {
1697 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GenerateAbilityRequest_001 start");
1698 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1699 Want want;
1700 AbilityRequest request;
1701 EXPECT_EQ(abilityMs_->GenerateAbilityRequest(want, 1, request, nullptr, 100), RESOLVE_ABILITY_ERR);
1702 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GenerateAbilityRequest_001 end");
1703 }
1704
1705 /*
1706 * Feature: AbilityManagerService
1707 * Function: GenerateExtensionAbilityRequest
1708 * SubFunction: NA
1709 * FunctionPoints: AbilityManagerService GenerateExtensionAbilityRequest
1710 */
1711 HWTEST_F(AbilityManagerServiceSecondTest, GenerateExtensionAbilityRequest_001, TestSize.Level1)
1712 {
1713 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GenerateExtensionAbilityRequest_001 start");
1714 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1715 Want want;
1716 AbilityRequest request;
1717 EXPECT_EQ(abilityMs_->GenerateExtensionAbilityRequest(want, request, nullptr, 100), RESOLVE_ABILITY_ERR);
1718 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GenerateExtensionAbilityRequest_001 end");
1719 }
1720
1721 /*
1722 * Feature: AbilityManagerService
1723 * Function: KillProcess
1724 * SubFunction: NA
1725 * FunctionPoints: AbilityManagerService KillProcess
1726 */
1727 HWTEST_F(AbilityManagerServiceSecondTest, KillProcess_001, TestSize.Level1)
1728 {
1729 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest KillProcess_001 start");
1730 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1731 EXPECT_EQ(abilityMs_->KillProcess("test"), GET_BUNDLE_INFO_FAILED);
1732 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest KillProcess_001 end");
1733 }
1734
1735 /*
1736 * Feature: AbilityManagerService
1737 * Function: CheckPermissionForKillCollaborator
1738 * SubFunction: NA
1739 * FunctionPoints: AbilityManagerService CheckPermissionForKillCollaborator
1740 */
1741 HWTEST_F(AbilityManagerServiceSecondTest, CheckPermissionForKillCollaborator_001, TestSize.Level1)
1742 {
1743 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckPermissionForKillCollaborator_001 start");
1744 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1745 EXPECT_EQ(abilityMs_->CheckPermissionForKillCollaborator(), true);
1746 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckPermissionForKillCollaborator_001 end");
1747 }
1748
1749 /*
1750 * Feature: AbilityManagerService
1751 * Function: PreLoadAppDataAbilities
1752 * SubFunction: NA
1753 * FunctionPoints: AbilityManagerService PreLoadAppDataAbilities
1754 */
1755 HWTEST_F(AbilityManagerServiceSecondTest, PreLoadAppDataAbilities_001, TestSize.Level1)
1756 {
1757 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest PreLoadAppDataAbilities_001 start");
1758 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1759 EXPECT_EQ(abilityMs_->PreLoadAppDataAbilities("", 100), ERR_INVALID_VALUE);
1760 EXPECT_EQ(abilityMs_->PreLoadAppDataAbilities("test", -1), ERR_OK);
1761 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest PreLoadAppDataAbilities_001 end");
1762 }
1763
1764 /*
1765 * Feature: AbilityManagerService
1766 * Function: IsSystemUiApp
1767 * SubFunction: NA
1768 * FunctionPoints: AbilityManagerService IsSystemUiApp
1769 */
1770 HWTEST_F(AbilityManagerServiceSecondTest, IsSystemUiApp_001, TestSize.Level1)
1771 {
1772 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsSystemUiApp_001 start");
1773 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1774 AppExecFwk::AbilityInfo info;
1775 info.bundleName = "bundleName";
1776 EXPECT_FALSE(abilityMs_->IsSystemUiApp(info));
1777
1778 info.bundleName = AbilityConfig::SYSTEM_UI_BUNDLE_NAME;
1779 info.name = "test";
1780 EXPECT_FALSE(abilityMs_->IsSystemUiApp(info));
1781
1782 info.name = AbilityConfig::SYSTEM_UI_NAVIGATION_BAR;
1783 EXPECT_TRUE(abilityMs_->IsSystemUiApp(info));
1784
1785 info.name = AbilityConfig::SYSTEM_UI_STATUS_BAR;
1786 EXPECT_TRUE(abilityMs_->IsSystemUiApp(info));
1787
1788 info.name = AbilityConfig::SYSTEM_UI_ABILITY_NAME;
1789 EXPECT_TRUE(abilityMs_->IsSystemUiApp(info));
1790 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsSystemUiApp_001 end");
1791 }
1792
1793 /*
1794 * Feature: AbilityManagerService
1795 * Function: IsSystemUI
1796 * SubFunction: NA
1797 * FunctionPoints: AbilityManagerService IsSystemUI
1798 */
1799 HWTEST_F(AbilityManagerServiceSecondTest, IsSystemUI_001, TestSize.Level1)
1800 {
1801 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsSystemUI_001 start");
1802 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1803 std::string bundleName = "bundleName";
1804 EXPECT_FALSE(abilityMs_->IsSystemUI(bundleName));
1805
1806 bundleName = AbilityConfig::SYSTEM_UI_BUNDLE_NAME;
1807 EXPECT_TRUE(abilityMs_->IsSystemUI(bundleName));
1808 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsSystemUI_001 end");
1809 }
1810
1811 /*
1812 * Feature: AbilityManagerService
1813 * Function: CheckSenderWantInfo
1814 * SubFunction: NA
1815 * FunctionPoints: AbilityManagerService CheckSenderWantInfo
1816 */
1817 HWTEST_F(AbilityManagerServiceSecondTest, CheckSenderWantInfo_001, TestSize.Level1)
1818 {
1819 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckSenderWantInfo_001 start");
1820 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1821 WantSenderInfo wantSenderInfo;
1822 wantSenderInfo.bundleName = "badeName";
1823 int32_t callerUid = 0;
1824 EXPECT_TRUE(abilityMs_->CheckSenderWantInfo(callerUid, wantSenderInfo));
1825 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckSenderWantInfo_001 end");
1826 }
1827
1828 /*
1829 * Feature: AbilityManagerService
1830 * Function: ParseJsonFromBoot
1831 * SubFunction: NA
1832 * FunctionPoints: AbilityManagerService ParseJsonFromBoot
1833 */
1834 HWTEST_F(AbilityManagerServiceSecondTest, ParseJsonFromBoot_001, TestSize.Level1)
1835 {
1836 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ParseJsonFromBoot_001 start");
1837 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1838 const std::string file = "/etc/efficiency_manager/prevent_startability_whitelist.json";
1839 nlohmann::json whiteListJsonObj;
1840 abilityMs_->ParseJsonFromBoot(file);
1841 EXPECT_TRUE(abilityMs_ != nullptr);
1842 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ParseJsonFromBoot_001 end");
1843 }
1844
1845 /*
1846 * Feature: AbilityManagerService
1847 * Function: IsInWhiteList
1848 * SubFunction: NA
1849 * FunctionPoints: AbilityManagerService IsInWhiteList
1850 */
1851 HWTEST_F(AbilityManagerServiceSecondTest, IsInWhiteList_001, TestSize.Level1)
1852 {
1853 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsInWhiteList_001 start");
1854 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1855 const std::string callerBundleName = "com.example.amstest";
1856 const std::string calleeBundleName = "com.exmple.testserviceextensionability";
1857 const std::string calleeAbilityName = "ServiceextensionAbility";
1858 abilityMs_->IsInWhiteList(callerBundleName, calleeBundleName, calleeAbilityName);
1859 EXPECT_TRUE(abilityMs_ != nullptr);
1860 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsInWhiteList_001 end");
1861 }
1862
1863 /*
1864 * Feature: AbilityManagerService
1865 * Function: ShouldPreventStartAbility
1866 * SubFunction: NA
1867 * FunctionPoints: AbilityManagerService ShouldPreventStartAbility
1868 */
1869 HWTEST_F(AbilityManagerServiceSecondTest, ShouldPreventStartAbility_001, TestSize.Level1)
1870 {
1871 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ShouldPreventStartAbility_001 start");
1872 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1873 const std::string deviceName = "";
1874 const std::string abilityName = "EntryAbility";
1875 const std::string appName = "amstest";
1876 const std::string bundleName = "com.example.amstest";
1877 const std::string moduleName = "entry";
1878 AbilityRequest abilityRequest = AbilityManagerServiceSecondTest::GenerateAbilityRequest(deviceName,
1879 abilityName, appName, bundleName, moduleName);
1880 EXPECT_FALSE(abilityMs_->ShouldPreventStartAbility(abilityRequest));
1881 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ShouldPreventStartAbility_001 end");
1882 }
1883
1884 /*
1885 * Feature: AbilityManagerService
1886 * Name: UpdateKeepAliveEnableState_001
1887 * Function: UpdateKeepAliveEnableState
1888 * SubFunction: NA
1889 * FunctionPoints: AbilityManagerService UpdateKeepAliveEnableState
1890 */
1891 HWTEST_F(AbilityManagerServiceSecondTest, UpdateKeepAliveEnableState_001, TestSize.Level1)
1892 {
1893 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UpdateKeepAliveEnableState_001 start");
1894 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1895 EXPECT_NE(abilityMs_, nullptr);
1896 auto ret = abilityMs_->UpdateKeepAliveEnableState("bundle", "entry", "mainAbility", true, 0);
1897 EXPECT_NE(ret, ERR_OK);
1898 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UpdateKeepAliveEnableState_001 end");
1899 }
1900
1901 #ifdef SUPPORT_AUTO_FILL
1902 /**
1903 * @tc.name: CheckCallAutoFillExtensionPermission_001
1904 * @tc.desc: Check can't start non-system app when extension type is AUTO_FILL_PASSWORD.
1905 * @tc.type: FUNC
1906 */
1907 HWTEST_F(AbilityManagerServiceSecondTest, CheckCallAutoFillExtensionPermission_001, TestSize.Level1)
1908 {
1909 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1910 TAG_LOGI(AAFwkTag::TEST, "testcase begin.");
1911 abilityRequest_.abilityInfo.visible = true;
1912 abilityRequest_.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::AUTO_FILL_PASSWORD;
1913 abilityRequest_.appInfo.isSystemApp = false;
1914 abilityRequest_.appInfo.bundleName = "test.bundleName";
1915 EXPECT_EQ(abilityMs_->CheckCallAutoFillExtensionPermission(abilityRequest_), CHECK_PERMISSION_FAILED);
1916 TAG_LOGI(AAFwkTag::TEST, "testcase end.");
1917 }
1918
1919 /**
1920 * @tc.name: CheckCallAutoFillExtensionPermission_002
1921 * @tc.desc: Check can't start non-system app when bundleName different.
1922 * @tc.type: FUNC
1923 */
1924 HWTEST_F(AbilityManagerServiceSecondTest, CheckCallAutoFillExtensionPermission_002, TestSize.Level1)
1925 {
1926 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1927 TAG_LOGI(AAFwkTag::TEST, "testcase begin.");
1928 abilityRequest_.abilityInfo.visible = true;
1929 abilityRequest_.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::AUTO_FILL_PASSWORD;
1930 abilityRequest_.appInfo.isSystemApp = true;
1931 abilityRequest_.appInfo.bundleName = "test.bundleName";
1932 EXPECT_EQ(abilityMs_->CheckCallAutoFillExtensionPermission(abilityRequest_), ERR_OK);
1933 TAG_LOGI(AAFwkTag::TEST, "testcase end.");
1934 }
1935 #endif // SUPPORT_AUTO_FILL
1936 } // namespace AAFwk
1937 } // namespace OHOS
1938