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