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 CHECK_PERMISSION_FAILED);
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 CHECK_PERMISSION_FAILED);
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), ERR_INVALID_VALUE);
616
617 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
618 EXPECT_EQ(abilityMs_->CloseUIAbilityBySCB(sessionInfo), 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: DisconnectRemoteAbility
685 * SubFunction: NA
686 * FunctionPoints: AbilityManagerService DisconnectRemoteAbility
687 */
688 HWTEST_F(AbilityManagerServiceSecondTest, DisconnectRemoteAbility_001, TestSize.Level1)
689 {
690 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DisconnectRemoteAbility_001 start");
691 auto abilityMs_ = std::make_shared<AbilityManagerService>();
692 EXPECT_EQ(abilityMs_->DisconnectRemoteAbility(nullptr), ERR_NULL_OBJECT);
693 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DisconnectRemoteAbility_001 end");
694 }
695
696 /*
697 * Feature: AbilityManagerService
698 * Function: ContinueMission
699 * SubFunction: NA
700 * FunctionPoints: AbilityManagerService ContinueMission
701 */
702 HWTEST_F(AbilityManagerServiceSecondTest, ContinueMission_001, TestSize.Level1)
703 {
704 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueMission_001 start");
705 auto abilityMs_ = std::make_shared<AbilityManagerService>();
706 std::string srcDeviceId = "test";
707 std::string dstDeviceId = "test";
708 AAFwk::WantParams wantParams;
709 EXPECT_EQ(abilityMs_->ContinueMission(srcDeviceId, dstDeviceId, 1, nullptr, wantParams),
710 CHECK_PERMISSION_FAILED);
711 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueMission_001 end");
712 }
713
714 /*
715 * Feature: AbilityManagerService
716 * Function: ContinueMissionBundleName
717 * SubFunction: NA
718 * FunctionPoints: AbilityManagerService ContinueMissionBundleName
719 */
720 HWTEST_F(AbilityManagerServiceSecondTest, ContinueMissionBundleName_001, TestSize.Level1)
721 {
722 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueMissionBundleName_001 start");
723 auto abilityMs_ = std::make_shared<AbilityManagerService>();
724 std::string srcDeviceId = "";
725 std::string dstDeviceId = "";
726 const sptr<IRemoteObject> callback = nullptr;
727 AAFwk::WantParams wantParams;
728 ContinueMissionInfo continueMissionInfo;
729 continueMissionInfo.dstDeviceId = dstDeviceId;
730 continueMissionInfo.srcDeviceId = srcDeviceId;
731 continueMissionInfo.bundleName = "bundleName";
732 continueMissionInfo.wantParams = wantParams;
733 EXPECT_EQ(abilityMs_->ContinueMission(continueMissionInfo, callback), CHECK_PERMISSION_FAILED);
734 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueMissionBundleName_001 end");
735 }
736
737 /*
738 * Feature: AbilityManagerService
739 * Function: ContinueMissionBundleName
740 * SubFunction: NA
741 * FunctionPoints: AbilityManagerService ContinueMissionBundleName
742 */
743 HWTEST_F(AbilityManagerServiceSecondTest, ContinueMissionBundleName_002, TestSize.Level1)
744 {
745 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueMissionBundleName_002 start");
746 auto abilityMs_ = std::make_shared<AbilityManagerService>();
747 std::string srcDeviceId = "";
748 std::string dstDeviceId = "";
749 const sptr<IRemoteObject> callback = nullptr;
750 AAFwk::WantParams wantParams;
751 ContinueMissionInfo continueMissionInfo;
752 continueMissionInfo.dstDeviceId = dstDeviceId;
753 continueMissionInfo.srcDeviceId = srcDeviceId;
754 continueMissionInfo.bundleName = "";
755 continueMissionInfo.wantParams = wantParams;
756 EXPECT_EQ(abilityMs_->ContinueMission(continueMissionInfo, callback), CHECK_PERMISSION_FAILED);
757 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueMissionBundleName_002 end");
758 }
759
760 /*
761 * Feature: AbilityManagerService
762 * Function: ContinueAbility
763 * SubFunction: NA
764 * FunctionPoints: AbilityManagerService ContinueAbility
765 */
766 HWTEST_F(AbilityManagerServiceSecondTest, ContinueAbility_001, TestSize.Level1)
767 {
768 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueAbility_001 start");
769 auto abilityMs_ = std::make_shared<AbilityManagerService>();
770 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
771 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
772 std::string deviceId = "test";
773 EXPECT_EQ(abilityMs_->ContinueAbility(deviceId, 1, 1), ERR_INVALID_VALUE);
774 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ContinueAbility_001 end");
775 }
776
777 /*
778 * Feature: AbilityManagerService
779 * Function: StartContinuation
780 * SubFunction: NA
781 * FunctionPoints: AbilityManagerService StartContinuation
782 */
783 HWTEST_F(AbilityManagerServiceSecondTest, StartContinuation_001, TestSize.Level1)
784 {
785 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartContinuation_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 Want want;
790 EXPECT_EQ(abilityMs_->StartContinuation(want, nullptr, 1), ERR_INVALID_VALUE);
791 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StartContinuation_001 end");
792 }
793
794 /*
795 * Feature: AbilityManagerService
796 * Function: NotifyCompleteContinuation
797 * SubFunction: NA
798 * FunctionPoints: AbilityManagerService NotifyCompleteContinuation
799 */
800 HWTEST_F(AbilityManagerServiceSecondTest, NotifyCompleteContinuation_001, TestSize.Level1)
801 {
802 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest NotifyCompleteContinuation_001 start");
803 auto abilityMs_ = std::make_shared<AbilityManagerService>();
804 std::string deviceId = "test";
805 ASSERT_NE(abilityMs_, nullptr);
806 abilityMs_->NotifyCompleteContinuation(deviceId, 1, true);
807 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest NotifyCompleteContinuation_001 end");
808 }
809
810 /*
811 * Feature: AbilityManagerService
812 * Function: NotifyContinuationResult
813 * SubFunction: NA
814 * FunctionPoints: AbilityManagerService NotifyContinuationResult
815 */
816 HWTEST_F(AbilityManagerServiceSecondTest, NotifyContinuationResult_001, TestSize.Level1)
817 {
818 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest NotifyContinuationResult_001 start");
819 auto abilityMs_ = std::make_shared<AbilityManagerService>();
820 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
821 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
822 EXPECT_EQ(abilityMs_->NotifyContinuationResult(1, 1), ERR_INVALID_VALUE);
823 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest NotifyContinuationResult_001 end");
824 }
825
826 /*
827 * Feature: AbilityManagerService
828 * Function: StopSyncRemoteMissions
829 * SubFunction: NA
830 * FunctionPoints: AbilityManagerService StopSyncRemoteMissions
831 */
832 HWTEST_F(AbilityManagerServiceSecondTest, StopSyncRemoteMissions_001, TestSize.Level1)
833 {
834 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StopSyncRemoteMissions_001 start");
835 auto abilityMs_ = std::make_shared<AbilityManagerService>();
836 std::string devId = "test";
837 EXPECT_EQ(abilityMs_->StopSyncRemoteMissions(devId), CHECK_PERMISSION_FAILED);
838 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest StopSyncRemoteMissions_001 end");
839 }
840
841 /*
842 * Feature: AbilityManagerService
843 * Function: RegisterObserver
844 * SubFunction: NA
845 * FunctionPoints: AbilityManagerService RegisterObserver
846 */
847 HWTEST_F(AbilityManagerServiceSecondTest, RegisterObserver_001, TestSize.Level1)
848 {
849 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterObserver_001 start");
850 AAFwk::IsMockSaCall::IsMockCheckObserverCallerPermission();
851 auto abilityMs_ = std::make_shared<AbilityManagerService>();
852 abilityMs_->RegisterObserver(nullptr);
853 EXPECT_NE(abilityMs_, nullptr);
854 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterObserver_001 end");
855 }
856
857 /*
858 * Feature: AbilityManagerService
859 * Function: UnregisterObserver
860 * SubFunction: NA
861 * FunctionPoints: AbilityManagerService UnregisterObserver
862 */
863 HWTEST_F(AbilityManagerServiceSecondTest, UnregisterObserver_001, TestSize.Level1)
864 {
865 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnregisterObserver_001 start");
866 AAFwk::IsMockSaCall::IsMockCheckObserverCallerPermission();
867 auto abilityMs_ = std::make_shared<AbilityManagerService>();
868 abilityMs_->UnregisterObserver(nullptr);
869 EXPECT_NE(abilityMs_, nullptr);
870 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnregisterObserver_001 end");
871 }
872
873 /*
874 * Feature: AbilityManagerService
875 * Function: RegisterMissionListener
876 * SubFunction: NA
877 * FunctionPoints: AbilityManagerService RegisterMissionListener
878 */
879 HWTEST_F(AbilityManagerServiceSecondTest, RegisterMissionListener_001, TestSize.Level1)
880 {
881 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterMissionListener_001 start");
882 auto abilityMs_ = std::make_shared<AbilityManagerService>();
883 std::string deviceId = "test";
884 EXPECT_EQ(abilityMs_->RegisterMissionListener(deviceId, nullptr), REGISTER_REMOTE_MISSION_LISTENER_FAIL);
885 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterMissionListener_001 end");
886 }
887
888 /*
889 * Feature: AbilityManagerService
890 * Function: RegisterMissionListener
891 * SubFunction: NA
892 * FunctionPoints: AbilityManagerService RegisterMissionListener
893 */
894 HWTEST_F(AbilityManagerServiceSecondTest, RegisterMissionListener_002, TestSize.Level1)
895 {
896 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterMissionListener_002 start");
897 auto abilityMs_ = std::make_shared<AbilityManagerService>();
898 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
899 auto temp_ = abilityMs_->subManagersHelper_->currentMissionListManager_;
900 abilityMs_->subManagersHelper_->currentMissionListManager_ = nullptr;
901 abilityMs_->RegisterMissionListener(nullptr);
902 EXPECT_TRUE(abilityMs_ != nullptr);
903 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterMissionListener_002 end");
904 }
905
906 /*
907 * Feature: AbilityManagerService
908 * Function: UnRegisterMissionListener
909 * SubFunction: NA
910 * FunctionPoints: AbilityManagerService UnRegisterMissionListener
911 */
912 HWTEST_F(AbilityManagerServiceSecondTest, UnRegisterMissionListener_001, TestSize.Level1)
913 {
914 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnRegisterMissionListener_001 start");
915 auto abilityMs_ = std::make_shared<AbilityManagerService>();
916 std::string deviceId = "test";
917 EXPECT_EQ(abilityMs_->UnRegisterMissionListener(deviceId, nullptr), REGISTER_REMOTE_MISSION_LISTENER_FAIL);
918 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnRegisterMissionListener_001 end");
919 }
920
921 /*
922 * Feature: AbilityManagerService
923 * Function: UnRegisterMissionListener
924 * SubFunction: NA
925 * FunctionPoints: AbilityManagerService UnRegisterMissionListener
926 */
927 HWTEST_F(AbilityManagerServiceSecondTest, UnRegisterMissionListener_002, TestSize.Level1)
928 {
929 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnRegisterMissionListener_002 start");
930 auto abilityMs_ = std::make_shared<AbilityManagerService>();
931 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
932 auto temp_ = abilityMs_->subManagersHelper_->currentMissionListManager_;
933 abilityMs_->subManagersHelper_->currentMissionListManager_ = nullptr;
934 EXPECT_EQ(abilityMs_->UnRegisterMissionListener(nullptr), ERR_NO_INIT);
935 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnRegisterMissionListener_002 end");
936 }
937
938 /*
939 * Feature: AbilityManagerService
940 * Function: GetWantSender
941 * SubFunction: NA
942 * FunctionPoints: AbilityManagerService GetWantSender
943 */
944 HWTEST_F(AbilityManagerServiceSecondTest, GetWantSender_001, TestSize.Level1)
945 {
946 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetWantSender_001 start");
947 auto abilityMs_ = std::make_shared<AbilityManagerService>();
948 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
949 WantSenderInfo wantSenderInfo;
950 auto temp = abilityMs_->subManagersHelper_->currentPendingWantManager_;
951 abilityMs_->subManagersHelper_->currentPendingWantManager_ = nullptr;
952 EXPECT_EQ(abilityMs_->GetWantSender(wantSenderInfo, nullptr), nullptr);
953 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetWantSender_001 end");
954 }
955
956 /*
957 * Feature: AbilityManagerService
958 * Function: SendWantSender
959 * SubFunction: NA
960 * FunctionPoints: AbilityManagerService SendWantSender
961 */
962 HWTEST_F(AbilityManagerServiceSecondTest, SendWantSender_001, TestSize.Level1)
963 {
964 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest SendWantSender_001 start");
965 auto abilityMs_ = std::make_shared<AbilityManagerService>();
966 SenderInfo senderInfo;
967 EXPECT_EQ(abilityMs_->SendWantSender(nullptr, senderInfo), ERR_INVALID_VALUE);
968 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest SendWantSender_001 end");
969 }
970
971 /*
972 * Feature: AbilityManagerService
973 * Function: CancelWantSender
974 * SubFunction: NA
975 * FunctionPoints: AbilityManagerService CancelWantSender
976 */
977 HWTEST_F(AbilityManagerServiceSecondTest, CancelWantSender_001, TestSize.Level1)
978 {
979 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CancelWantSender_001 start");
980 auto abilityMs_ = std::make_shared<AbilityManagerService>();
981 ASSERT_NE(abilityMs_, nullptr);
982 abilityMs_->CancelWantSender(nullptr);
983 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CancelWantSender_001 end");
984 }
985
986 /*
987 * Feature: AbilityManagerService
988 * Function: GetPendingWantUid
989 * SubFunction: NA
990 * FunctionPoints: AbilityManagerService GetPendingWantUid
991 */
992 HWTEST_F(AbilityManagerServiceSecondTest, GetPendingWantUid_001, TestSize.Level1)
993 {
994 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantUid_001 start");
995 auto abilityMs_ = std::make_shared<AbilityManagerService>();
996 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
997 auto temp = abilityMs_->subManagersHelper_->currentPendingWantManager_;
998 abilityMs_->subManagersHelper_->currentPendingWantManager_.reset();
999 EXPECT_EQ(abilityMs_->GetPendingWantUid(nullptr), -1);
1000
1001 abilityMs_->subManagersHelper_->currentPendingWantManager_ = temp;
1002 EXPECT_EQ(abilityMs_->GetPendingWantUid(nullptr), -1);
1003 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantUid_001 end");
1004 }
1005
1006 /*
1007 * Feature: AbilityManagerService
1008 * Function: GetPendingWantUserId
1009 * SubFunction: NA
1010 * FunctionPoints: AbilityManagerService GetPendingWantUserId
1011 */
1012 HWTEST_F(AbilityManagerServiceSecondTest, GetPendingWantUserId_001, TestSize.Level1)
1013 {
1014 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantUserId_001 start");
1015 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1016 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1017 auto temp = abilityMs_->subManagersHelper_->currentPendingWantManager_;
1018 abilityMs_->subManagersHelper_->currentPendingWantManager_.reset();
1019 EXPECT_EQ(abilityMs_->GetPendingWantUserId(nullptr), -1);
1020
1021 abilityMs_->subManagersHelper_->currentPendingWantManager_ = temp;
1022 EXPECT_EQ(abilityMs_->GetPendingWantUserId(nullptr), -1);
1023 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantUserId_001 end");
1024 }
1025
1026 /*
1027 * Feature: AbilityManagerService
1028 * Function: GetPendingWantBundleName
1029 * SubFunction: NA
1030 * FunctionPoints: AbilityManagerService GetPendingWantBundleName
1031 */
1032 HWTEST_F(AbilityManagerServiceSecondTest, GetPendingWantBundleName_001, TestSize.Level1)
1033 {
1034 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantBundleName_001 start");
1035 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1036 EXPECT_EQ(abilityMs_->GetPendingWantBundleName(nullptr), "");
1037 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantBundleName_001 end");
1038 }
1039
1040 /*
1041 * Feature: AbilityManagerService
1042 * Function: GetPendingWantCode
1043 * SubFunction: NA
1044 * FunctionPoints: AbilityManagerService GetPendingWantCode
1045 */
1046 HWTEST_F(AbilityManagerServiceSecondTest, GetPendingWantCode_001, TestSize.Level1)
1047 {
1048 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantCode_001 start");
1049 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1050 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1051 auto temp = abilityMs_->subManagersHelper_->currentPendingWantManager_;
1052 abilityMs_->subManagersHelper_->currentPendingWantManager_.reset();
1053 EXPECT_EQ(abilityMs_->GetPendingWantCode(nullptr), -1);
1054
1055 abilityMs_->subManagersHelper_->currentPendingWantManager_ = temp;
1056 EXPECT_EQ(abilityMs_->GetPendingWantCode(nullptr), -1);
1057 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantCode_001 end");
1058 }
1059
1060 /*
1061 * Feature: AbilityManagerService
1062 * Function: GetPendingWantType
1063 * SubFunction: NA
1064 * FunctionPoints: AbilityManagerService GetPendingWantType
1065 */
1066 HWTEST_F(AbilityManagerServiceSecondTest, GetPendingWantType_001, TestSize.Level1)
1067 {
1068 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantType_001 start");
1069 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1070 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1071 auto temp = abilityMs_->subManagersHelper_->currentPendingWantManager_;
1072 abilityMs_->subManagersHelper_->currentPendingWantManager_.reset();
1073 EXPECT_EQ(abilityMs_->GetPendingWantType(nullptr), -1);
1074
1075 abilityMs_->subManagersHelper_->currentPendingWantManager_ = temp;
1076 EXPECT_EQ(abilityMs_->GetPendingWantType(nullptr), -1);
1077 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingWantType_001 end");
1078 }
1079
1080 /*
1081 * Feature: AbilityManagerService
1082 * Function: RegisterCancelListener
1083 * SubFunction: NA
1084 * FunctionPoints: AbilityManagerService RegisterCancelListener
1085 */
1086 HWTEST_F(AbilityManagerServiceSecondTest, RegisterCancelListener_001, TestSize.Level1)
1087 {
1088 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterCancelListener_001 start");
1089 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1090 ASSERT_NE(abilityMs_, nullptr);
1091 abilityMs_->RegisterCancelListener(nullptr, nullptr);
1092 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest RegisterCancelListener_001 end");
1093 }
1094
1095 /*
1096 * Feature: AbilityManagerService
1097 * Function: UnregisterCancelListener
1098 * SubFunction: NA
1099 * FunctionPoints: AbilityManagerService UnregisterCancelListener
1100 */
1101 HWTEST_F(AbilityManagerServiceSecondTest, UnregisterCancelListener_001, TestSize.Level1)
1102 {
1103 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnregisterCancelListener_001 start");
1104 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1105 ASSERT_NE(abilityMs_, nullptr);
1106 abilityMs_->UnregisterCancelListener(nullptr, nullptr);
1107 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnregisterCancelListener_001 end");
1108 }
1109
1110 /*
1111 * Feature: AbilityManagerService
1112 * Function: GetPendingRequestWant
1113 * SubFunction: NA
1114 * FunctionPoints: AbilityManagerService GetPendingRequestWant
1115 */
1116 HWTEST_F(AbilityManagerServiceSecondTest, GetPendingRequestWant_001, TestSize.Level1)
1117 {
1118 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingRequestWant_001 start");
1119 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1120 std::shared_ptr<Want> want;
1121 EXPECT_EQ(abilityMs_->GetPendingRequestWant(nullptr, want), ERR_INVALID_VALUE);
1122 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetPendingRequestWant_001 end");
1123 }
1124
1125 /*
1126 * Feature: AbilityManagerService
1127 * Function: UnlockMissionForCleanup
1128 * SubFunction: NA
1129 * FunctionPoints: AbilityManagerService UnlockMissionForCleanup
1130 */
1131 HWTEST_F(AbilityManagerServiceSecondTest, UnlockMissionForCleanup_001, TestSize.Level1)
1132 {
1133 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnlockMissionForCleanup_001 start");
1134 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1135 EXPECT_NE(abilityMs_->UnlockMissionForCleanup(1), CHECK_PERMISSION_FAILED);
1136 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UnlockMissionForCleanup_001 end");
1137 }
1138
1139 /*
1140 * Feature: AbilityManagerService
1141 * Function: GetMissionInfos
1142 * SubFunction: NA
1143 * FunctionPoints: AbilityManagerService GetMissionInfos
1144 */
1145 HWTEST_F(AbilityManagerServiceSecondTest, GetMissionInfos_001, TestSize.Level1)
1146 {
1147 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetMissionInfos_001 start");
1148 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1149 std::vector<MissionInfo> missionInfos;
1150 EXPECT_NE(abilityMs_->GetMissionInfos("", 10, missionInfos), CHECK_PERMISSION_FAILED);
1151 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetMissionInfos_001 end");
1152 }
1153
1154 /*
1155 * Feature: AbilityManagerService
1156 * Function: GetRemoteMissionInfos
1157 * SubFunction: NA
1158 * FunctionPoints: AbilityManagerService GetRemoteMissionInfos
1159 */
1160 HWTEST_F(AbilityManagerServiceSecondTest, GetRemoteMissionInfos_001, TestSize.Level1)
1161 {
1162 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetRemoteMissionInfos_001 start");
1163 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1164 std::vector<MissionInfo> missionInfos;
1165 EXPECT_EQ(abilityMs_->GetRemoteMissionInfos("", 10, missionInfos), INVALID_PARAMETERS_ERR);
1166 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetRemoteMissionInfos_001 end");
1167 }
1168
1169 /*
1170 * Feature: AbilityManagerService
1171 * Function: GetMissionInfo
1172 * SubFunction: NA
1173 * FunctionPoints: AbilityManagerService GetMissionInfo
1174 */
1175 HWTEST_F(AbilityManagerServiceSecondTest, GetMissionInfo_001, TestSize.Level1)
1176 {
1177 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetMissionInfo_001 start");
1178 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1179 MissionInfo missionInfo;
1180 EXPECT_NE(abilityMs_->GetMissionInfo("", 10, missionInfo), CHECK_PERMISSION_FAILED);
1181 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetMissionInfo_001 end");
1182 }
1183
1184 /*
1185 * Feature: AbilityManagerService
1186 * Function: GetRemoteMissionInfo
1187 * SubFunction: NA
1188 * FunctionPoints: AbilityManagerService GetRemoteMissionInfo
1189 */
1190 HWTEST_F(AbilityManagerServiceSecondTest, GetRemoteMissionInfo_001, TestSize.Level1)
1191 {
1192 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetRemoteMissionInfo_001 start");
1193 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1194 MissionInfo missionInfo;
1195 EXPECT_EQ(abilityMs_->GetRemoteMissionInfo("", 10, missionInfo), INVALID_PARAMETERS_ERR);
1196 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetRemoteMissionInfo_001 end");
1197 }
1198
1199 /*
1200 * Feature: AbilityManagerService
1201 * Function: CleanMission
1202 * SubFunction: NA
1203 * FunctionPoints: AbilityManagerService CleanMission
1204 */
1205 HWTEST_F(AbilityManagerServiceSecondTest, CleanMission_001, TestSize.Level1)
1206 {
1207 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CleanMission_001 start");
1208 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1209 EXPECT_NE(abilityMs_->CleanMission(1), CHECK_PERMISSION_FAILED);
1210 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CleanMission_001 end");
1211 }
1212
1213 /*
1214 * Feature: AbilityManagerService
1215 * Function: MoveMissionToFront
1216 * SubFunction: NA
1217 * FunctionPoints: AbilityManagerService MoveMissionToFront
1218 */
1219 HWTEST_F(AbilityManagerServiceSecondTest, MoveMissionToFront_001, TestSize.Level1)
1220 {
1221 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionToFront_001 start");
1222 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1223 abilityMs_->MoveMissionToFront(100);
1224 EXPECT_TRUE(abilityMs_ != nullptr);
1225 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionToFront_001 end");
1226 }
1227
1228 /*
1229 * Feature: AbilityManagerService
1230 * Function: MoveMissionToFront
1231 * SubFunction: NA
1232 * FunctionPoints: AbilityManagerService MoveMissionToFront
1233 */
1234 HWTEST_F(AbilityManagerServiceSecondTest, MoveMissionToFront_002, TestSize.Level1)
1235 {
1236 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionToFront_002 start");
1237 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1238 StartOptions startOptions;
1239 EXPECT_EQ(abilityMs_->MoveMissionToFront(100, startOptions), CHECK_PERMISSION_FAILED);
1240 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionToFront_002 end");
1241 }
1242
1243 /*
1244 * Feature: AbilityManagerService
1245 * Function: MoveMissionToFront
1246 * SubFunction: NA
1247 * FunctionPoints: AbilityManagerService MoveMissionToFront
1248 */
1249 HWTEST_F(AbilityManagerServiceSecondTest, MoveMissionToFront_003, TestSize.Level1)
1250 {
1251 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionToFront_003 start");
1252 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1253 EXPECT_TRUE(abilityMs_ != nullptr);
1254 StartOptions startOptions;
1255 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1256 EXPECT_EQ(abilityMs_->MoveMissionToFront(100, startOptions), CHECK_PERMISSION_FAILED);
1257 }
1258 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionToFront_002 end");
1259 }
1260
1261 /*
1262 * Feature: AbilityManagerService
1263 * Function: MoveMissionsToForeground
1264 * SubFunction: NA
1265 * FunctionPoints: AbilityManagerService MoveMissionToFront
1266 */
1267 HWTEST_F(AbilityManagerServiceSecondTest, MoveMissionsToForeground_001, TestSize.Level1)
1268 {
1269 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionsToForeground_001 start");
1270 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1271 EXPECT_EQ(abilityMs_->MoveMissionsToForeground({1, 2, 3}, 1), CHECK_PERMISSION_FAILED);
1272 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionsToForeground_001 end");
1273 }
1274
1275 /*
1276 * Feature: AbilityManagerService
1277 * Function: MoveMissionsToBackground
1278 * SubFunction: NA
1279 * FunctionPoints: AbilityManagerService MoveMissionToFront
1280 */
1281 HWTEST_F(AbilityManagerServiceSecondTest, MoveMissionsToBackground_001, TestSize.Level1)
1282 {
1283 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionsToBackground_001 start");
1284 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1285 std::vector<int32_t> rs;
1286 EXPECT_EQ(abilityMs_->MoveMissionsToBackground({1, 2, 3}, rs), CHECK_PERMISSION_FAILED);
1287 EXPECT_TRUE(rs.empty());
1288 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest MoveMissionsToBackground_001 end");
1289 }
1290
1291 /*
1292 * Feature: AbilityManagerService
1293 * Function: IsAbilityControllerStartById
1294 * SubFunction: NA
1295 * FunctionPoints: AbilityManagerService IsAbilityControllerStartById
1296 */
1297 HWTEST_F(AbilityManagerServiceSecondTest, IsAbilityControllerStartById_001, TestSize.Level1)
1298 {
1299 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsAbilityControllerStartById_001 start");
1300 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1301 EXPECT_TRUE(abilityMs_->IsAbilityControllerStartById(1));
1302 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsAbilityControllerStartById_001 end");
1303 }
1304
1305 /*
1306 * Feature: AbilityManagerService
1307 * Function: GetConnectRecordListByCallback
1308 * SubFunction: NA
1309 * FunctionPoints: AbilityManagerService GetConnectRecordListByCallback
1310 */
1311 HWTEST_F(AbilityManagerServiceSecondTest, GetConnectRecordListByCallback_001, TestSize.Level1)
1312 {
1313 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetConnectRecordListByCallback_001 start");
1314 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1315 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1316 auto temp = abilityMs_->subManagersHelper_->currentConnectManager_;
1317 abilityMs_->subManagersHelper_->currentConnectManager_.reset();
1318 std::list<std::shared_ptr<ConnectionRecord>> connectList;
1319 EXPECT_EQ(abilityMs_->GetConnectRecordListByCallback(nullptr), connectList);
1320 abilityMs_->subManagersHelper_->currentConnectManager_ = temp;
1321 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetConnectRecordListByCallback_001 end");
1322 }
1323
1324 /*
1325 * Feature: AbilityManagerService
1326 * Function: AcquireDataAbility
1327 * SubFunction: NA
1328 * FunctionPoints: AbilityManagerService AcquireDataAbility
1329 */
1330 HWTEST_F(AbilityManagerServiceSecondTest, AcquireDataAbility_001, TestSize.Level1)
1331 {
1332 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest AcquireDataAbility_001 start");
1333 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1334 Uri uri("test");
1335 EXPECT_EQ(abilityMs_->AcquireDataAbility(uri, true, nullptr), nullptr);
1336 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest AcquireDataAbility_001 end");
1337 }
1338
1339 /*
1340 * Feature: AbilityManagerService
1341 * Function: ReleaseDataAbility
1342 * SubFunction: NA
1343 * FunctionPoints: AbilityManagerService ReleaseDataAbility
1344 */
1345 HWTEST_F(AbilityManagerServiceSecondTest, ReleaseDataAbility_001, TestSize.Level1)
1346 {
1347 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ReleaseDataAbility_001 start");
1348 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1349 EXPECT_EQ(abilityMs_->ReleaseDataAbility(nullptr, nullptr), ERR_INVALID_VALUE);
1350 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ReleaseDataAbility_001 end");
1351 }
1352
1353 /*
1354 * Feature: AbilityManagerService
1355 * Function: AttachAbilityThread
1356 * SubFunction: NA
1357 * FunctionPoints: AbilityManagerService AttachAbilityThread
1358 */
1359 HWTEST_F(AbilityManagerServiceSecondTest, AttachAbilityThread_001, TestSize.Level1)
1360 {
1361 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest AttachAbilityThread_001 start");
1362 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1363 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1364 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
1365 EXPECT_EQ(abilityMs_->AttachAbilityThread(nullptr, nullptr), ERR_INVALID_VALUE);
1366 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest AttachAbilityThread_001 end");
1367 }
1368
1369 /*
1370 * Feature: AbilityManagerService
1371 * Function: DumpInner
1372 * SubFunction: NA
1373 * FunctionPoints: AbilityManagerService DumpInner
1374 */
1375 HWTEST_F(AbilityManagerServiceSecondTest, DumpInner_001, TestSize.Level1)
1376 {
1377 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpInner_001 start");
1378 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1379 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1380 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
1381 std::vector<std::string> info;
1382 ASSERT_NE(abilityMs_, nullptr);
1383 abilityMs_->DumpInner("", info);
1384 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpInner_001 end");
1385 }
1386
1387 /*
1388 * Feature: AbilityManagerService
1389 * Function: DumpMissionListInner
1390 * SubFunction: NA
1391 * FunctionPoints: AbilityManagerService DumpMissionListInner
1392 */
1393 HWTEST_F(AbilityManagerServiceSecondTest, DumpMissionListInner_001, TestSize.Level1)
1394 {
1395 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpMissionListInner_001 start");
1396 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1397 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1398 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
1399 std::vector<std::string> info;
1400 ASSERT_NE(abilityMs_, nullptr);
1401 abilityMs_->DumpMissionListInner("", info);
1402 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpMissionListInner_001 end");
1403 }
1404
1405 /*
1406 * Feature: AbilityManagerService
1407 * Function: DumpMissionInfosInner
1408 * SubFunction: NA
1409 * FunctionPoints: AbilityManagerService DumpMissionInfosInner
1410 */
1411 HWTEST_F(AbilityManagerServiceSecondTest, DumpMissionInfosInner_001, TestSize.Level1)
1412 {
1413 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpMissionInfosInner_001 start");
1414 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1415 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1416 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
1417 std::vector<std::string> info;
1418 ASSERT_NE(abilityMs_, nullptr);
1419 abilityMs_->DumpMissionInfosInner("", info);
1420 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpMissionInfosInner_001 end");
1421 }
1422
1423 /*
1424 * Feature: AbilityManagerService
1425 * Function: SetResidentProcessEnabled
1426 * SubFunction: NA
1427 * FunctionPoints: AbilityManagerService SetResidentProcessEnabled
1428 */
1429 HWTEST_F(AbilityManagerServiceSecondTest, SetResidentProcessEnable_001, TestSize.Level1)
1430 {
1431 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1432 std::string bundleName = "ability.manager.service.test";
1433 bool enable = false;
1434 abilityMs_->SetResidentProcessEnabled(bundleName, enable);
1435 ASSERT_NE(abilityMs_, nullptr);
1436 }
1437
1438 /*
1439 * Feature: AbilityManagerService
1440 * Function: DumpMissionInner
1441 * SubFunction: NA
1442 * FunctionPoints: AbilityManagerService DumpMissionInner
1443 */
1444 HWTEST_F(AbilityManagerServiceSecondTest, DumpMissionInner_001, TestSize.Level1)
1445 {
1446 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpMissionInner_001 start");
1447 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1448 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1449 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
1450 std::vector<std::string> info;
1451 ASSERT_NE(abilityMs_, nullptr);
1452 abilityMs_->DumpMissionInner("", info);
1453 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpMissionInner_001 end");
1454 }
1455
1456 /*
1457 * Feature: AbilityManagerService
1458 * Function: DumpStateInner
1459 * SubFunction: NA
1460 * FunctionPoints: AbilityManagerService DumpStateInner
1461 */
1462 HWTEST_F(AbilityManagerServiceSecondTest, DumpStateInner_001, TestSize.Level1)
1463 {
1464 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpStateInner_001 start");
1465 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1466 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1467 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
1468 std::vector<std::string> info;
1469 ASSERT_NE(abilityMs_, nullptr);
1470 abilityMs_->DumpStateInner("", info);
1471 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpStateInner_001 end");
1472 }
1473
1474 /*
1475 * Feature: AbilityManagerService
1476 * Function: DataDumpStateInner
1477 * SubFunction: NA
1478 * FunctionPoints: AbilityManagerService DataDumpStateInner
1479 */
1480 HWTEST_F(AbilityManagerServiceSecondTest, DataDumpStateInner_001, TestSize.Level1)
1481 {
1482 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DataDumpStateInner_001 start");
1483 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1484 std::vector<std::string> info;
1485 ASSERT_NE(abilityMs_, nullptr);
1486 abilityMs_->DataDumpStateInner("", info);
1487 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DataDumpStateInner_001 end");
1488 }
1489
1490 /*
1491 * Feature: AbilityManagerService
1492 * Function: DumpState
1493 * SubFunction: NA
1494 * FunctionPoints: AbilityManagerService DumpState
1495 */
1496 HWTEST_F(AbilityManagerServiceSecondTest, DumpState_001, TestSize.Level1)
1497 {
1498 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpState_001 start");
1499 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1500 std::vector<std::string> info;
1501 ASSERT_NE(abilityMs_, nullptr);
1502 abilityMs_->DumpState("", info);
1503 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpState_001 end");
1504 }
1505
1506 /*
1507 * Feature: AbilityManagerService
1508 * Function: DumpSysState
1509 * SubFunction: NA
1510 * FunctionPoints: AbilityManagerService DumpSysState
1511 */
1512 HWTEST_F(AbilityManagerServiceSecondTest, DumpSysState_001, TestSize.Level1)
1513 {
1514 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpSysState_001 start");
1515 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1516 std::vector<std::string> info;
1517 ASSERT_NE(abilityMs_, nullptr);
1518 abilityMs_->DumpSysState("", info, true, true, 100);
1519 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest DumpSysState_001 end");
1520 }
1521
1522 /*
1523 * Feature: AbilityManagerService
1524 * Function: AbilityTransitionDone
1525 * SubFunction: NA
1526 * FunctionPoints: AbilityManagerService AbilityTransitionDone
1527 */
1528 HWTEST_F(AbilityManagerServiceSecondTest, AbilityTransitionDone_001, TestSize.Level1)
1529 {
1530 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest AbilityTransitionDone_001 start");
1531 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1532 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
1533 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
1534 PacMap saveData;
1535 EXPECT_EQ(abilityMs_->AbilityTransitionDone(nullptr, 1, saveData), ERR_INVALID_VALUE);
1536 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest AbilityTransitionDone_001 end");
1537 }
1538
1539 /*
1540 * Feature: AbilityManagerService
1541 * Function: OnAppStateChanged
1542 * SubFunction: NA
1543 * FunctionPoints: AbilityManagerService OnAppStateChanged
1544 */
1545 HWTEST_F(AbilityManagerServiceSecondTest, OnAppStateChanged_001, TestSize.Level1)
1546 {
1547 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest OnAppStateChanged_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 AppInfo info;
1552 ASSERT_NE(abilityMs_, nullptr);
1553 abilityMs_->OnAppStateChanged(info);
1554 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest OnAppStateChanged_001 end");
1555 }
1556
1557 /*
1558 * Feature: AbilityManagerService
1559 * Function: GetTaskHandler
1560 * SubFunction: NA
1561 * FunctionPoints: AbilityManagerService GetTaskHandler
1562 */
1563 HWTEST_F(AbilityManagerServiceSecondTest, GetTaskHandler_001, TestSize.Level1)
1564 {
1565 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetTaskHandler_001 start");
1566 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1567 ASSERT_NE(abilityMs_, nullptr);
1568 EXPECT_EQ(abilityMs_->GetTaskHandler(), nullptr);
1569 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetTaskHandler_001 end");
1570 }
1571
1572 /*
1573 * Feature: AbilityManagerService
1574 * Function: GetEventHandler
1575 * SubFunction: NA
1576 * FunctionPoints: AbilityManagerService GetEventHandler
1577 */
1578 HWTEST_F(AbilityManagerServiceSecondTest, GetEventHandler_001, TestSize.Level1)
1579 {
1580 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetEventHandler_001 start");
1581 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1582 ASSERT_NE(abilityMs_, nullptr);
1583 EXPECT_EQ(abilityMs_->GetEventHandler(), nullptr);
1584 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetEventHandler_001 end");
1585 }
1586
1587 /*
1588 * Feature: AbilityManagerService
1589 * Function: GetUserId
1590 * SubFunction: NA
1591 * FunctionPoints: AbilityManagerService GetUserId
1592 */
1593 HWTEST_F(AbilityManagerServiceSecondTest, GetUserId_001, TestSize.Level1)
1594 {
1595 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetUserId_001 start");
1596 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1597 EXPECT_NE(abilityMs_->GetUserId(), 100);
1598 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GetUserId_001 end");
1599 }
1600
1601 /*
1602 * Feature: AbilityManagerService
1603 * Function: GenerateAbilityRequest
1604 * SubFunction: NA
1605 * FunctionPoints: AbilityManagerService GenerateAbilityRequest
1606 */
1607 HWTEST_F(AbilityManagerServiceSecondTest, GenerateAbilityRequest_001, TestSize.Level1)
1608 {
1609 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GenerateAbilityRequest_001 start");
1610 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1611 Want want;
1612 AbilityRequest request;
1613 EXPECT_EQ(abilityMs_->GenerateAbilityRequest(want, 1, request, nullptr, 100), RESOLVE_ABILITY_ERR);
1614 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GenerateAbilityRequest_001 end");
1615 }
1616
1617 /*
1618 * Feature: AbilityManagerService
1619 * Function: GenerateExtensionAbilityRequest
1620 * SubFunction: NA
1621 * FunctionPoints: AbilityManagerService GenerateExtensionAbilityRequest
1622 */
1623 HWTEST_F(AbilityManagerServiceSecondTest, GenerateExtensionAbilityRequest_001, TestSize.Level1)
1624 {
1625 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GenerateExtensionAbilityRequest_001 start");
1626 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1627 Want want;
1628 AbilityRequest request;
1629 EXPECT_EQ(abilityMs_->GenerateExtensionAbilityRequest(want, request, nullptr, 100), RESOLVE_ABILITY_ERR);
1630 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest GenerateExtensionAbilityRequest_001 end");
1631 }
1632
1633 /*
1634 * Feature: AbilityManagerService
1635 * Function: KillProcess
1636 * SubFunction: NA
1637 * FunctionPoints: AbilityManagerService KillProcess
1638 */
1639 HWTEST_F(AbilityManagerServiceSecondTest, KillProcess_001, TestSize.Level1)
1640 {
1641 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest KillProcess_001 start");
1642 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1643 EXPECT_EQ(abilityMs_->KillProcess("test"), GET_BUNDLE_INFO_FAILED);
1644 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest KillProcess_001 end");
1645 }
1646
1647 /*
1648 * Feature: AbilityManagerService
1649 * Function: PreLoadAppDataAbilities
1650 * SubFunction: NA
1651 * FunctionPoints: AbilityManagerService PreLoadAppDataAbilities
1652 */
1653 HWTEST_F(AbilityManagerServiceSecondTest, PreLoadAppDataAbilities_001, TestSize.Level1)
1654 {
1655 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest PreLoadAppDataAbilities_001 start");
1656 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1657 EXPECT_EQ(abilityMs_->PreLoadAppDataAbilities("", 100), ERR_INVALID_VALUE);
1658 EXPECT_EQ(abilityMs_->PreLoadAppDataAbilities("test", -1), ERR_INVALID_STATE);
1659 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest PreLoadAppDataAbilities_001 end");
1660 }
1661
1662 /*
1663 * Feature: AbilityManagerService
1664 * Function: IsSystemUiApp
1665 * SubFunction: NA
1666 * FunctionPoints: AbilityManagerService IsSystemUiApp
1667 */
1668 HWTEST_F(AbilityManagerServiceSecondTest, IsSystemUiApp_001, TestSize.Level1)
1669 {
1670 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsSystemUiApp_001 start");
1671 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1672 AppExecFwk::AbilityInfo info;
1673 info.bundleName = "bundleName";
1674 EXPECT_FALSE(abilityMs_->IsSystemUiApp(info));
1675
1676 info.bundleName = AbilityConfig::SYSTEM_UI_BUNDLE_NAME;
1677 info.name = "test";
1678 EXPECT_FALSE(abilityMs_->IsSystemUiApp(info));
1679
1680 info.name = AbilityConfig::SYSTEM_UI_NAVIGATION_BAR;
1681 EXPECT_TRUE(abilityMs_->IsSystemUiApp(info));
1682
1683 info.name = AbilityConfig::SYSTEM_UI_STATUS_BAR;
1684 EXPECT_TRUE(abilityMs_->IsSystemUiApp(info));
1685
1686 info.name = AbilityConfig::SYSTEM_UI_ABILITY_NAME;
1687 EXPECT_TRUE(abilityMs_->IsSystemUiApp(info));
1688 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsSystemUiApp_001 end");
1689 }
1690
1691 /*
1692 * Feature: AbilityManagerService
1693 * Function: IsSystemUI
1694 * SubFunction: NA
1695 * FunctionPoints: AbilityManagerService IsSystemUI
1696 */
1697 HWTEST_F(AbilityManagerServiceSecondTest, IsSystemUI_001, TestSize.Level1)
1698 {
1699 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsSystemUI_001 start");
1700 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1701 std::string bundleName = "bundleName";
1702 EXPECT_FALSE(abilityMs_->IsSystemUI(bundleName));
1703
1704 bundleName = AbilityConfig::SYSTEM_UI_BUNDLE_NAME;
1705 EXPECT_TRUE(abilityMs_->IsSystemUI(bundleName));
1706 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsSystemUI_001 end");
1707 }
1708
1709 /*
1710 * Feature: AbilityManagerService
1711 * Function: CheckSenderWantInfo
1712 * SubFunction: NA
1713 * FunctionPoints: AbilityManagerService CheckSenderWantInfo
1714 */
1715 HWTEST_F(AbilityManagerServiceSecondTest, CheckSenderWantInfo_001, TestSize.Level1)
1716 {
1717 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckSenderWantInfo_001 start");
1718 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1719 WantSenderInfo wantSenderInfo;
1720 wantSenderInfo.bundleName = "badeName";
1721 int32_t callerUid = 0;
1722 EXPECT_TRUE(abilityMs_->CheckSenderWantInfo(callerUid, wantSenderInfo));
1723 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest CheckSenderWantInfo_001 end");
1724 }
1725
1726 /*
1727 * Feature: AbilityManagerService
1728 * Function: ParseJsonFromBoot
1729 * SubFunction: NA
1730 * FunctionPoints: AbilityManagerService ParseJsonFromBoot
1731 */
1732 HWTEST_F(AbilityManagerServiceSecondTest, ParseJsonFromBoot_001, TestSize.Level1)
1733 {
1734 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ParseJsonFromBoot_001 start");
1735 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1736 const std::string file = "/etc/efficiency_manager/prevent_startability_whitelist.json";
1737 nlohmann::json whiteListJsonObj;
1738 abilityMs_->ParseJsonFromBoot(file);
1739 EXPECT_TRUE(abilityMs_ != nullptr);
1740 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ParseJsonFromBoot_001 end");
1741 }
1742
1743 /*
1744 * Feature: AbilityManagerService
1745 * Function: IsInWhiteList
1746 * SubFunction: NA
1747 * FunctionPoints: AbilityManagerService IsInWhiteList
1748 */
1749 HWTEST_F(AbilityManagerServiceSecondTest, IsInWhiteList_001, TestSize.Level1)
1750 {
1751 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsInWhiteList_001 start");
1752 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1753 const std::string callerBundleName = "com.example.amstest";
1754 const std::string calleeBundleName = "com.exmple.testserviceextensionability";
1755 const std::string calleeAbilityName = "ServiceextensionAbility";
1756 abilityMs_->IsInWhiteList(callerBundleName, calleeBundleName, calleeAbilityName);
1757 EXPECT_TRUE(abilityMs_ != nullptr);
1758 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest IsInWhiteList_001 end");
1759 }
1760
1761 /*
1762 * Feature: AbilityManagerService
1763 * Function: ShouldPreventStartAbility
1764 * SubFunction: NA
1765 * FunctionPoints: AbilityManagerService ShouldPreventStartAbility
1766 */
1767 HWTEST_F(AbilityManagerServiceSecondTest, ShouldPreventStartAbility_001, TestSize.Level1)
1768 {
1769 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ShouldPreventStartAbility_001 start");
1770 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1771 const std::string deviceName = "";
1772 const std::string abilityName = "EntryAbility";
1773 const std::string appName = "amstest";
1774 const std::string bundleName = "com.example.amstest";
1775 const std::string moduleName = "entry";
1776 AbilityRequest abilityRequest = AbilityManagerServiceSecondTest::GenerateAbilityRequest(deviceName,
1777 abilityName, appName, bundleName, moduleName);
1778 EXPECT_FALSE(abilityMs_->ShouldPreventStartAbility(abilityRequest));
1779 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest ShouldPreventStartAbility_001 end");
1780 }
1781
1782 /*
1783 * Feature: AbilityManagerService
1784 * Name: UpdateKeepAliveEnableState_001
1785 * Function: CheckProcessOptions
1786 * SubFunction: NA
1787 * FunctionPoints: AbilityManagerService UpdateKeepAliveEnableState
1788 */
1789 HWTEST_F(AbilityManagerServiceSecondTest, UpdateKeepAliveEnableState_001, TestSize.Level1)
1790 {
1791 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UpdateKeepAliveEnableState_001 start");
1792 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1793 EXPECT_NE(abilityMs_, nullptr);
1794 auto ret = abilityMs_->UpdateKeepAliveEnableState("bundle", "entry", "mainAbility", true, 0);
1795 EXPECT_NE(ret, ERR_OK);
1796 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceSecondTest UpdateKeepAliveEnableState_001 end");
1797 }
1798
1799 /**
1800 * @tc.name: CheckCallAutoFillExtensionPermission_001
1801 * @tc.desc: Check can't start non-system app when extension type is AUTO_FILL_PASSWORD.
1802 * @tc.type: FUNC
1803 */
1804 HWTEST_F(AbilityManagerServiceSecondTest, CheckCallAutoFillExtensionPermission_001, TestSize.Level1)
1805 {
1806 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1807 TAG_LOGI(AAFwkTag::TEST, "testcase begin.");
1808 abilityRequest_.abilityInfo.visible = true;
1809 abilityRequest_.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::AUTO_FILL_PASSWORD;
1810 abilityRequest_.appInfo.isSystemApp = false;
1811 abilityRequest_.appInfo.bundleName = "test.bundleName";
1812 EXPECT_EQ(abilityMs_->CheckCallAutoFillExtensionPermission(abilityRequest_), CHECK_PERMISSION_FAILED);
1813 TAG_LOGI(AAFwkTag::TEST, "testcase end.");
1814 }
1815
1816 /**
1817 * @tc.name: CheckCallAutoFillExtensionPermission_002
1818 * @tc.desc: Check can't start non-system app when bundleName different.
1819 * @tc.type: FUNC
1820 */
1821 HWTEST_F(AbilityManagerServiceSecondTest, CheckCallAutoFillExtensionPermission_002, TestSize.Level1)
1822 {
1823 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1824 TAG_LOGI(AAFwkTag::TEST, "testcase begin.");
1825 abilityRequest_.abilityInfo.visible = true;
1826 abilityRequest_.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::AUTO_FILL_PASSWORD;
1827 abilityRequest_.appInfo.isSystemApp = true;
1828 abilityRequest_.appInfo.bundleName = "test.bundleName";
1829 EXPECT_EQ(abilityMs_->CheckCallAutoFillExtensionPermission(abilityRequest_), ERR_OK);
1830 TAG_LOGI(AAFwkTag::TEST, "testcase end.");
1831 }
1832 } // namespace AAFwk
1833 } // namespace OHOS
1834