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