1 /*
2 * Copyright (c) 2023 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_bundle_event_callback.h"
29 #include "ability_manager_errors.h"
30 #include "ability_manager_stub_mock_test.h"
31 #include "ability_info.h"
32 #include "connection_observer_errors.h"
33 #include "free_install_manager.h"
34 #include "hilog_tag_wrapper.h"
35 #include "mock_sa_call.h"
36 #include "session/host/include/session.h"
37 #include "scene_board_judgement.h"
38 #include "system_ability_definition.h"
39 #include "uri.h"
40
41 using namespace testing;
42 using namespace testing::ext;
43 using namespace OHOS::AppExecFwk;
44 using OHOS::AppExecFwk::AbilityType;
45 using OHOS::AppExecFwk::ExtensionAbilityType;
46 namespace OHOS {
47 namespace AAFwk {
48 namespace {
49 const int32_t USER_ID_U100 = 100;
50 const int32_t APP_MEMORY_SIZE = 512;
51 const uint32_t TOKENID = 211;
52 const std::string EMPTY_DEVICE_ID = "";
53 const std::string SESSIONID = "sessionId";
54 const std::string APPID = "1003";
55 const int REQUESTCODE = 10;
56 } // namespace
57 class AbilityManagerServiceThirdTest : public testing::Test {
58 public:
59 static void SetUpTestCase();
60 static void TearDownTestCase();
61 std::shared_ptr<AbilityRecord> MockAbilityRecord(AbilityType);
62 sptr<Token> MockToken(AbilityType);
63 void SetUp();
64 void TearDown();
65
66 AbilityRequest GenerateAbilityRequest(const std::string& deviceName, const std::string& abilityName,
67 const std::string& appName, const std::string& bundleName, const std::string& moduleName);
68 public:
69 AbilityRequest abilityRequest_{};
70 Want want_{};
71 };
72
GenerateAbilityRequest(const std::string & deviceName,const std::string & abilityName,const std::string & appName,const std::string & bundleName,const std::string & moduleName)73 AbilityRequest AbilityManagerServiceThirdTest::GenerateAbilityRequest(const std::string& deviceName,
74 const std::string& abilityName, const std::string& appName, const std::string& bundleName,
75 const std::string& moduleName)
76 {
77 ElementName element(deviceName, bundleName, abilityName, moduleName);
78 want_.SetElement(element);
79
80 AbilityInfo abilityInfo;
81 abilityInfo.visible = true;
82 abilityInfo.applicationName = appName;
83 abilityInfo.type = AbilityType::EXTENSION;
84 abilityInfo.name = abilityName;
85 abilityInfo.bundleName = bundleName;
86 abilityInfo.moduleName = moduleName;
87 abilityInfo.deviceId = deviceName;
88 ApplicationInfo appinfo;
89 appinfo.name = appName;
90 appinfo.bundleName = bundleName;
91 abilityInfo.applicationInfo = appinfo;
92 AbilityRequest abilityRequest;
93 abilityRequest.want = want_;
94 abilityRequest.abilityInfo = abilityInfo;
95 abilityRequest.appInfo = appinfo;
96
97 return abilityRequest;
98 }
99
SetUpTestCase()100 void AbilityManagerServiceThirdTest::SetUpTestCase() {}
101
TearDownTestCase()102 void AbilityManagerServiceThirdTest::TearDownTestCase() {}
103
SetUp()104 void AbilityManagerServiceThirdTest::SetUp() {}
105
TearDown()106 void AbilityManagerServiceThirdTest::TearDown() {}
107
MockAbilityRecord(AbilityType abilityType)108 std::shared_ptr<AbilityRecord> AbilityManagerServiceThirdTest::MockAbilityRecord(AbilityType abilityType)
109 {
110 AbilityRequest abilityRequest;
111 abilityRequest.appInfo.bundleName = "com.test.demo";
112 abilityRequest.abilityInfo.name = "MainAbility";
113 abilityRequest.abilityInfo.type = abilityType;
114 return AbilityRecord::CreateAbilityRecord(abilityRequest);
115 }
116
MockToken(AbilityType abilityType)117 sptr<Token> AbilityManagerServiceThirdTest::MockToken(AbilityType abilityType)
118 {
119 std::shared_ptr<AbilityRecord> abilityRecord = MockAbilityRecord(abilityType);
120 if (!abilityRecord) {
121 return nullptr;
122 }
123 return abilityRecord->GetToken();
124 }
125
126 /*
127 * Feature: AbilityManagerService
128 * Function: HandleActiveTimeOut
129 * SubFunction: NA
130 * FunctionPoints: AbilityManagerService HandleActiveTimeOut
131 */
132 HWTEST_F(AbilityManagerServiceThirdTest, HandleActiveTimeOut_001, TestSize.Level1)
133 {
134 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest HandleActiveTimeOut_001 start");
135 auto abilityMs_ = std::make_shared<AbilityManagerService>();
136 ASSERT_NE(abilityMs_, nullptr);
137 abilityMs_->HandleActiveTimeOut(100);
138 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest HandleActiveTimeOut_001 end");
139 }
140
141 /*
142 * Feature: AbilityManagerService
143 * Function: HandleInactiveTimeOut
144 * SubFunction: NA
145 * FunctionPoints: AbilityManagerService HandleInactiveTimeOut
146 */
147 HWTEST_F(AbilityManagerServiceThirdTest, HandleInactiveTimeOut_001, TestSize.Level1)
148 {
149 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest HandleInactiveTimeOut_001 start");
150 auto abilityMs_ = std::make_shared<AbilityManagerService>();
151 ASSERT_NE(abilityMs_, nullptr);
152 abilityMs_->HandleInactiveTimeOut(100);
153 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest HandleInactiveTimeOut_001 end");
154 }
155
156 /*
157 * Feature: AbilityManagerService
158 * Function: VerificationToken
159 * SubFunction: NA
160 * FunctionPoints: AbilityManagerService VerificationToken
161 */
162 HWTEST_F(AbilityManagerServiceThirdTest, VerificationToken_001, TestSize.Level1)
163 {
164 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest VerificationToken_001 start");
165 auto abilityMs_ = std::make_shared<AbilityManagerService>();
166 EXPECT_FALSE(abilityMs_->VerificationToken(nullptr));
167 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest VerificationToken_001 end");
168 }
169
170 /*
171 * Feature: AbilityManagerService
172 * Function: VerificationAllToken
173 * SubFunction: NA
174 * FunctionPoints: AbilityManagerService VerificationAllToken
175 */
176 HWTEST_F(AbilityManagerServiceThirdTest, VerificationAllToken_001, TestSize.Level1)
177 {
178 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest VerificationAllToken_001 start");
179 auto abilityMs_ = std::make_shared<AbilityManagerService>();
180 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
181 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
182 EXPECT_FALSE(abilityMs_->VerificationAllToken(nullptr));
183 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest VerificationAllToken_001 end");
184 }
185
186 /*
187 * Feature: AbilityManagerService
188 * Function: GetDataAbilityManager
189 * SubFunction: NA
190 * FunctionPoints: AbilityManagerService GetDataAbilityManager
191 */
192 HWTEST_F(AbilityManagerServiceThirdTest, GetDataAbilityManager_001, TestSize.Level1)
193 {
194 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetDataAbilityManager_001 start");
195 auto abilityMs_ = std::make_shared<AbilityManagerService>();
196 EXPECT_EQ(abilityMs_->GetDataAbilityManager(nullptr), nullptr);
197 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetDataAbilityManager_001 end");
198 }
199
200 /*
201 * Feature: AbilityManagerService
202 * Function: GetMissionListManagerByUserId
203 * SubFunction: NA
204 * FunctionPoints: AbilityManagerService GetMissionListManagerByUserId
205 */
206 HWTEST_F(AbilityManagerServiceThirdTest, GetListManagerByUserId_001, TestSize.Level1)
207 {
208 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetListManagerByUserId_001 start");
209 auto abilityMs_ = std::make_shared<AbilityManagerService>();
210 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
211 EXPECT_EQ(abilityMs_->GetMissionListManagerByUserId(100), nullptr);
212
213 auto temp = abilityMs_->subManagersHelper_->missionListManagers_;
214 abilityMs_->subManagersHelper_->missionListManagers_.clear();
215 EXPECT_EQ(abilityMs_->GetMissionListManagerByUserId(100).get(), nullptr);
216 abilityMs_->subManagersHelper_->missionListManagers_ = temp;
217 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetListManagerByUserId_001 end");
218 }
219
220 /*
221 * Feature: AbilityManagerService
222 * Function: GetDataAbilityManagerByUserId
223 * SubFunction: NA
224 * FunctionPoints: AbilityManagerService GetDataAbilityManagerByUserId
225 */
226 HWTEST_F(AbilityManagerServiceThirdTest, GetDataAbilityManagerByUserId_001, TestSize.Level1)
227 {
228 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetDataAbilityManagerByUserId_001 start");
229 auto abilityMs_ = std::make_shared<AbilityManagerService>();
230 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
231 EXPECT_EQ(abilityMs_->GetDataAbilityManagerByUserId(100), nullptr);
232
233 auto temp = abilityMs_->subManagersHelper_->dataAbilityManagers_;
234 abilityMs_->subManagersHelper_->dataAbilityManagers_.clear();
235 EXPECT_EQ(abilityMs_->GetDataAbilityManagerByUserId(100).get(), nullptr);
236 abilityMs_->subManagersHelper_->dataAbilityManagers_ = temp;
237 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetDataAbilityManagerByUserId_001 end");
238 }
239
240 /*
241 * Feature: AbilityManagerService
242 * Function: GetConnectManagerByToken
243 * SubFunction: NA
244 * FunctionPoints: AbilityManagerService GetConnectManagerByToken
245 */
246 HWTEST_F(AbilityManagerServiceThirdTest, GetConnectManagerByToken_001, TestSize.Level1)
247 {
248 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetConnectManagerByToken_001 start");
249 auto abilityMs_ = std::make_shared<AbilityManagerService>();
250 EXPECT_EQ(abilityMs_->GetConnectManagerByToken(nullptr), nullptr);
251 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetConnectManagerByToken_001 end");
252 }
253
254 /*
255 * Feature: AbilityManagerService
256 * Function: GetDataAbilityManagerByToken
257 * SubFunction: NA
258 * FunctionPoints: AbilityManagerService GetDataAbilityManagerByToken
259 */
260 HWTEST_F(AbilityManagerServiceThirdTest, GetDataAbilityManagerByToken_001, TestSize.Level1)
261 {
262 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetDataAbilityManagerByToken_001 start");
263 auto abilityMs_ = std::make_shared<AbilityManagerService>();
264 EXPECT_EQ(abilityMs_->GetDataAbilityManagerByToken(nullptr), nullptr);
265 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetDataAbilityManagerByToken_001 end");
266 }
267
268 /*
269 * Feature: AbilityManagerService
270 * Function: ConnectServices
271 * SubFunction: NA
272 * FunctionPoints: AbilityManagerService ConnectServices
273 */
274 HWTEST_F(AbilityManagerServiceThirdTest, ConnectServices_001, TestSize.Level1)
275 {
276 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest ConnectServices_001 start");
277 auto abilityMs_ = std::make_shared<AbilityManagerService>();
278 ASSERT_NE(abilityMs_, nullptr);
279 abilityMs_->ConnectServices();
280 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest ConnectServices_001 end");
281 }
282
283 /*
284 * Feature: AbilityManagerService
285 * Function: GetWantSenderInfo
286 * SubFunction: NA
287 * FunctionPoints: AbilityManagerService GetWantSenderInfo
288 */
289 HWTEST_F(AbilityManagerServiceThirdTest, GetWantSenderInfo_001, TestSize.Level1)
290 {
291 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetWantSenderInfo_001 start");
292 auto abilityMs_ = std::make_shared<AbilityManagerService>();
293 std::shared_ptr<WantSenderInfo> info;
294 EXPECT_EQ(abilityMs_->GetWantSenderInfo(nullptr, info), ERR_INVALID_VALUE);
295 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetWantSenderInfo_001 end");
296 }
297
298 /*
299 * Feature: AbilityManagerService
300 * Function: GetAppMemorySize
301 * SubFunction: NA
302 * FunctionPoints: AbilityManagerService GetAppMemorySize
303 */
304 HWTEST_F(AbilityManagerServiceThirdTest, GetAppMemorySize_001, TestSize.Level1)
305 {
306 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetAppMemorySize_001 start");
307 auto abilityMs_ = std::make_shared<AbilityManagerService>();
308 EXPECT_EQ(abilityMs_->GetAppMemorySize(), APP_MEMORY_SIZE);
309 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetAppMemorySize_001 end");
310 }
311
312 /*
313 * Feature: AbilityManagerService
314 * Function: IsRamConstrainedDevice
315 * SubFunction: NA
316 * FunctionPoints: AbilityManagerService IsRamConstrainedDevice
317 */
318 HWTEST_F(AbilityManagerServiceThirdTest, IsRamConstrainedDevice_001, TestSize.Level1)
319 {
320 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest IsRamConstrainedDevice_001 start");
321 auto abilityMs_ = std::make_shared<AbilityManagerService>();
322 EXPECT_FALSE(abilityMs_->IsRamConstrainedDevice());
323 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest IsRamConstrainedDevice_001 end");
324 }
325
326 /*
327 * Feature: AbilityManagerService
328 * Function: GetMissionSaveTime
329 * SubFunction: NA
330 * FunctionPoints: AbilityManagerService GetMissionSaveTime
331 */
332 HWTEST_F(AbilityManagerServiceThirdTest, GetMissionSaveTime_001, TestSize.Level1)
333 {
334 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetMissionSaveTime_001 start");
335 auto abilityMs_ = std::make_shared<AbilityManagerService>();
336 EXPECT_NE(AmsConfigurationParameter::GetInstance().GetMissionSaveTime(), 0);
337 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetMissionSaveTime_001 end");
338 }
339
340 /*
341 * Feature: AbilityManagerService
342 * Function: GetAbilityTokenByMissionId
343 * SubFunction: NA
344 * FunctionPoints: AbilityManagerService GetAbilityTokenByMissionId
345 */
346 HWTEST_F(AbilityManagerServiceThirdTest, GetAbilityTokenByMissionId_001, TestSize.Level1)
347 {
348 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetAbilityTokenByMissionId_001 start");
349 auto abilityMs_ = std::make_shared<AbilityManagerService>();
350 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
351 EXPECT_EQ(abilityMs_->GetAbilityTokenByMissionId(100), nullptr);
352
353 auto temp = abilityMs_->subManagersHelper_->currentMissionListManager_;
354 abilityMs_->subManagersHelper_->currentMissionListManager_.reset();
355 EXPECT_EQ(abilityMs_->GetAbilityTokenByMissionId(100), nullptr);
356 abilityMs_->subManagersHelper_->currentMissionListManager_ = temp;
357 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetAbilityTokenByMissionId_001 end");
358 }
359
360 /*
361 * Feature: AbilityManagerService
362 * Function: StartRemoteAbilityByCall
363 * SubFunction: NA
364 * FunctionPoints: AbilityManagerService StartRemoteAbilityByCall
365 */
366 HWTEST_F(AbilityManagerServiceThirdTest, StartRemoteAbilityByCall_001, TestSize.Level1)
367 {
368 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest StartRemoteAbilityByCall_001 start");
369 auto abilityMs_ = std::make_shared<AbilityManagerService>();
370 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
371 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
372 Want want;
373 EXPECT_EQ(abilityMs_->StartRemoteAbilityByCall(want, nullptr, nullptr), ERR_INVALID_VALUE);
374 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest StartRemoteAbilityByCall_001 end");
375 }
376
377 /*
378 * Feature: AbilityManagerService
379 * Function: ReleaseRemoteAbility
380 * SubFunction: NA
381 * FunctionPoints: AbilityManagerService ReleaseRemoteAbility
382 */
383 HWTEST_F(AbilityManagerServiceThirdTest, ReleaseRemoteAbility_001, TestSize.Level1)
384 {
385 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest ReleaseRemoteAbility_001 start");
386 auto abilityMs_ = std::make_shared<AbilityManagerService>();
387 AppExecFwk::ElementName element;
388 EXPECT_EQ(abilityMs_->ReleaseRemoteAbility(nullptr, element), ERR_NULL_OBJECT);
389 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest ReleaseRemoteAbility_001 end");
390 }
391
392 /*
393 * Feature: AbilityManagerService
394 * Function: JudgeAbilityVisibleControl
395 * SubFunction: NA
396 * FunctionPoints: AbilityManagerService JudgeAbilityVisibleControl
397 */
398 HWTEST_F(AbilityManagerServiceThirdTest, JudgeAbilityVisibleControl_001, TestSize.Level1)
399 {
400 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest JudgeAbilityVisibleControl_001 start");
401 auto abilityMs_ = std::make_shared<AbilityManagerService>();
402 AppExecFwk::AbilityInfo abilityInfo;
403 abilityInfo.visible = true;
404 EXPECT_EQ(abilityMs_->JudgeAbilityVisibleControl(abilityInfo), ERR_OK);
405
406 abilityInfo.visible = false;
407 EXPECT_EQ(abilityMs_->JudgeAbilityVisibleControl(abilityInfo), ERR_OK);
408
409 abilityInfo.applicationInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
410 EXPECT_EQ(abilityMs_->JudgeAbilityVisibleControl(abilityInfo), ERR_OK);
411
412 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest JudgeAbilityVisibleControl_001 end");
413 }
414
415 /*
416 * Feature: AbilityManagerService
417 * Function: OnAcceptWantResponse
418 * SubFunction: NA
419 * FunctionPoints: AbilityManagerService OnAcceptWantResponse
420 */
421 HWTEST_F(AbilityManagerServiceThirdTest, OnAcceptWantResponse_001, TestSize.Level1)
422 {
423 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest OnAcceptWantResponse_001 start");
424 auto abilityMs_ = std::make_shared<AbilityManagerService>();
425 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
426 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
427 AAFwk::Want want;
428 ASSERT_NE(abilityMs_, nullptr);
429 abilityMs_->OnAcceptWantResponse(want, "test");
430
431 auto temp = abilityMs_->subManagersHelper_->currentMissionListManager_;
432 abilityMs_->subManagersHelper_->currentMissionListManager_.reset();
433 abilityMs_->OnAcceptWantResponse(want, "test");
434 abilityMs_->subManagersHelper_->currentMissionListManager_ = temp;
435 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest OnAcceptWantResponse_001 end");
436 }
437
438 /*
439 * Feature: AbilityManagerService
440 * Function: OnStartSpecifiedAbilityTimeoutResponse
441 * SubFunction: NA
442 * FunctionPoints: AbilityManagerService OnStartSpecifiedAbilityTimeoutResponse
443 */
444 HWTEST_F(AbilityManagerServiceThirdTest, OnStartSpecifiedAbilityTimeoutResponse_001, TestSize.Level1)
445 {
446 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest OnStartSpecifiedAbilityTimeoutResponse_001 start");
447 auto abilityMs_ = std::make_shared<AbilityManagerService>();
448 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
449 AAFwk::Want want;
450 ASSERT_NE(abilityMs_, nullptr);
451 abilityMs_->OnStartSpecifiedAbilityTimeoutResponse(want);
452
453 auto temp = abilityMs_->subManagersHelper_->currentMissionListManager_;
454 abilityMs_->subManagersHelper_->currentMissionListManager_.reset();
455 abilityMs_->OnStartSpecifiedAbilityTimeoutResponse(want);
456 abilityMs_->subManagersHelper_->currentMissionListManager_ = temp;
457 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest OnStartSpecifiedAbilityTimeoutResponse_001 end");
458 }
459
460 /*
461 * Feature: AbilityManagerService
462 * Function: OnStartSpecifiedFailed
463 * SubFunction: NA
464 * FunctionPoints: AbilityManagerService OnStartSpecifiedFailed
465 */
466 HWTEST_F(AbilityManagerServiceThirdTest, OnStartSpecifiedFailed_001, TestSize.Level1)
467 {
468 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest OnStartSpecifiedFailed_001 start");
469 auto abilityMs_ = std::make_shared<AbilityManagerService>();
470 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
471 ASSERT_NE(abilityMs_, nullptr);
472 abilityMs_->OnStartSpecifiedFailed(1);
473 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest OnStartSpecifiedFailed_001 end");
474 }
475
476 /*
477 * Feature: AbilityManagerService
478 * Function: GetAbilityRunningInfos
479 * SubFunction: NA
480 * FunctionPoints: AbilityManagerService GetAbilityRunningInfos
481 */
482 HWTEST_F(AbilityManagerServiceThirdTest, GetAbilityRunningInfos_001, TestSize.Level1)
483 {
484 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetAbilityRunningInfos_001 start");
485 auto abilityMs_ = std::make_shared<AbilityManagerService>();
486 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
487 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
488 std::vector<AbilityRunningInfo> info;
489 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
490 EXPECT_NE(abilityMs_->GetAbilityRunningInfos(info), ERR_OK);
491
492 auto temp1 = abilityMs_->subManagersHelper_->currentMissionListManager_;
493 abilityMs_->subManagersHelper_->currentMissionListManager_.reset();
494 EXPECT_EQ(abilityMs_->GetAbilityRunningInfos(info), ERR_INVALID_VALUE);
495 abilityMs_->subManagersHelper_->currentMissionListManager_ = temp1;
496
497 auto temp2 = abilityMs_->subManagersHelper_->currentConnectManager_;
498 abilityMs_->subManagersHelper_->currentConnectManager_.reset();
499 EXPECT_NE(abilityMs_->GetAbilityRunningInfos(info), ERR_OK);
500 abilityMs_->subManagersHelper_->currentConnectManager_ = temp2;
501
502 auto temp3 = abilityMs_->subManagersHelper_->currentDataAbilityManager_;
503 abilityMs_->subManagersHelper_->currentDataAbilityManager_.reset();
504 EXPECT_NE(abilityMs_->GetAbilityRunningInfos(info), ERR_OK);
505 abilityMs_->subManagersHelper_->currentDataAbilityManager_ = temp3;
506 }
507 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetAbilityRunningInfos_001 end");
508 }
509
510 /*
511 * Feature: AbilityManagerService
512 * Function: GetExtensionRunningInfos
513 * SubFunction: NA
514 * FunctionPoints: AbilityManagerService GetExtensionRunningInfos
515 */
516 HWTEST_F(AbilityManagerServiceThirdTest, GetExtensionRunningInfos_001, TestSize.Level1)
517 {
518 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetExtensionRunningInfos_001 start");
519 auto abilityMs_ = std::make_shared<AbilityManagerService>();
520 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
521 std::vector<AAFwk::ExtensionRunningInfo> extensionRunningInfo;
522 EXPECT_NE(abilityMs_->GetExtensionRunningInfos(10, extensionRunningInfo), ERR_OK);
523
524 auto temp = abilityMs_->subManagersHelper_->currentConnectManager_;
525 abilityMs_->subManagersHelper_->currentConnectManager_.reset();
526 EXPECT_EQ(abilityMs_->GetExtensionRunningInfos(10, extensionRunningInfo), ERR_INVALID_VALUE);
527 abilityMs_->subManagersHelper_->currentConnectManager_ = temp;
528 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetExtensionRunningInfos_001 end");
529 }
530
531 /*
532 * Feature: AbilityManagerService
533 * Function: GetProcessRunningInfos
534 * SubFunction: NA
535 * FunctionPoints: AbilityManagerService GetProcessRunningInfos
536 */
537 HWTEST_F(AbilityManagerServiceThirdTest, GetProcessRunningInfos_001, TestSize.Level1)
538 {
539 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetProcessRunningInfos_001 start");
540 auto abilityMs_ = std::make_shared<AbilityManagerService>();
541 std::vector<AppExecFwk::RunningProcessInfo> info;
542 EXPECT_EQ(abilityMs_->GetProcessRunningInfos(info), ERR_OK);
543 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetProcessRunningInfos_001 end");
544 }
545
546 /*
547 * Feature: AbilityManagerService
548 * Function: GetProcessRunningInfosByUserId
549 * SubFunction: NA
550 * FunctionPoints: AbilityManagerService GetProcessRunningInfosByUserId
551 */
552 HWTEST_F(AbilityManagerServiceThirdTest, GetProcessRunningInfosByUserId_001, TestSize.Level1)
553 {
554 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetProcessRunningInfosByUserId_001 start");
555 auto abilityMs_ = std::make_shared<AbilityManagerService>();
556 std::vector<AppExecFwk::RunningProcessInfo> info;
557 EXPECT_NE(abilityMs_->GetProcessRunningInfosByUserId(info, 100), INNER_ERR);
558 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetProcessRunningInfosByUserId_001 end");
559 }
560
561 /*
562 * Feature: AbilityManagerService
563 * Function: ClearUserData
564 * SubFunction: NA
565 * FunctionPoints: AbilityManagerService ClearUserData
566 */
567 HWTEST_F(AbilityManagerServiceThirdTest, ClearUserData_001, TestSize.Level1)
568 {
569 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest ClearUserData_001 start");
570 auto abilityMs_ = std::make_shared<AbilityManagerService>();
571 ASSERT_NE(abilityMs_, nullptr);
572 abilityMs_->ClearUserData(100);
573 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest ClearUserData_001 end");
574 }
575
576 /*
577 * Feature: AbilityManagerService
578 * Function: CallRequestDone
579 * SubFunction: NA
580 * FunctionPoints: AbilityManagerService CallRequestDone
581 */
582 HWTEST_F(AbilityManagerServiceThirdTest, CallRequestDone_001, TestSize.Level1)
583 {
584 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest CallRequestDone_001 start");
585 auto abilityMs_ = std::make_shared<AbilityManagerService>();
586 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
587 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
588 sptr<IRemoteObject> token = nullptr;
589 sptr<IRemoteObject> callStub = nullptr;
590 ASSERT_NE(abilityMs_, nullptr);
591 abilityMs_->CallRequestDone(token, callStub);
592 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest CallRequestDone_001 end");
593 }
594
595 /*
596 * Feature: AbilityManagerService
597 * Function: UpdateMissionSnapShot
598 * SubFunction: NA
599 * FunctionPoints: AbilityManagerService UpdateMissionSnapShot
600 */
601 HWTEST_F(AbilityManagerServiceThirdTest, UpdateMissionSnapShot_001, TestSize.Level1)
602 {
603 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest UpdateMissionSnapShot_001 start");
604 auto abilityMs_ = std::make_shared<AbilityManagerService>();
605 auto pixelMap = std::shared_ptr<Media::PixelMap>();
606 MissionSnapshot missionSnapshot;
607 ASSERT_NE(abilityMs_, nullptr);
608 abilityMs_->UpdateMissionSnapShot(nullptr, pixelMap);
609 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest UpdateMissionSnapShot_001 end");
610 }
611
612 /*
613 * Feature: AbilityManagerService
614 * Function: GetRemoteMissionSnapshotInfo
615 * SubFunction: NA
616 * FunctionPoints: AbilityManagerService GetRemoteMissionSnapshotInfo
617 */
618 HWTEST_F(AbilityManagerServiceThirdTest, GetRemoteMissionSnapshotInfo_001, TestSize.Level1)
619 {
620 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetRemoteMissionSnapshotInfo_001 start");
621 auto abilityMs_ = std::make_shared<AbilityManagerService>();
622 MissionSnapshot missionSnapshot;
623 EXPECT_EQ(abilityMs_->GetRemoteMissionSnapshotInfo("", 1, missionSnapshot), ERR_NULL_OBJECT);
624 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetRemoteMissionSnapshotInfo_001 end");
625 }
626
627 /*
628 * Feature: AbilityManagerService
629 * Function: GetValidUserId
630 * SubFunction: NA
631 * FunctionPoints: AbilityManagerService GetValidUserId
632 */
633 HWTEST_F(AbilityManagerServiceThirdTest, GetValidUserId_001, TestSize.Level1)
634 {
635 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetValidUserId_001 start");
636 auto abilityMs_ = std::make_shared<AbilityManagerService>();
637 MissionSnapshot missionSnapshot;
638 EXPECT_EQ(abilityMs_->GetValidUserId(100), 100);
639 EXPECT_EQ(abilityMs_->GetValidUserId(0), 0);
640 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetValidUserId_001 end");
641 }
642
643 /*
644 * Feature: AbilityManagerService
645 * Function: IsRunningInStabilityTest
646 * SubFunction: NA
647 * FunctionPoints: AbilityManagerService IsRunningInStabilityTest
648 */
649 HWTEST_F(AbilityManagerServiceThirdTest, IsRunningInStabilityTest_001, TestSize.Level1)
650 {
651 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest IsRunningInStabilityTest_001 start");
652 auto abilityMs_ = std::make_shared<AbilityManagerService>();
653 abilityMs_->controllerIsAStabilityTest_ = false;
654 EXPECT_FALSE(abilityMs_->IsRunningInStabilityTest());
655 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest IsRunningInStabilityTest_001 end");
656 }
657
658 #ifdef ABILITY_COMMAND_FOR_TEST
659 /*
660 * Feature: AbilityManagerService
661 * Function: ForceTimeoutForTest
662 * SubFunction: NA
663 * FunctionPoints: AbilityManagerService ForceTimeoutForTest
664 */
665 HWTEST_F(AbilityManagerServiceThirdTest, ForceTimeoutForTest_001, TestSize.Level1)
666 {
667 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest ForceTimeoutForTest_001 start");
668 auto abilityMs_ = std::make_shared<AbilityManagerService>();
669 EXPECT_EQ(abilityMs_->ForceTimeoutForTest("", ""), INVALID_DATA);
670 EXPECT_TRUE(abilityMs_->ForceTimeoutForTest("clean", ""), ERR_OK);
671 EXPECT_TRUE(abilityMs_->ForceTimeoutForTest("INITIAL", ""), ERR_OK);
672 EXPECT_TRUE(abilityMs_->ForceTimeoutForTest("INACTIVE", ""), ERR_OK);
673 EXPECT_TRUE(abilityMs_->ForceTimeoutForTest("FOREGROUND", ""), ERR_OK);
674 EXPECT_TRUE(abilityMs_->ForceTimeoutForTest("BACKGROUND", ""), ERR_OK);
675 EXPECT_TRUE(abilityMs_->ForceTimeoutForTest("TERMINATING", ""), ERR_OK);
676 EXPECT_TRUE(abilityMs_->ForceTimeoutForTest("COMMAND", ""), ERR_OK);
677 EXPECT_TRUE(abilityMs_->ForceTimeoutForTest("test", ""), INVALID_DATA);
678 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest ForceTimeoutForTest_001 end");
679 }
680 #endif
681
682 /*
683 * Feature: AbilityManagerService
684 * Function: JudgeMultiUserConcurrency
685 * SubFunction: NA
686 * FunctionPoints: AbilityManagerService JudgeMultiUserConcurrency
687 */
688 HWTEST_F(AbilityManagerServiceThirdTest, JudgeMultiUserConcurrency_001, TestSize.Level1)
689 {
690 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest JudgeMultiUserConcurrency_001 start");
691 auto abilityMs_ = std::make_shared<AbilityManagerService>();
692 EXPECT_TRUE(abilityMs_->JudgeMultiUserConcurrency(0));
693
694 auto temp = abilityMs_->userController_;
695 abilityMs_->userController_ = nullptr;
696 EXPECT_FALSE(abilityMs_->JudgeMultiUserConcurrency(100));
697 abilityMs_->userController_ = temp;
698 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest JudgeMultiUserConcurrency_001 end");
699 }
700
701 /*
702 * Feature: AbilityManagerService
703 * Function: CheckWindowMode
704 * SubFunction: NA
705 * FunctionPoints: AbilityManagerService CheckWindowMode
706 */
707 HWTEST_F(AbilityManagerServiceThirdTest, CheckWindowMode_001, TestSize.Level1)
708 {
709 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest CheckWindowMode_001 start");
710 auto abilityMs_ = std::make_shared<AbilityManagerService>();
711 auto windowMode = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_UNDEFINED;
712 std::vector<AppExecFwk::SupportWindowMode> windowModes;
713 EXPECT_TRUE(abilityMs_->CheckWindowMode(windowMode, windowModes));
714
715 windowMode = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FULLSCREEN;
716 EXPECT_FALSE(abilityMs_->CheckWindowMode(windowMode, windowModes));
717 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest CheckWindowMode_001 end");
718 }
719
720 /*
721 * Feature: AbilityManagerService
722 * Function: IsNeedTimeoutForTest
723 * SubFunction: NA
724 * FunctionPoints: AbilityManagerService IsNeedTimeoutForTest
725 */
726 HWTEST_F(AbilityManagerServiceThirdTest, IsNeedTimeoutForTest_001, TestSize.Level1)
727 {
728 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest IsNeedTimeoutForTest_001 start");
729 auto abilityMs_ = std::make_shared<AbilityManagerService>();
730 EXPECT_FALSE(abilityMs_->IsNeedTimeoutForTest("", ""));
731 abilityMs_->timeoutMap_.insert({"state", "abilityName"});
732 EXPECT_TRUE(abilityMs_->IsNeedTimeoutForTest("abilityName", "state"));
733 abilityMs_->timeoutMap_.clear();
734 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest IsNeedTimeoutForTest_001 end");
735 }
736
737 /*
738 * Feature: AbilityManagerService
739 * Function: GetValidDataAbilityUri
740 * SubFunction: NA
741 * FunctionPoints: AbilityManagerService GetValidDataAbilityUri
742 */
743 HWTEST_F(AbilityManagerServiceThirdTest, GetValidDataAbilityUri_001, TestSize.Level1)
744 {
745 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetValidDataAbilityUri_001 start");
746 auto abilityMs_ = std::make_shared<AbilityManagerService>();
747 std::string adjustUri;
748 EXPECT_FALSE(abilityMs_->GetValidDataAbilityUri("test", adjustUri));
749
750 EXPECT_TRUE(abilityMs_->GetValidDataAbilityUri("//test", adjustUri));
751 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetValidDataAbilityUri_001 end");
752 }
753
754 /*
755 * Feature: AbilityManagerService
756 * Function: GetDataAbilityUri
757 * SubFunction: NA
758 * FunctionPoints: AbilityManagerService GetDataAbilityUri
759 */
760 HWTEST_F(AbilityManagerServiceThirdTest, GetDataAbilityUri_001, TestSize.Level1)
761 {
762 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetDataAbilityUri_001 start");
763 auto abilityMs_ = std::make_shared<AbilityManagerService>();
764 std::vector<AppExecFwk::AbilityInfo> abilityInfos;
765 std::string uri;
766 EXPECT_FALSE(abilityMs_->GetDataAbilityUri(abilityInfos, "", uri));
767 EXPECT_FALSE(abilityMs_->GetDataAbilityUri(abilityInfos, "test", uri));
768
769 AppExecFwk::AbilityInfo abilityInfo;
770 abilityInfos.push_back(abilityInfo);
771 EXPECT_FALSE(abilityMs_->GetDataAbilityUri(abilityInfos, "", uri));
772
773 abilityInfo.type = AbilityType::DATA;
774 abilityInfo.name = "test";
775 EXPECT_FALSE(abilityMs_->GetDataAbilityUri(abilityInfos, "test", uri));
776 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetDataAbilityUri_001 end");
777 }
778
779 /*
780 * Feature: AbilityManagerService
781 * Function: CreateVerificationInfo
782 * SubFunction: NA
783 * FunctionPoints: AbilityManagerService CreateVerificationInfo
784 */
785 HWTEST_F(AbilityManagerServiceThirdTest, CreateVerificationInfo_001, TestSize.Level1)
786 {
787 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest CreateVerificationInfo_001 start");
788 auto abilityMs_ = std::make_shared<AbilityManagerService>();
789 AbilityRequest abilityRequest;
790 abilityMs_->whiteListassociatedWakeUpFlag_ = false;
791 EXPECT_FALSE(abilityMs_->CreateVerificationInfo(abilityRequest).associatedWakeUp);
792
793 abilityMs_->whiteListassociatedWakeUpFlag_ = true;
794 abilityRequest.appInfo.bundleName = "com.ohos.settingsdata";
795 EXPECT_TRUE(abilityMs_->CreateVerificationInfo(abilityRequest).associatedWakeUp);
796
797 abilityRequest.appInfo.bundleName = "test";
798 abilityRequest.appInfo.associatedWakeUp = false;
799 EXPECT_FALSE(abilityMs_->CreateVerificationInfo(abilityRequest).associatedWakeUp);
800 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest CreateVerificationInfo_001 end");
801 }
802
803 /*
804 * Feature: AbilityManagerService
805 * Function: StopUser
806 * SubFunction: NA
807 * FunctionPoints: AbilityManagerService StopUser
808 */
809 HWTEST_F(AbilityManagerServiceThirdTest, StopUser_001, TestSize.Level1)
810 {
811 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest StopUser_001 start");
812 auto abilityMs_ = std::make_shared<AbilityManagerService>();
813 EXPECT_EQ(abilityMs_->StopUser(USER_ID_U100, nullptr), CHECK_PERMISSION_FAILED);
814 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest StopUser_001 end");
815 }
816
817 /*
818 * Feature: AbilityManagerService
819 * Function: GetStartUpNewRuleFlag
820 * SubFunction: NA
821 * FunctionPoints: AbilityManagerService GetStartUpNewRuleFlag
822 */
823 HWTEST_F(AbilityManagerServiceThirdTest, GetStartUpNewRuleFlag_001, TestSize.Level1)
824 {
825 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetStartUpNewRuleFlag_001 start");
826 auto abilityMs_ = std::make_shared<AbilityManagerService>();
827 EXPECT_EQ(abilityMs_->GetStartUpNewRuleFlag(), abilityMs_->startUpNewRule_);
828 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest GetStartUpNewRuleFlag_001 end");
829 }
830
831 /*
832 * Feature: AbilityManagerService
833 * Function: IsCrossUserCall
834 * SubFunction: NA
835 * FunctionPoints: AbilityManagerService IsCrossUserCall
836 */
837 HWTEST_F(AbilityManagerServiceThirdTest, IsCrossUserCall_001, TestSize.Level1)
838 {
839 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest IsCrossUserCall_001 start");
840 auto abilityMs_ = std::make_shared<AbilityManagerService>();
841 int32_t userId = -1;
842 EXPECT_EQ(abilityMs_->IsCrossUserCall(userId), false);
843 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest IsCrossUserCall_001 end");
844 }
845
846 /*
847 * Feature: AbilityManagerService
848 * Function: IsCrossUserCall
849 * SubFunction: NA
850 * FunctionPoints: AbilityManagerService IsCrossUserCall
851 */
852 HWTEST_F(AbilityManagerServiceThirdTest, IsCrossUserCall_002, TestSize.Level1)
853 {
854 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest IsCrossUserCall_002 start");
855 auto abilityMs_ = std::make_shared<AbilityManagerService>();
856 int32_t userId = 0;
857 EXPECT_EQ(abilityMs_->IsCrossUserCall(userId), false);
858 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest IsCrossUserCall_002 end");
859 }
860
861 /*
862 * Feature: AbilityManagerService
863 * Function: IsCrossUserCall
864 * SubFunction: NA
865 * FunctionPoints: AbilityManagerService IsCrossUserCall
866 */
867 HWTEST_F(AbilityManagerServiceThirdTest, IsCrossUserCall_003, TestSize.Level1)
868 {
869 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest IsCrossUserCall_003 start");
870 auto abilityMs_ = std::make_shared<AbilityManagerService>();
871 int32_t userId = 10;
872 EXPECT_EQ(abilityMs_->IsCrossUserCall(userId), true);
873 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest IsCrossUserCall_003 end");
874 }
875
876 /*
877 * Feature: AbilityManagerService
878 * Function: IsValidMissionIds
879 * SubFunction: NA
880 * FunctionPoints: AbilityManagerService IsValidMissionIds
881 */
882 HWTEST_F(AbilityManagerServiceThirdTest, IsValidMissionIds_001, TestSize.Level1)
883 {
884 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest IsValidMissionIds_001 start");
885 auto abilityMs_ = std::make_shared<AbilityManagerService>();
886 std::vector<int32_t> missionIds;
887 std::vector<MissionValidResult> results;
888 EXPECT_EQ(abilityMs_->IsValidMissionIds(missionIds, results), ERR_INVALID_VALUE);
889 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest IsValidMissionIds_001 end");
890 }
891
892 /*
893 * Feature: AbilityManagerService
894 * Function: CheckUIExtensionIsFocused
895 * SubFunction: NA
896 * FunctionPoints: AbilityManagerService CheckUIExtensionIsFocused
897 */
898 HWTEST_F(AbilityManagerServiceThirdTest, CheckUIExtensionIsFocused_001, TestSize.Level1)
899 {
900 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest CheckUIExtensionIsFocused_001 start");
901 auto abilityMs_ = std::make_shared<AbilityManagerService>();
902 bool isFocused = false;
903 EXPECT_EQ(abilityMs_->CheckUIExtensionIsFocused(0, isFocused), CHECK_PERMISSION_FAILED);
904 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest CheckUIExtensionIsFocused_001 end");
905 }
906
907 /*
908 * Feature: AbilityManagerService
909 * Function: CheckCollaboratorType
910 * SubFunction: NA
911 * FunctionPoints: AbilityManagerService CheckCollaboratorType
912 * @tc.require: issueI7LF4X
913 */
914 HWTEST_F(AbilityManagerServiceThirdTest, CheckCollaboratorType_001, TestSize.Level1)
915 {
916 auto abilityMs_ = std::make_shared<AbilityManagerService>();
917 bool res = abilityMs_->CheckCollaboratorType(CollaboratorType::RESERVE_TYPE);
918 EXPECT_EQ(res, true);
919
920 res = abilityMs_->CheckCollaboratorType(CollaboratorType::DEFAULT_TYPE);
921 EXPECT_EQ(res, false);
922 }
923
924 /*
925 * Feature: AbilityManagerService
926 * Function: RegisterSessionHandler
927 * SubFunction: NA
928 * FunctionPoints: AbilityManagerService RegisterSessionHandler
929 */
930 HWTEST_F(AbilityManagerServiceThirdTest, RegisterSessionHandler_002, TestSize.Level1)
931 {
932 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest RegisterSessionHandler_002 start");
933 auto abilityMs_ = std::make_shared<AbilityManagerService>();
934 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
935 abilityMs_->subManagersHelper_->currentUIAbilityManager_ = std::make_shared<UIAbilityLifecycleManager>();
936 EXPECT_EQ(abilityMs_->RegisterSessionHandler(nullptr), ERR_WRONG_INTERFACE_CALL);
937 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest RegisterSessionHandler_002 end");
938 }
939
940 /*
941 * Feature: AbilityManagerService
942 * Function: SetPickerElementName
943 * SubFunction: NA
944 * FunctionPoints: AbilityManagerService SetPickerElementName
945 */
946 HWTEST_F(AbilityManagerServiceThirdTest, SetPickerElementName_001, TestSize.Level1)
947 {
948 auto abilityMs_ = std::make_shared<AbilityManagerService>();
949 EXPECT_NE(abilityMs_, nullptr);
950 abilityMs_->SetPickerElementName(nullptr, USER_ID_U100);
951 }
952
953 /*
954 * Feature: AbilityManagerService
955 * Function: SetPickerElementName
956 * SubFunction: NA
957 * FunctionPoints: AbilityManagerService SetPickerElementName
958 */
959 HWTEST_F(AbilityManagerServiceThirdTest, SetPickerElementName_002, TestSize.Level1)
960 {
961 auto abilityMs_ = std::make_shared<AbilityManagerService>();
962 EXPECT_NE(abilityMs_, nullptr);
963 sptr<SessionInfo> sessionInfo = new SessionInfo();
964 const sptr<SessionInfo> extensionSessionInfo = sessionInfo;
965 abilityMs_->SetPickerElementName(extensionSessionInfo, USER_ID_U100);
966 }
967
968 /*
969 * Feature: AbilityManagerService
970 * Function: SetPickerElementName
971 * SubFunction: NA
972 * FunctionPoints: AbilityManagerService SetPickerElementName
973 */
974 HWTEST_F(AbilityManagerServiceThirdTest, SetPickerElementName_003, TestSize.Level1)
975 {
976 auto abilityMs_ = std::make_shared<AbilityManagerService>();
977 EXPECT_NE(abilityMs_, nullptr);
978 sptr<SessionInfo> sessionInfo = new SessionInfo();
979 Want want;
980 const std::string type = "share";
981 want.SetParam("ability.want.params.uiExtensionTargetType", type);
982 sessionInfo->want = want;
983 const sptr<SessionInfo> extensionSessionInfo = sessionInfo;
984 abilityMs_->SetPickerElementName(extensionSessionInfo, USER_ID_U100);
985 }
986
987 /*
988 * Feature: AbilityManagerService
989 * Function: SetPickerElementName
990 * SubFunction: NA
991 * FunctionPoints: AbilityManagerService SetPickerElementName
992 */
993 HWTEST_F(AbilityManagerServiceThirdTest, SetPickerElementName_004, TestSize.Level1)
994 {
995 auto abilityMs_ = std::make_shared<AbilityManagerService>();
996 EXPECT_NE(abilityMs_, nullptr);
997 sptr<SessionInfo> sessionInfo = new SessionInfo();
998 Want want;
999 want.SetElementName("com.example.share", "ShareUIExtensionAbility");
1000 sessionInfo->want = want;
1001 const sptr<SessionInfo> extensionSessionInfo = sessionInfo;
1002 abilityMs_->SetPickerElementName(extensionSessionInfo, USER_ID_U100);
1003 }
1004
1005 /*
1006 * Feature: AbilityManagerService
1007 * Function: OpenAtomicService
1008 * SubFunction: NA
1009 * FunctionPoints: AbilityManagerService OpenAtomicService
1010 */
1011 HWTEST_F(AbilityManagerServiceThirdTest, OpenAtomicService_001, TestSize.Level1)
1012 {
1013 auto abilityMs = std::make_shared<AbilityManagerService>();
1014 EXPECT_NE(abilityMs, nullptr);
1015 Want want;
1016 StartOptions startOptions;
1017 int32_t userId = 100;
1018 auto openRet = abilityMs->OpenAtomicService(want, startOptions, nullptr, 1, userId);
1019 EXPECT_EQ(openRet, CHECK_PERMISSION_FAILED);
1020 }
1021
1022 /*
1023 * Feature: AbilityManagerService
1024 * Function: RestartApp
1025 * FunctionPoints: AbilityManagerService RestartApp
1026 */
1027 HWTEST_F(AbilityManagerServiceThirdTest, RestartApp_001, TestSize.Level1)
1028 {
1029 auto abilityMs = std::make_shared<AbilityManagerService>();
1030 EXPECT_NE(abilityMs, nullptr);
1031 AAFwk::Want want;
1032 int32_t res = abilityMs->RestartApp(want);
1033 EXPECT_NE(res, ERR_OK);
1034 }
1035
1036 /*
1037 * Feature: AbilityManagerService
1038 * Function: UnloadUIExtensionAbility
1039 * FunctionPoints: AbilityManagerService UnloadUIExtensionAbility
1040 */
1041 HWTEST_F(AbilityManagerServiceThirdTest, UnloadUIExtensionAbility_001, TestSize.Level1)
1042 {
1043 TAG_LOGI(AAFwkTag::TEST, "start.");
1044 auto abilityMs = std::make_shared<AbilityManagerService>();
1045 AbilityRequest abilityRequest;
1046 AppExecFwk::ElementName providerElement("0", "com.ohos.uiextensionprovider", "UIExtensionProvider", "entry");
1047 abilityRequest.want.SetElement(providerElement);
1048 abilityRequest.abilityInfo.type = AbilityType::EXTENSION;
1049 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1050 std::string hostBundleName = "com.ohos.uiextensionuser";
1051 auto result = abilityMs->UnloadUIExtensionAbility(abilityRecord, hostBundleName);
1052 EXPECT_EQ(result, ERR_INVALID_VALUE);
1053 TAG_LOGI(AAFwkTag::TEST, "finish.");
1054 }
1055
1056 /*
1057 * Feature: AbilityManagerService
1058 * Function: PreloadUIExtensionAbility
1059 * FunctionPoints: AbilityManagerService PreloadUIExtensionAbility
1060 */
1061 HWTEST_F(AbilityManagerServiceThirdTest, PreloadUIExtensionAbility_001, TestSize.Level1)
1062 {
1063 TAG_LOGI(AAFwkTag::TEST, "start.");
1064 auto abilityMs = std::make_shared<AbilityManagerService>();
1065 Want providerWant;
1066 AppExecFwk::ElementName providerElement("0", "com.ohos.uiextensionprovider", "UIExtensionProvider", "entry");
1067 providerWant.SetElement(providerElement);
1068 std::string hostBundleName = "com.ohos.uiextensionuser";
1069 auto result = abilityMs->PreloadUIExtensionAbility(providerWant, hostBundleName, DEFAULT_INVAL_VALUE);
1070 EXPECT_EQ(result, ERR_PERMISSION_DENIED);
1071 TAG_LOGI(AAFwkTag::TEST, "finish.");
1072 }
1073
1074 /*
1075 * Feature: AbilityManagerService
1076 * Function: PreloadUIExtensionAbilityInner
1077 * FunctionPoints: AbilityManagerService PreloadUIExtensionAbility
1078 */
1079 HWTEST_F(AbilityManagerServiceThirdTest, PreloadUIExtensionAbilityInner_001, TestSize.Level1)
1080 {
1081 TAG_LOGI(AAFwkTag::TEST, "start.");
1082 auto abilityMs = std::make_shared<AbilityManagerService>();
1083 Want providerWant;
1084 AppExecFwk::ElementName providerElement("0", "com.ohos.uiextensionprovider", "UIExtensionProvider", "entry");
1085 providerWant.SetElement(providerElement);
1086 std::string hostBundleName = "com.ohos.uiextensionuser";
1087 auto result = abilityMs->PreloadUIExtensionAbilityInner(providerWant, hostBundleName, DEFAULT_INVAL_VALUE);
1088 EXPECT_NE(result, ERR_OK);
1089 TAG_LOGI(AAFwkTag::TEST, "finish.");
1090 }
1091
1092 /*
1093 * Feature: AbilityManagerService
1094 * Function: CheckRestartAppWant
1095 * FunctionPoints: AbilityManagerService CheckRestartAppWant
1096 */
1097 HWTEST_F(AbilityManagerServiceThirdTest, CheckRestartAppWant_001, TestSize.Level1)
1098 {
1099 auto abilityMs = std::make_shared<AbilityManagerService>();
1100 EXPECT_NE(abilityMs, nullptr);
1101 AAFwk::Want want;
1102 int32_t userId = 100;
1103 int32_t res = abilityMs->CheckRestartAppWant(want, 0, userId);
1104 EXPECT_EQ(res, AAFwk::ERR_RESTART_APP_INCORRECT_ABILITY);
1105 }
1106
1107 /*
1108 * Feature: AbilityManagerService
1109 * Function: GetAbilityStateByPersistentId
1110 * FunctionPoints: AbilityManagerService GetAbilityStateByPersistentId
1111 */
1112 HWTEST_F(AbilityManagerServiceThirdTest, GetAbilityStateByPersistentId_001, TestSize.Level1)
1113 {
1114 auto abilityMs = std::make_shared<AbilityManagerService>();
1115 EXPECT_NE(abilityMs, nullptr);
1116 int32_t persistentId = 100;
1117 bool state;
1118 int32_t res = abilityMs->GetAbilityStateByPersistentId(persistentId, state);
1119 EXPECT_EQ(res, ERR_PERMISSION_DENIED);
1120 }
1121
1122 /*
1123 * Feature: AbilityManagerService
1124 * Function: InitDeepLinkReserve
1125 * FunctionPoints: AbilityManagerService InitDeepLinkReserve
1126 */
1127 HWTEST_F(AbilityManagerServiceThirdTest, InitDeepLinkReserve_001, TestSize.Level1)
1128 {
1129 auto abilityMs = std::make_shared<AbilityManagerService>();
1130 abilityMs->InitDeepLinkReserve();
1131 EXPECT_NE(abilityMs, nullptr);
1132 }
1133
1134 /*
1135 * Feature: AbilityManagerService
1136 * Function: InitInterceptor
1137 * FunctionPoints: AbilityManagerService InitInterceptor
1138 */
1139 HWTEST_F(AbilityManagerServiceThirdTest, InitInterceptor_001, TestSize.Level1)
1140 {
1141 auto abilityMs = std::make_shared<AbilityManagerService>();
1142 abilityMs->InitInterceptor();
1143 EXPECT_NE(abilityMs, nullptr);
1144 }
1145
1146 /*
1147 * Feature: AbilityManagerService
1148 * Function: InitPushTask
1149 * FunctionPoints: AbilityManagerService InitPushTask
1150 */
1151 HWTEST_F(AbilityManagerServiceThirdTest, InitPushTask_001, TestSize.Level1)
1152 {
1153 auto abilityMs = std::make_shared<AbilityManagerService>();
1154 abilityMs->InitPushTask();
1155 EXPECT_NE(abilityMs, nullptr);
1156 }
1157
1158 /*
1159 * Feature: AbilityManagerService
1160 * Function: InitPushTask
1161 * FunctionPoints: AbilityManagerService InitPushTask
1162 */
1163 HWTEST_F(AbilityManagerServiceThirdTest, InitPushTask_002, TestSize.Level1)
1164 {
1165 auto abilityMs = std::make_shared<AbilityManagerService>();
1166 abilityMs->taskHandler_ = nullptr;
1167 abilityMs->InitPushTask();
1168 EXPECT_NE(abilityMs, nullptr);
1169 }
1170
1171 /*
1172 * Feature: AbilityManagerService
1173 * Function: InitStartupFlag
1174 * FunctionPoints: AbilityManagerService InitStartupFlag
1175 */
1176 HWTEST_F(AbilityManagerServiceThirdTest, InitStartupFlag_001, TestSize.Level1)
1177 {
1178 auto abilityMs = std::make_shared<AbilityManagerService>();
1179 abilityMs->InitStartupFlag();
1180 EXPECT_NE(abilityMs, nullptr);
1181 }
1182
1183 /*
1184 * Feature: AbilityManagerService
1185 * Function: InitStartAbilityChain
1186 * FunctionPoints: AbilityManagerService InitStartAbilityChain
1187 */
1188 HWTEST_F(AbilityManagerServiceThirdTest, InitStartAbilityChain_001, TestSize.Level1)
1189 {
1190 auto abilityMs = std::make_shared<AbilityManagerService>();
1191 abilityMs->InitStartAbilityChain();
1192 EXPECT_NE(abilityMs, nullptr);
1193 }
1194
1195 /*
1196 * Feature: AbilityManagerService
1197 * Function: QueryServiceState
1198 * FunctionPoints: AbilityManagerService QueryServiceState
1199 */
1200 HWTEST_F(AbilityManagerServiceThirdTest, QueryServiceState_001, TestSize.Level1)
1201 {
1202 auto abilityMs = std::make_shared<AbilityManagerService>();
1203 abilityMs->QueryServiceState();
1204 EXPECT_NE(abilityMs, nullptr);
1205 }
1206
1207 /*
1208 * Feature: AbilityManagerService
1209 * Function: StartAbilityByFreeInstall
1210 * FunctionPoints: AbilityManagerService StartAbilityByFreeInstall
1211 */
1212 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityByFreeInstall_001, TestSize.Level1)
1213 {
1214 AAFwk::IsMockSaCall::IsMockSaCallWithPermission();
1215 auto abilityMs = std::make_shared<AbilityManagerService>();
1216 Want want;
1217 sptr<IRemoteObject> callerToken;
1218 int32_t userId = 0;
1219 int32_t requestCode = 0;
1220 auto result = abilityMs->StartAbilityByFreeInstall(want, callerToken, userId, requestCode);
1221 EXPECT_EQ(result, ERR_INVALID_VALUE);
1222 }
1223
1224 /*
1225 * Feature: AbilityManagerService
1226 * Function: StartAbilityByFreeInstall
1227 * FunctionPoints: AbilityManagerService StartAbilityByFreeInstall
1228 */
1229 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityByFreeInstall_002, TestSize.Level1)
1230 {
1231 auto abilityMs = std::make_shared<AbilityManagerService>();
1232 Want want;
1233 want.SetFlags(Want::FLAG_ABILITY_CONTINUATION);
1234 sptr<IRemoteObject> callerToken;
1235 int32_t userId = 0;
1236 int32_t requestCode = 0;
1237 auto result = abilityMs->StartAbilityByFreeInstall(want, callerToken, userId, requestCode);
1238 EXPECT_EQ(result, ERR_INVALID_CONTINUATION_FLAG);
1239 }
1240
1241 /*
1242 * Feature: AbilityManagerService
1243 * Function: StartAbilityWithSpecifyTokenId
1244 * FunctionPoints: AbilityManagerService StartAbilityWithSpecifyTokenId
1245 */
1246 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityWithSpecifyTokenId_001, TestSize.Level1)
1247 {
1248 auto abilityMs = std::make_shared<AbilityManagerService>();
1249 Want want;
1250 sptr<IRemoteObject> callerToken;
1251 uint32_t specifyTokenId = 0;
1252 int32_t userId = 0;
1253 int32_t requestCode = 0;
1254 auto result = abilityMs->StartAbilityWithSpecifyTokenId(want, callerToken, specifyTokenId, userId, requestCode);
1255 EXPECT_EQ(result, CHECK_PERMISSION_FAILED);
1256 }
1257
1258 /*
1259 * Feature: AbilityManagerService
1260 * Function: StartAbilityByInsightIntent
1261 * FunctionPoints: AbilityManagerService StartAbilityByInsightIntent
1262 */
1263 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityByInsightIntent_001, TestSize.Level1)
1264 {
1265 auto abilityMs = std::make_shared<AbilityManagerService>();
1266 Want want;
1267 sptr<IRemoteObject> callerToken;
1268 uint64_t intentId = 0;
1269 int32_t userId = 0;
1270 auto result = abilityMs->StartAbilityByInsightIntent(want, callerToken, intentId, userId);
1271 EXPECT_EQ(result, ERR_INVALID_VALUE);
1272 }
1273
1274 /*
1275 * Feature: AbilityManagerService
1276 * Function: StartAbilityWithSpecifyTokenIdInner
1277 * FunctionPoints: AbilityManagerService StartAbilityWithSpecifyTokenIdInner
1278 */
1279 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityWithSpecifyTokenIdInner_001, TestSize.Level1)
1280 {
1281 AAFwk::IsMockSaCall::IsMockSaCallWithPermission();
1282 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1283 Want want;
1284 sptr<IRemoteObject> callerToken = nullptr;
1285 int requestCode = 0;
1286 EXPECT_EQ(abilityMs_->StartAbilityWithSpecifyTokenIdInner(want, callerToken, USER_ID_U100, false, requestCode),
1287 ERR_INVALID_VALUE);
1288 }
1289
1290 /*
1291 * Feature: AbilityManagerService
1292 * Function: StartAbilityWithSpecifyTokenIdInner
1293 * FunctionPoints: AbilityManagerService StartAbilityWithSpecifyTokenIdInner
1294 */
1295 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityWithSpecifyTokenIdInner_002, TestSize.Level1)
1296 {
1297 auto abilityMs_ = std::make_shared<AbilityManagerService>();
1298 Want want;
1299 want.SetFlags(Want::FLAG_ABILITY_CONTINUATION);
1300 sptr<IRemoteObject> callerToken = nullptr;
1301 int requestCode = 0;
1302 EXPECT_EQ(abilityMs_->StartAbilityWithSpecifyTokenIdInner(want, callerToken, USER_ID_U100, false, requestCode),
1303 ERR_INVALID_CONTINUATION_FLAG);
1304 }
1305
1306 /*
1307 * Feature: AbilityManagerService
1308 * Function: StartAbilityByUIContentSession
1309 * FunctionPoints: AbilityManagerService StartAbilityByUIContentSession
1310 */
1311 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityByUIContentSession_001, TestSize.Level1)
1312 {
1313 auto abilityMs = std::make_shared<AbilityManagerService>();
1314 Want want;
1315 sptr<IRemoteObject> callerToken;
1316 sptr<SessionInfo> sessionInfo;
1317 int32_t userId = 0;
1318 int requestCode = 0;
1319 auto result = abilityMs->StartAbilityByUIContentSession(want, callerToken, sessionInfo, userId, requestCode);
1320 EXPECT_EQ(result, ERR_INVALID_VALUE);
1321 }
1322
1323 /*
1324 * Feature: AbilityManagerService
1325 * Function: StartAbilityByUIContentSession
1326 * FunctionPoints: AbilityManagerService StartAbilityByUIContentSession
1327 */
1328 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityByUIContentSession_002, TestSize.Level1)
1329 {
1330 auto abilityMs = std::make_shared<AbilityManagerService>();
1331 Want want;
1332 sptr<IRemoteObject> callerToken = new AbilityManagerStubTestMock();
1333 sptr<SessionInfo> sessionInfo;
1334 int32_t userId = 0;
1335 int requestCode = 0;
1336 auto result = abilityMs->StartAbilityByUIContentSession(want, callerToken, sessionInfo, userId, requestCode);
1337 EXPECT_EQ(result, ERR_INVALID_VALUE);
1338 }
1339
1340 /*
1341 * Feature: AbilityManagerService
1342 * Function: StartAbilityByUIContentSession
1343 * FunctionPoints: AbilityManagerService StartAbilityByUIContentSession
1344 */
1345 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityByUIContentSession_003, TestSize.Level1)
1346 {
1347 auto abilityMs = std::make_shared<AbilityManagerService>();
1348 Want want;
1349 sptr<IRemoteObject> callerToken;
1350 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
1351 int32_t userId = 0;
1352 int requestCode = 0;
1353 auto result = abilityMs->StartAbilityByUIContentSession(want, callerToken, sessionInfo, userId, requestCode);
1354 EXPECT_EQ(result, ERR_INVALID_VALUE);
1355 }
1356
1357 /*
1358 * Feature: AbilityManagerService
1359 * Function: StartAbilityByUIContentSession
1360 * FunctionPoints: AbilityManagerService StartAbilityByUIContentSession
1361 */
1362 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityByUIContentSession_004, TestSize.Level1)
1363 {
1364 auto abilityMs = std::make_shared<AbilityManagerService>();
1365 Want want;
1366 sptr<IRemoteObject> callerToken = new AbilityManagerStubTestMock();
1367 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
1368 int32_t userId = 0;
1369 int requestCode = 0;
1370 auto result = abilityMs->StartAbilityByUIContentSession(want, callerToken, sessionInfo, userId, requestCode);
1371 EXPECT_EQ(result, ERR_INVALID_VALUE);
1372 }
1373
1374 /*
1375 * Feature: AbilityManagerService
1376 * Function: StartAbilityByUIContentSession
1377 * FunctionPoints: AbilityManagerService StartAbilityByUIContentSession
1378 */
1379 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityByUIContentSession_005, TestSize.Level1)
1380 {
1381 auto abilityMs = std::make_shared<AbilityManagerService>();
1382 Want want;
1383 StartOptions startOptions;
1384 sptr<IRemoteObject> callerToken;
1385 sptr<SessionInfo> sessionInfo;
1386 int32_t userId = 0;
1387 int requestCode = 0;
1388 auto result = abilityMs->StartAbilityByUIContentSession(want, startOptions, callerToken, sessionInfo, userId,
1389 requestCode);
1390 EXPECT_EQ(result, ERR_INVALID_VALUE);
1391 }
1392
1393 /*
1394 * Feature: AbilityManagerService
1395 * Function: StartAbilityByUIContentSession
1396 * FunctionPoints: AbilityManagerService StartAbilityByUIContentSession
1397 */
1398 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityByUIContentSession_006, TestSize.Level1)
1399 {
1400 auto abilityMs = std::make_shared<AbilityManagerService>();
1401 Want want;
1402 StartOptions startOptions;
1403 sptr<IRemoteObject> callerToken = new AbilityManagerStubTestMock();
1404 sptr<SessionInfo> sessionInfo;
1405 int32_t userId = 0;
1406 int requestCode = 0;
1407 auto result = abilityMs->StartAbilityByUIContentSession(want, startOptions, callerToken, sessionInfo, userId,
1408 requestCode);
1409 EXPECT_EQ(result, ERR_INVALID_VALUE);
1410 }
1411
1412 /*
1413 * Feature: AbilityManagerService
1414 * Function: StartAbilityByUIContentSession
1415 * FunctionPoints: AbilityManagerService StartAbilityByUIContentSession
1416 */
1417 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityByUIContentSession_007, TestSize.Level1)
1418 {
1419 auto abilityMs = std::make_shared<AbilityManagerService>();
1420 Want want;
1421 StartOptions startOptions;
1422 sptr<IRemoteObject> callerToken;
1423 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
1424 int32_t userId = 0;
1425 int requestCode = 0;
1426 auto result = abilityMs->StartAbilityByUIContentSession(want, startOptions, callerToken, sessionInfo, userId,
1427 requestCode);
1428 EXPECT_EQ(result, ERR_INVALID_VALUE);
1429 }
1430
1431 /*
1432 * Feature: AbilityManagerService
1433 * Function: StartAbilityByUIContentSession
1434 * FunctionPoints: AbilityManagerService StartAbilityByUIContentSession
1435 */
1436 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityByUIContentSession_008, TestSize.Level1)
1437 {
1438 auto abilityMs = std::make_shared<AbilityManagerService>();
1439 Want want;
1440 StartOptions startOptions;
1441 sptr<IRemoteObject> callerToken = new AbilityManagerStubTestMock();
1442 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
1443 int32_t userId = 0;
1444 int requestCode = 0;
1445 auto result = abilityMs->StartAbilityByUIContentSession(want, startOptions, callerToken, sessionInfo, userId,
1446 requestCode);
1447 EXPECT_EQ(result, ERR_INVALID_VALUE);
1448 }
1449
1450 /*
1451 * Feature: AbilityManagerService
1452 * Function: ImplicitStartAbilityAsCaller
1453 * FunctionPoints: AbilityManagerService ImplicitStartAbilityAsCaller
1454 */
1455 HWTEST_F(AbilityManagerServiceThirdTest, ImplicitStartAbilityAsCaller_001, TestSize.Level1)
1456 {
1457 auto abilityMs = std::make_shared<AbilityManagerService>();
1458 Want want;
1459 sptr<IRemoteObject> callerToken;
1460 sptr<IRemoteObject> asCallerSourceToken;
1461 int32_t userId = 0;
1462 int requestCode = 0;
1463 auto result = abilityMs->ImplicitStartAbilityAsCaller(want, callerToken, asCallerSourceToken, userId,
1464 requestCode);
1465 EXPECT_EQ(result, ERR_INVALID_VALUE);
1466 }
1467
1468 /*
1469 * Feature: AbilityManagerService
1470 * Function: StartAbilityAsCallerDetails
1471 * FunctionPoints: AbilityManagerService StartAbilityAsCallerDetails
1472 */
1473 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityAsCallerDetails_001, TestSize.Level1)
1474 {
1475 auto abilityMs = std::make_shared<AbilityManagerService>();
1476 Want want;
1477 sptr<IRemoteObject> callerToken;
1478 sptr<IRemoteObject> asCallerSourceToken;
1479 int32_t userId = 0;
1480 int requestCode = 0;
1481 bool isImplicit = true;
1482 auto result = abilityMs->StartAbilityAsCallerDetails(want, callerToken, asCallerSourceToken, userId,
1483 requestCode, isImplicit);
1484 EXPECT_EQ(result, ERR_INVALID_VALUE);
1485 }
1486
1487 /*
1488 * Feature: AbilityManagerService
1489 * Function: StartAbilityAsCallerDetails
1490 * FunctionPoints: AbilityManagerService StartAbilityAsCallerDetails
1491 */
1492 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityAsCallerDetails_002, TestSize.Level1)
1493 {
1494 auto abilityMs = std::make_shared<AbilityManagerService>();
1495 Want want;
1496 want.SetFlags(Want::FLAG_ABILITY_CONTINUATION);
1497 sptr<IRemoteObject> callerToken;
1498 sptr<IRemoteObject> asCallerSourceToken;
1499 int32_t userId = 0;
1500 int requestCode = 0;
1501 bool isImplicit = true;
1502 auto result = abilityMs->StartAbilityAsCallerDetails(want, callerToken, asCallerSourceToken, userId,
1503 requestCode, isImplicit);
1504 EXPECT_EQ(result, ERR_INVALID_CONTINUATION_FLAG);
1505 }
1506
1507 /*
1508 * Feature: AbilityManagerService
1509 * Function: StartAbilityAsCallerDetails
1510 * FunctionPoints: AbilityManagerService StartAbilityAsCallerDetails
1511 */
1512 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityAsCallerDetails_003, TestSize.Level1)
1513 {
1514 auto abilityMs = std::make_shared<AbilityManagerService>();
1515 Want want;
1516 sptr<IRemoteObject> callerToken;
1517 sptr<IRemoteObject> asCallerSourceToken = new AbilityManagerStubTestMock();
1518 int32_t userId = 0;
1519 int requestCode = 0;
1520 bool isImplicit = true;
1521 auto result = abilityMs->StartAbilityAsCallerDetails(want, callerToken, asCallerSourceToken, userId,
1522 requestCode, isImplicit);
1523 EXPECT_EQ(result, ERR_INVALID_VALUE);
1524 }
1525
1526 /*
1527 * Feature: AbilityManagerService
1528 * Function: StartAbilityPublicPrechainCheck
1529 * FunctionPoints: AbilityManagerService StartAbilityPublicPrechainCheck
1530 */
1531 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityPublicPrechainCheck_001, TestSize.Level1)
1532 {
1533 auto abilityMs = std::make_shared<AbilityManagerService>();
1534 Want want;
1535 StartAbilityParams startParams(const_cast<Want &>(want));
1536 auto result = abilityMs->StartAbilityPublicPrechainCheck(startParams);
1537 EXPECT_EQ(result, ERR_OK);
1538 }
1539
1540 /*
1541 * Feature: AbilityManagerService
1542 * Function: StartAbilityPrechainInterceptor
1543 * FunctionPoints: AbilityManagerService StartAbilityPrechainInterceptor
1544 */
1545 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityPrechainInterceptor_001, TestSize.Level1)
1546 {
1547 auto abilityMs = std::make_shared<AbilityManagerService>();
1548 Want want;
1549 StartAbilityParams startParams(const_cast<Want &>(want));
1550 auto result = abilityMs->StartAbilityPrechainInterceptor(startParams);
1551 EXPECT_EQ(result, ERR_INVALID_VALUE);
1552 }
1553
1554 /*
1555 * Feature: AbilityManagerService
1556 * Function: StartAbilityInChain
1557 * FunctionPoints: AbilityManagerService StartAbilityInChain
1558 */
1559 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityInChain_001, TestSize.Level1)
1560 {
1561 auto abilityMs = std::make_shared<AbilityManagerService>();
1562 Want want;
1563 StartAbilityParams startParams(const_cast<Want &>(want));
1564 int result = 0;
1565 auto ret = abilityMs->StartAbilityInChain(startParams, result);
1566 EXPECT_EQ(ret, ERR_OK);
1567 }
1568
1569 /*
1570 * Feature: AbilityManagerService
1571 * Function: StartAbilityWrap
1572 * FunctionPoints: AbilityManagerService StartAbilityWrap
1573 */
1574 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityWrap_001, TestSize.Level1)
1575 {
1576 auto abilityMs = std::make_shared<AbilityManagerService>();
1577 Want want;
1578 sptr<IRemoteObject> callerToken;
1579 int requestCode = 0;
1580 int32_t userId = 0;
1581 bool isStartAsCaller = true;
1582 uint32_t specifyToken = 0;
1583 bool isForegroundToRestartApp = true;
1584 bool isImplicit = true;
1585 auto result = abilityMs->StartAbilityWrap(want, callerToken, requestCode, false, userId, isStartAsCaller,
1586 specifyToken, isForegroundToRestartApp, isImplicit);
1587 EXPECT_EQ(result, ERR_INVALID_VALUE);
1588 }
1589
1590 /*
1591 * Feature: AbilityManagerService
1592 * Function: SetReserveInfo
1593 * FunctionPoints: AbilityManagerService SetReserveInfo
1594 */
1595 HWTEST_F(AbilityManagerServiceThirdTest, SetReserveInfo_001, TestSize.Level1)
1596 {
1597 auto abilityMs = std::make_shared<AbilityManagerService>();
1598 std::string linkString = "";
1599 AbilityRequest abilityRequest;
1600 abilityMs->SetReserveInfo(linkString, abilityRequest);
1601 EXPECT_TRUE(abilityMs != nullptr);
1602 }
1603
1604 /*
1605 * Feature: AbilityManagerService
1606 * Function: ImplicitStartAbility
1607 * FunctionPoints: AbilityManagerService ImplicitStartAbility
1608 */
1609 HWTEST_F(AbilityManagerServiceThirdTest, ImplicitStartAbility_001, TestSize.Level1)
1610 {
1611 auto abilityMs = std::make_shared<AbilityManagerService>();
1612 Want want;
1613 AbilityStartSetting abilityStartSetting;
1614 const sptr<IRemoteObject> callerToken;
1615 int32_t userId = 0;
1616 int requestCode = 0;
1617 auto result = abilityMs->ImplicitStartAbility(want, abilityStartSetting, callerToken, userId, requestCode);
1618 EXPECT_EQ(result, ERR_INVALID_VALUE);
1619 }
1620
1621 /*
1622 * Feature: AbilityManagerService
1623 * Function: ImplicitStartAbility
1624 * FunctionPoints: AbilityManagerService ImplicitStartAbility
1625 */
1626 HWTEST_F(AbilityManagerServiceThirdTest, ImplicitStartAbility_002, TestSize.Level1)
1627 {
1628 auto abilityMs = std::make_shared<AbilityManagerService>();
1629 Want want;
1630 StartOptions startOptions;
1631 const sptr<IRemoteObject> callerToken;
1632 int32_t userId = 0;
1633 int requestCode = 0;
1634 auto result = abilityMs->ImplicitStartAbility(want, startOptions, callerToken, userId, requestCode);
1635 EXPECT_EQ(result, ERR_INVALID_VALUE);
1636 }
1637
1638 /*
1639 * Feature: AbilityManagerService
1640 * Function: StartUIAbilityForOptionWrap
1641 * FunctionPoints: AbilityManagerService StartUIAbilityForOptionWrap
1642 */
1643 HWTEST_F(AbilityManagerServiceThirdTest, StartUIAbilityForOptionWrap_001, TestSize.Level1)
1644 {
1645 auto abilityMs = std::make_shared<AbilityManagerService>();
1646 Want want;
1647 StartOptions startOptions;
1648 const sptr<IRemoteObject> callerToken;
1649 int32_t userId = 0;
1650 int requestCode = 0;
1651 uint32_t callerTokenId = 0;
1652 bool isImplicit = true;
1653 auto result = abilityMs->StartUIAbilityForOptionWrap(want, startOptions, callerToken, false, userId, requestCode,
1654 callerTokenId, isImplicit);
1655 EXPECT_EQ(result, ERR_INVALID_VALUE);
1656 }
1657
1658 /*
1659 * Feature: AbilityManagerService
1660 * Function: StartAbilityForOptionWrap
1661 * FunctionPoints: AbilityManagerService StartAbilityForOptionWrap
1662 */
1663 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityForOptionWrap_001, TestSize.Level1)
1664 {
1665 auto abilityMs = std::make_shared<AbilityManagerService>();
1666 Want want;
1667 StartOptions startOptions;
1668 const sptr<IRemoteObject> callerToken;
1669 int32_t userId = 0;
1670 int requestCode = 0;
1671 bool isStartAsCaller = true;
1672 uint32_t callerTokenId = 0;
1673 bool isImplicit = true;
1674 auto result = abilityMs->StartAbilityForOptionWrap(want, startOptions, callerToken, false, userId, requestCode,
1675 isStartAsCaller, callerTokenId, isImplicit);
1676 EXPECT_EQ(result, ERR_INVALID_VALUE);
1677 }
1678
1679 /*
1680 * Feature: AbilityManagerService
1681 * Function: StartAbilityForOptionInner
1682 * FunctionPoints: AbilityManagerService StartAbilityForOptionInner
1683 */
1684 HWTEST_F(AbilityManagerServiceThirdTest, StartAbilityForOptionInner_001, TestSize.Level1)
1685 {
1686 auto abilityMs = std::make_shared<AbilityManagerService>();
1687 Want want;
1688 StartOptions startOptions;
1689 const sptr<IRemoteObject> callerToken;
1690 int32_t userId = 0;
1691 int requestCode = 0;
1692 bool isStartAsCaller = true;
1693 uint32_t specifyTokenId = 0;
1694 bool isImplicit = true;
1695 auto result = abilityMs->StartAbilityForOptionInner(want, startOptions, callerToken, false, userId, requestCode,
1696 isStartAsCaller, specifyTokenId, isImplicit);
1697 EXPECT_EQ(result, ERR_INVALID_VALUE);
1698 }
1699
1700 /*
1701 * Feature: AbilityManagerService
1702 * Function: RequestDialogService
1703 * FunctionPoints: AbilityManagerService RequestDialogService
1704 */
1705 HWTEST_F(AbilityManagerServiceThirdTest, RequestDialogService_001, TestSize.Level1)
1706 {
1707 auto abilityMs = std::make_shared<AbilityManagerService>();
1708 Want want;
1709 const sptr<IRemoteObject> callerToken;
1710 auto result = abilityMs->RequestDialogService(want, callerToken);
1711 EXPECT_EQ(result, ERR_INVALID_CALLER);
1712 }
1713
1714 /*
1715 * Feature: AbilityManagerService
1716 * Function: RequestDialogService
1717 * FunctionPoints: AbilityManagerService RequestDialogService
1718 */
1719 HWTEST_F(AbilityManagerServiceThirdTest, RequestDialogService_002, TestSize.Level1)
1720 {
1721 auto abilityMs = std::make_shared<AbilityManagerService>();
1722 Want want;
1723 want.SetFlags(Want::FLAG_ABILITY_CONTINUATION);
1724 const sptr<IRemoteObject> callerToken;
1725 auto result = abilityMs->RequestDialogService(want, callerToken);
1726 EXPECT_EQ(result, ERR_INVALID_CONTINUATION_FLAG);
1727 }
1728
1729 /*
1730 * Feature: AbilityManagerService
1731 * Function: RequestDialogServiceInner
1732 * FunctionPoints: AbilityManagerService RequestDialogServiceInner
1733 */
1734 HWTEST_F(AbilityManagerServiceThirdTest, RequestDialogServiceInner_001, TestSize.Level1)
1735 {
1736 auto abilityMs = std::make_shared<AbilityManagerService>();
1737 Want want;
1738 const sptr<IRemoteObject> callerToken;
1739 int requestCode = 0;
1740 int32_t userId = 0;
1741 auto result = abilityMs->RequestDialogServiceInner(want, callerToken, requestCode, userId);
1742 EXPECT_EQ(result, ERR_INVALID_CALLER);
1743 }
1744
1745 /*
1746 * Feature: AbilityManagerService
1747 * Function: StartUIAbilityBySCB
1748 * FunctionPoints: AbilityManagerService StartUIAbilityBySCB
1749 */
1750 HWTEST_F(AbilityManagerServiceThirdTest, StartUIAbilityBySCB_001, TestSize.Level1)
1751 {
1752 auto abilityMs = std::make_shared<AbilityManagerService>();
1753 sptr<SessionInfo> sessionInfo = nullptr;
1754 bool isColdStart = true;
1755 auto result = abilityMs->StartUIAbilityBySCB(sessionInfo, isColdStart);
1756 EXPECT_EQ(result, ERR_INVALID_VALUE);
1757 }
1758
1759 /*
1760 * Feature: AbilityManagerService
1761 * Function: StartUIAbilityBySCB
1762 * FunctionPoints: AbilityManagerService StartUIAbilityBySCB
1763 */
1764 HWTEST_F(AbilityManagerServiceThirdTest, StartUIAbilityBySCB_002, TestSize.Level1)
1765 {
1766 auto abilityMs = std::make_shared<AbilityManagerService>();
1767 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
1768 bool isColdStart = true;
1769 auto result = abilityMs->StartUIAbilityBySCB(sessionInfo, isColdStart);
1770 EXPECT_EQ(result, ERR_INVALID_VALUE);
1771 }
1772
1773 /*
1774 * Feature: AbilityManagerService
1775 * Function: CheckCallingTokenId
1776 * FunctionPoints: AbilityManagerService CheckCallingTokenId
1777 */
1778 HWTEST_F(AbilityManagerServiceThirdTest, CheckCallingTokenId_001, TestSize.Level1)
1779 {
1780 auto abilityMs = std::make_shared<AbilityManagerService>();
1781 std::string bundleName = "test";
1782 int32_t userId = 0;
1783 auto result = abilityMs->CheckCallingTokenId(bundleName, userId);
1784 EXPECT_EQ(result, false);
1785 }
1786
1787 /*
1788 * Feature: AbilityManagerService
1789 * Function: IsCallerSceneBoard
1790 * FunctionPoints: AbilityManagerService IsCallerSceneBoard
1791 */
1792 HWTEST_F(AbilityManagerServiceThirdTest, IsCallerSceneBoard_001, TestSize.Level1)
1793 {
1794 auto abilityMs = std::make_shared<AbilityManagerService>();
1795 auto result = abilityMs->IsCallerSceneBoard();
1796 EXPECT_EQ(result, false);
1797 }
1798
1799 /*
1800 * Feature: AbilityManagerService
1801 * Function: IsDmsAlive
1802 * FunctionPoints: AbilityManagerService IsDmsAlive
1803 */
1804 HWTEST_F(AbilityManagerServiceThirdTest, IsDmsAlive_001, TestSize.Level1)
1805 {
1806 auto abilityMs = std::make_shared<AbilityManagerService>();
1807 auto result = abilityMs->IsDmsAlive();
1808 EXPECT_EQ(result, false);
1809 }
1810
1811 /*
1812 * Feature: AbilityManagerService
1813 * Function: AppUpgradeCompleted
1814 * FunctionPoints: AbilityManagerService AppUpgradeCompleted
1815 */
1816 HWTEST_F(AbilityManagerServiceThirdTest, AppUpgradeCompleted_001, TestSize.Level1)
1817 {
1818 auto abilityMs = std::make_shared<AbilityManagerService>();
1819 int32_t uid = 0;
1820 abilityMs->AppUpgradeCompleted(uid);
1821 EXPECT_TRUE(abilityMs != nullptr);
1822 }
1823
1824 /*
1825 * Feature: AbilityManagerService
1826 * Function: AppUpgradeCompleted
1827 * FunctionPoints: AbilityManagerService AppUpgradeCompleted
1828 */
1829 HWTEST_F(AbilityManagerServiceThirdTest, AppUpgradeCompleted_002, TestSize.Level1)
1830 {
1831 AAFwk::IsMockSaCall::IsMockSaCallWithPermission();
1832 auto abilityMs = std::make_shared<AbilityManagerService>();
1833 int32_t uid = 1;
1834 abilityMs->AppUpgradeCompleted(uid);
1835 EXPECT_TRUE(abilityMs != nullptr);
1836 }
1837
1838 /*
1839 * Feature: AbilityManagerService
1840 * Function: OnAddSystemAbility
1841 * FunctionPoints: AbilityManagerService OnAddSystemAbility
1842 */
1843 HWTEST_F(AbilityManagerServiceThirdTest, OnAddSystemAbility_001, TestSize.Level1)
1844 {
1845 auto abilityMs = std::make_shared<AbilityManagerService>();
1846 int32_t systemAbilityId = BACKGROUND_TASK_MANAGER_SERVICE_ID;
1847 std::string deviceId = "";
1848 abilityMs->OnAddSystemAbility(systemAbilityId, deviceId);
1849 EXPECT_TRUE(abilityMs != nullptr);
1850 }
1851
1852 /*
1853 * Feature: AbilityManagerService
1854 * Function: OnAddSystemAbility
1855 * FunctionPoints: AbilityManagerService OnAddSystemAbility
1856 */
1857 HWTEST_F(AbilityManagerServiceThirdTest, OnAddSystemAbility_002, TestSize.Level1)
1858 {
1859 auto abilityMs = std::make_shared<AbilityManagerService>();
1860 int32_t systemAbilityId = DISTRIBUTED_SCHED_SA_ID;
1861 std::string deviceId = "";
1862 abilityMs->OnAddSystemAbility(systemAbilityId, deviceId);
1863 EXPECT_TRUE(abilityMs != nullptr);
1864 }
1865
1866 /*
1867 * Feature: AbilityManagerService
1868 * Function: OnAddSystemAbility
1869 * FunctionPoints: AbilityManagerService OnAddSystemAbility
1870 */
1871 HWTEST_F(AbilityManagerServiceThirdTest, OnAddSystemAbility_003, TestSize.Level1)
1872 {
1873 auto abilityMs = std::make_shared<AbilityManagerService>();
1874 int32_t systemAbilityId = BUNDLE_MGR_SERVICE_SYS_ABILITY_ID;
1875 std::string deviceId = "";
1876 abilityMs->OnAddSystemAbility(systemAbilityId, deviceId);
1877 EXPECT_TRUE(abilityMs != nullptr);
1878 }
1879
1880 /*
1881 * Feature: AbilityManagerService
1882 * Function: OnRemoveSystemAbility
1883 * FunctionPoints: AbilityManagerService OnRemoveSystemAbility
1884 */
1885 HWTEST_F(AbilityManagerServiceThirdTest, OnRemoveSystemAbility_001, TestSize.Level1)
1886 {
1887 auto abilityMs = std::make_shared<AbilityManagerService>();
1888 int32_t systemAbilityId = BACKGROUND_TASK_MANAGER_SERVICE_ID;
1889 std::string deviceId = "";
1890 abilityMs->OnRemoveSystemAbility(systemAbilityId, deviceId);
1891 EXPECT_TRUE(abilityMs != nullptr);
1892 }
1893
1894 /*
1895 * Feature: AbilityManagerService
1896 * Function: OnRemoveSystemAbility
1897 * FunctionPoints: AbilityManagerService OnRemoveSystemAbility
1898 */
1899 HWTEST_F(AbilityManagerServiceThirdTest, OnRemoveSystemAbility_002, TestSize.Level1)
1900 {
1901 auto abilityMs = std::make_shared<AbilityManagerService>();
1902 int32_t systemAbilityId = DISTRIBUTED_SCHED_SA_ID;
1903 std::string deviceId = "";
1904 abilityMs->OnRemoveSystemAbility(systemAbilityId, deviceId);
1905 EXPECT_TRUE(abilityMs != nullptr);
1906 }
1907
1908 /*
1909 * Feature: AbilityManagerService
1910 * Function: OnRemoveSystemAbility
1911 * FunctionPoints: AbilityManagerService OnRemoveSystemAbility
1912 */
1913 HWTEST_F(AbilityManagerServiceThirdTest, OnRemoveSystemAbility_003, TestSize.Level1)
1914 {
1915 auto abilityMs = std::make_shared<AbilityManagerService>();
1916 int32_t systemAbilityId = BUNDLE_MGR_SERVICE_SYS_ABILITY_ID;
1917 std::string deviceId = "";
1918 abilityMs->OnRemoveSystemAbility(systemAbilityId, deviceId);
1919 EXPECT_TRUE(abilityMs != nullptr);
1920 }
1921
1922 /*
1923 * Feature: AbilityManagerService
1924 * Function: SubscribeBundleEventCallback
1925 * FunctionPoints: AbilityManagerService SubscribeBundleEventCallback
1926 */
1927 HWTEST_F(AbilityManagerServiceThirdTest, SubscribeBundleEventCallback_001, TestSize.Level1)
1928 {
1929 auto abilityMs = std::make_shared<AbilityManagerService>();
1930 abilityMs->abilityBundleEventCallback_ = nullptr;
1931 abilityMs->SubscribeBundleEventCallback();
1932 EXPECT_TRUE(abilityMs != nullptr);
1933 }
1934
1935 /*
1936 * Feature: AbilityManagerService
1937 * Function: SubscribeBundleEventCallback
1938 * FunctionPoints: AbilityManagerService SubscribeBundleEventCallback
1939 */
1940 HWTEST_F(AbilityManagerServiceThirdTest, SubscribeBundleEventCallback_002, TestSize.Level1)
1941 {
1942 auto abilityMs = std::make_shared<AbilityManagerService>();
1943 abilityMs->abilityBundleEventCallback_ = new (std::nothrow) AbilityBundleEventCallback(nullptr, nullptr);
1944 abilityMs->SubscribeBundleEventCallback();
1945 EXPECT_TRUE(abilityMs != nullptr);
1946 }
1947
1948 /*
1949 * Feature: AbilityManagerService
1950 * Function: UnsubscribeBundleEventCallback
1951 * FunctionPoints: AbilityManagerService UnsubscribeBundleEventCallback
1952 */
1953 HWTEST_F(AbilityManagerServiceThirdTest, UnsubscribeBundleEventCallback_001, TestSize.Level1)
1954 {
1955 auto abilityMs = std::make_shared<AbilityManagerService>();
1956 abilityMs->abilityBundleEventCallback_ = nullptr;
1957 abilityMs->UnsubscribeBundleEventCallback();
1958 EXPECT_TRUE(abilityMs != nullptr);
1959 }
1960
1961 /*
1962 * Feature: AbilityManagerService
1963 * Function: UnsubscribeBundleEventCallback
1964 * FunctionPoints: AbilityManagerService UnsubscribeBundleEventCallback
1965 */
1966 HWTEST_F(AbilityManagerServiceThirdTest, UnsubscribeBundleEventCallback_002, TestSize.Level1)
1967 {
1968 auto abilityMs = std::make_shared<AbilityManagerService>();
1969 abilityMs->abilityBundleEventCallback_ = new (std::nothrow) AbilityBundleEventCallback(nullptr, nullptr);
1970 abilityMs->UnsubscribeBundleEventCallback();
1971 EXPECT_TRUE(abilityMs != nullptr);
1972 }
1973
1974 /*
1975 * Feature: AbilityManagerService
1976 * Function: ImplicitStartExtensionAbility
1977 * FunctionPoints: AbilityManagerService ImplicitStartExtensionAbility
1978 */
1979 HWTEST_F(AbilityManagerServiceThirdTest, ImplicitStartExtensionAbility_001, TestSize.Level1)
1980 {
1981 auto abilityMs = std::make_shared<AbilityManagerService>();
1982 Want want;
1983 sptr<IRemoteObject> callerToken;
1984 int32_t userId = 0;
1985 AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::UI;
1986 auto result = abilityMs->ImplicitStartExtensionAbility(want, callerToken, userId, extensionType);
1987 EXPECT_EQ(result, ERR_INVALID_VALUE);
1988 }
1989
1990 /*
1991 * Feature: AbilityManagerService
1992 * Function: ImplicitStartExtensionAbility
1993 * FunctionPoints: AbilityManagerService ImplicitStartExtensionAbility
1994 */
1995 HWTEST_F(AbilityManagerServiceThirdTest, ImplicitStartExtensionAbility_002, TestSize.Level1)
1996 {
1997 auto abilityMs = std::make_shared<AbilityManagerService>();
1998 Want want;
1999 sptr<IRemoteObject> callerToken;
2000 int32_t userId = 0;
2001 AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::VPN;
2002 auto result = abilityMs->ImplicitStartExtensionAbility(want, callerToken, userId, extensionType);
2003 EXPECT_EQ(result, ERR_INVALID_VALUE);
2004 }
2005
2006 /*
2007 * Feature: AbilityManagerService
2008 * Function: RequestModalUIExtension
2009 * FunctionPoints: AbilityManagerService RequestModalUIExtension
2010 */
2011 HWTEST_F(AbilityManagerServiceThirdTest, RequestModalUIExtension_001, TestSize.Level1)
2012 {
2013 auto abilityMs = std::make_shared<AbilityManagerService>();
2014 Want want;
2015 auto result = abilityMs->RequestModalUIExtension(want);
2016 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
2017 EXPECT_EQ(result, INNER_ERR);
2018 } else {
2019 EXPECT_EQ(result, ERR_OK);
2020 }
2021 }
2022
2023 /*
2024 * Feature: AbilityManagerService
2025 * Function: RequestModalUIExtensionInner
2026 * FunctionPoints: AbilityManagerService RequestModalUIExtensionInner
2027 */
2028 HWTEST_F(AbilityManagerServiceThirdTest, RequestModalUIExtensionInner_001, TestSize.Level1)
2029 {
2030 auto abilityMs = std::make_shared<AbilityManagerService>();
2031 Want want;
2032 auto result = abilityMs->RequestModalUIExtensionInner(want);
2033 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
2034 EXPECT_EQ(result, INNER_ERR);
2035 } else {
2036 EXPECT_EQ(result, ERR_OK);
2037 }
2038 }
2039
2040 /*
2041 * Feature: AbilityManagerService
2042 * Function: ChangeAbilityVisibility
2043 * FunctionPoints: AbilityManagerService ChangeAbilityVisibility
2044 */
2045 HWTEST_F(AbilityManagerServiceThirdTest, ChangeAbilityVisibility_001, TestSize.Level1)
2046 {
2047 auto abilityMs = std::make_shared<AbilityManagerService>();
2048 sptr<IRemoteObject> token;
2049 bool isShow = true;
2050 auto result = abilityMs->ChangeAbilityVisibility(token, isShow);
2051 EXPECT_EQ(result, ERR_CAPABILITY_NOT_SUPPORT);
2052 }
2053
2054 /*
2055 * Feature: AbilityManagerService
2056 * Function: ChangeUIAbilityVisibilityBySCB
2057 * FunctionPoints: AbilityManagerService ChangeUIAbilityVisibilityBySCB
2058 */
2059 HWTEST_F(AbilityManagerServiceThirdTest, ChangeUIAbilityVisibilityBySCB_001, TestSize.Level1)
2060 {
2061 auto abilityMs = std::make_shared<AbilityManagerService>();
2062 sptr<SessionInfo> sessionInfo;
2063 bool isShow = true;
2064 auto result = abilityMs->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow);
2065 EXPECT_EQ(result, ERR_WRONG_INTERFACE_CALL);
2066 }
2067
2068 #ifdef WITH_DLP
2069 /*
2070 * Feature: AbilityManagerService
2071 * Function: StartExtensionAbilityInner
2072 * FunctionPoints: AbilityManagerService StartExtensionAbilityInner
2073 */
2074 HWTEST_F(AbilityManagerServiceThirdTest, StartExtensionAbilityInner_001, TestSize.Level1)
2075 {
2076 auto abilityMs = std::make_shared<AbilityManagerService>();
2077 Want want;
2078 sptr<IRemoteObject> callerToken = nullptr;
2079 int32_t userId = 0;
2080 AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::VPN;
2081 bool checkSystemCaller = true;
2082 bool isImplicit = true;
2083 bool isDlp = true;
2084 auto result = abilityMs->StartExtensionAbilityInner(want, callerToken, userId, extensionType, checkSystemCaller,
2085 isImplicit, isDlp);
2086 EXPECT_EQ(result, ERR_INVALID_VALUE);
2087 }
2088
2089 /*
2090 * Feature: AbilityManagerService
2091 * Function: StartExtensionAbilityInner
2092 * FunctionPoints: AbilityManagerService StartExtensionAbilityInner
2093 */
2094 HWTEST_F(AbilityManagerServiceThirdTest, StartExtensionAbilityInner_002, TestSize.Level1)
2095 {
2096 auto abilityMs = std::make_shared<AbilityManagerService>();
2097 Want want;
2098 sptr<IRemoteObject> callerToken = new AbilityManagerStubTestMock();
2099 int32_t userId = 0;
2100 AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::VPN;
2101 bool checkSystemCaller = true;
2102 bool isImplicit = true;
2103 bool isDlp = true;
2104 auto result = abilityMs->StartExtensionAbilityInner(want, callerToken, userId, extensionType, checkSystemCaller,
2105 isImplicit, isDlp);
2106 EXPECT_EQ(result, ERR_INVALID_CALLER);
2107 }
2108
2109 /*
2110 * Feature: AbilityManagerService
2111 * Function: StartExtensionAbilityInner
2112 * FunctionPoints: AbilityManagerService StartExtensionAbilityInner
2113 */
2114 HWTEST_F(AbilityManagerServiceThirdTest, StartExtensionAbilityInner_003, TestSize.Level1)
2115 {
2116 auto abilityMs = std::make_shared<AbilityManagerService>();
2117 Want want;
2118 sptr<IRemoteObject> callerToken = new AbilityManagerStubTestMock();
2119 int32_t userId = 0;
2120 AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::VPN;
2121 bool checkSystemCaller = true;
2122 bool isImplicit = true;
2123 bool isDlp = false;
2124 auto result = abilityMs->StartExtensionAbilityInner(want, callerToken, userId, extensionType, checkSystemCaller,
2125 isImplicit, isDlp);
2126 EXPECT_EQ(result, ERR_INVALID_CALLER);
2127 }
2128
2129 /*
2130 * Feature: AbilityManagerService
2131 * Function: StartExtensionAbilityInner
2132 * FunctionPoints: AbilityManagerService StartExtensionAbilityInner
2133 */
2134 HWTEST_F(AbilityManagerServiceThirdTest, StartExtensionAbilityInner_004, TestSize.Level1)
2135 {
2136 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest StartExtensionAbilityInner_004 start");
2137 auto abilityMs = std::make_shared<AbilityManagerService>();
2138 Want want;
2139 sptr<IRemoteObject> callerToken = nullptr;
2140 int32_t userId = 0;
2141 AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::VPN;
2142 bool checkSystemCaller = true;
2143 bool isImplicit = true;
2144 bool isDlp = true;
2145 abilityMs->interceptorExecuter_ = std::make_shared<AbilityInterceptorExecuter>();
2146 abilityMs->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
2147 auto result = abilityMs->StartExtensionAbilityInner(want, callerToken, userId, extensionType, checkSystemCaller,
2148 isImplicit, isDlp);
2149 EXPECT_EQ(result, ERR_IMPLICIT_START_ABILITY_FAIL);
2150
2151 abilityMs-> implicitStartProcessor_ = std::make_shared<ImplicitStartProcessor>();
2152 result = abilityMs->StartExtensionAbilityInner(want, callerToken, userId, extensionType, checkSystemCaller,
2153 isImplicit, isDlp);
2154 EXPECT_EQ(result, ERR_IMPLICIT_START_ABILITY_FAIL);
2155 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest StartExtensionAbilityInner_004 end");
2156 }
2157 #endif // WITH_DLP
2158
2159 /*
2160 * Feature: AbilityManagerService
2161 * Function: MoveAbilityToBackground
2162 * FunctionPoints: AbilityManagerService MoveAbilityToBackground
2163 */
2164 HWTEST_F(AbilityManagerServiceThirdTest, MoveAbilityToBackground_001, TestSize.Level1)
2165 {
2166 auto abilityMs = std::make_shared<AbilityManagerService>();
2167 sptr<IRemoteObject> token = nullptr;
2168 auto result = abilityMs->MoveAbilityToBackground(token);
2169 EXPECT_EQ(result, ERR_INVALID_VALUE);
2170 }
2171
2172 /*
2173 * Feature: AbilityManagerService
2174 * Function: GetLocalDeviceId
2175 * FunctionPoints: AbilityManagerService GetLocalDeviceId
2176 */
2177 HWTEST_F(AbilityManagerServiceThirdTest, GetLocalDeviceId_001, TestSize.Level1)
2178 {
2179 auto abilityMs = std::make_shared<AbilityManagerService>();
2180 std::string localDeviceId = "device";
2181 auto result = abilityMs->GetLocalDeviceId(localDeviceId);
2182 EXPECT_EQ(result, false);
2183 }
2184
2185 /*
2186 * Feature: AbilityManagerService
2187 * Function: AnonymizeDeviceId
2188 * FunctionPoints: AbilityManagerService AnonymizeDeviceId
2189 */
2190 HWTEST_F(AbilityManagerServiceThirdTest, AnonymizeDeviceId_001, TestSize.Level1)
2191 {
2192 auto abilityMs = std::make_shared<AbilityManagerService>();
2193 std::string localDeviceId = "device";
2194 auto result = abilityMs->AnonymizeDeviceId(localDeviceId);
2195 EXPECT_NE(result, EMPTY_DEVICE_ID);
2196 }
2197
2198 /*
2199 * Feature: AbilityManagerService
2200 * Function: AnonymizeDeviceId
2201 * FunctionPoints: AbilityManagerService AnonymizeDeviceId
2202 */
2203 HWTEST_F(AbilityManagerServiceThirdTest, AnonymizeDeviceId_002, TestSize.Level1)
2204 {
2205 auto abilityMs = std::make_shared<AbilityManagerService>();
2206 std::string localDeviceId = "";
2207 auto result = abilityMs->AnonymizeDeviceId(localDeviceId);
2208 EXPECT_EQ(result, EMPTY_DEVICE_ID);
2209 }
2210
2211 /*
2212 * Feature: AbilityManagerService
2213 * Function: OpenLink
2214 * FunctionPoints: AbilityManagerService OpenLink
2215 */
2216 HWTEST_F(AbilityManagerServiceThirdTest, OpenLink_001, TestSize.Level1)
2217 {
2218 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2219 EXPECT_NE(abilityMs_, nullptr);
2220 sptr<IRemoteObject> token = MockToken(AbilityType::PAGE);
2221 AAFwk::Want want;
2222 Uri uri("");
2223 want.GetOperation().SetUri(uri);
2224
2225 auto result = abilityMs_->OpenLink(want, token, USER_ID_U100, REQUESTCODE);
2226 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest OpenLink_001 call result %{public}d", result);
2227 }
2228
2229 /*
2230 * Feature: AbilityManagerService
2231 * Function: NotifySCBToHandleAtomicServiceException
2232 * FunctionPoints: AbilityManagerService NotifySCBToHandleAtomicServiceException
2233 */
2234 HWTEST_F(AbilityManagerServiceThirdTest, NotifySCBToHandleAtomicServiceException_001, TestSize.Level1)
2235 {
2236 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2237 EXPECT_NE(abilityMs_, nullptr);
2238
2239 int32_t errCode = 0;
2240 std::string reason;
2241 abilityMs_->NotifySCBToHandleAtomicServiceException(SESSIONID, errCode, reason);
2242 }
2243
2244 /*
2245 * Feature: AbilityManagerService
2246 * Function: StartUIAbilityByPreInstallInner
2247 * FunctionPoints: AbilityManagerService StartUIAbilityByPreInstallInner
2248 */
2249 HWTEST_F(AbilityManagerServiceThirdTest, StartUIAbilityByPreInstallInner_001, TestSize.Level1)
2250 {
2251 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2252 EXPECT_NE(abilityMs_, nullptr);
2253
2254 FreeInstallInfo taskInfo;
2255 auto result2 = abilityMs_->StartUIAbilityByPreInstall(taskInfo);
2256 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest StartUIAbilityByPreInstallInner_001 result2 %{public}d",
2257 result2);
2258 }
2259
2260 /*
2261 * Feature: AbilityManagerService
2262 * Function: PreStartInner
2263 * FunctionPoints: AbilityManagerService PreStartInner
2264 */
2265 HWTEST_F(AbilityManagerServiceThirdTest, PreStartInner_001, TestSize.Level1)
2266 {
2267 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2268 EXPECT_NE(abilityMs_, nullptr);
2269
2270 FreeInstallInfo taskInfo;
2271 auto result = abilityMs_->PreStartInner(taskInfo);
2272 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest PreStartInner_001 call result %{public}d", result);
2273 }
2274
2275 /*
2276 * Feature: AbilityManagerService
2277 * Function: PreStartMission
2278 * FunctionPoints: PreStartMission
2279 */
2280 HWTEST_F(AbilityManagerServiceThirdTest, PreStartMission_001, TestSize.Level1)
2281 {
2282 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2283 EXPECT_NE(abilityMs_, nullptr);
2284
2285 auto result = abilityMs_->PreStartMission("com.ix.hiservcie", "entry", "ServiceAbility", "2024-07-16 10:00:00");
2286 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest PreStartMission_001 call result %{public}d", result);
2287 }
2288
2289 /*
2290 * Feature: AbilityManagerService
2291 * Function: HandleRestartResidentProcessDependedOnWeb
2292 * FunctionPoints: HandleRestartResidentProcessDependedOnWeb
2293 */
2294 HWTEST_F(AbilityManagerServiceThirdTest, HandleRestartResidentProcessDependedOnWeb_001, TestSize.Level1)
2295 {
2296 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2297 EXPECT_NE(abilityMs_, nullptr);
2298
2299 abilityMs_->HandleRestartResidentProcessDependedOnWeb();
2300 }
2301
2302 /*
2303 * Feature: AbilityManagerService
2304 * Function: NotifyFrozenProcessByRSS
2305 * FunctionPoints: NotifyFrozenProcessByRSS
2306 */
2307 HWTEST_F(AbilityManagerServiceThirdTest, NotifyFrozenProcessByRSS_001, TestSize.Level1)
2308 {
2309 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2310 EXPECT_NE(abilityMs_, nullptr);
2311
2312 std::vector<int32_t> pidList;
2313 int32_t UID = 1000;
2314 abilityMs_->NotifyFrozenProcessByRSS(pidList, UID);
2315 }
2316
2317 /*
2318 * Feature: AbilityManagerService
2319 * Function: TransferAbilityResultForExtension
2320 * FunctionPoints: TransferAbilityResultForExtension
2321 */
2322 HWTEST_F(AbilityManagerServiceThirdTest, TransferAbilityResultForExtension_001, TestSize.Level1)
2323 {
2324 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2325 EXPECT_NE(abilityMs_, nullptr);
2326
2327 AAFwk::Want want;
2328 sptr<IRemoteObject> token = MockToken(AbilityType::PAGE);
2329 int32_t resultCode = 0;
2330 auto result = abilityMs_->TransferAbilityResultForExtension(token, resultCode, want);
2331 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest TransferAbilityResultForExtension %{public}d", result);
2332 }
2333
2334 /*
2335 * Feature: AbilityManagerService
2336 * Function: StartShortcut
2337 * FunctionPoints: StartShortcut
2338 */
2339 HWTEST_F(AbilityManagerServiceThirdTest, StartShortcut_001, TestSize.Level1)
2340 {
2341 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2342 EXPECT_NE(abilityMs_, nullptr);
2343
2344 AAFwk::Want want;
2345 StartOptions startOp;
2346 auto result = abilityMs_->StartShortcut(want, startOp);
2347 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirdTest StartShortcut %{public}d", result);
2348 }
2349
2350 /*
2351 * Feature: AbilityManagerService
2352 * Function: ConvertFullPath
2353 * FunctionPoints: ConvertFullPath
2354 */
2355 HWTEST_F(AbilityManagerServiceThirdTest, ConvertFullPath_001, TestSize.Level1)
2356 {
2357 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2358 EXPECT_NE(abilityMs_, nullptr);
2359
2360 std::string partialPath = "";
2361 std::string fullPath;
2362 EXPECT_EQ(abilityMs_->ConvertFullPath(partialPath, fullPath), false);
2363
2364 partialPath = "hello";
2365 EXPECT_NE(abilityMs_->ConvertFullPath(partialPath, fullPath), true);
2366 }
2367
2368 /*
2369 * Feature: AbilityManagerService
2370 * Function: ParseJsonValueFromFile
2371 * FunctionPoints: ParseJsonValueFromFile
2372 */
2373 HWTEST_F(AbilityManagerServiceThirdTest, ParseJsonValueFromFile_001, TestSize.Level1)
2374 {
2375 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2376 EXPECT_NE(abilityMs_, nullptr);
2377
2378 std::string filePath = "hello";
2379 nlohmann::json value;
2380 abilityMs_->ParseJsonValueFromFile(value, filePath);
2381 }
2382
2383 /*
2384 * Feature: AbilityManagerService
2385 * Function: GetConfigFileAbsolutePath
2386 * FunctionPoints: GetConfigFileAbsolutePath
2387 */
2388 HWTEST_F(AbilityManagerServiceThirdTest, GetConfigFileAbsolutePath_001, TestSize.Level1)
2389 {
2390 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2391 EXPECT_NE(abilityMs_, nullptr);
2392
2393 EXPECT_EQ(abilityMs_->GetConfigFileAbsolutePath(""), "");
2394 std::string relativePath = "hello";
2395 abilityMs_->GetConfigFileAbsolutePath(relativePath);
2396 }
2397
2398 /*
2399 * Feature: AbilityManagerService
2400 * Function: ParseJsonFromBoot
2401 * FunctionPoints: ParseJsonFromBoot
2402 */
2403 HWTEST_F(AbilityManagerServiceThirdTest, ParseJsonFromBoot_001, TestSize.Level1)
2404 {
2405 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2406 EXPECT_NE(abilityMs_, nullptr);
2407
2408 abilityMs_->ParseJsonFromBoot("");
2409 }
2410
2411 /*
2412 * Feature: AbilityManagerService
2413 * Function: IsInWhiteList
2414 * FunctionPoints: IsInWhiteList
2415 */
2416 HWTEST_F(AbilityManagerServiceThirdTest, IsInWhiteList_001, TestSize.Level1)
2417 {
2418 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2419 EXPECT_NE(abilityMs_, nullptr);
2420
2421 abilityMs_->IsInWhiteList("", "", "");
2422 }
2423
2424 /*
2425 * Feature: AbilityManagerService
2426 * Function: ReportPreventStartAbilityResult
2427 * FunctionPoints: ReportPreventStartAbilityResult
2428 */
2429 HWTEST_F(AbilityManagerServiceThirdTest, ReportPreventStartAbilityResult_001, TestSize.Level1)
2430 {
2431 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2432 EXPECT_NE(abilityMs_, nullptr);
2433
2434 AppExecFwk::AbilityInfo abilityInfo;
2435 AppExecFwk::AbilityInfo abilityInfo2;
2436 abilityMs_->ReportPreventStartAbilityResult(abilityInfo, abilityInfo2);
2437 }
2438
2439 /*
2440 * Feature: AbilityManagerService
2441 * Function: ShouldPreventStartAbility
2442 * FunctionPoints: ShouldPreventStartAbility
2443 */
2444 HWTEST_F(AbilityManagerServiceThirdTest, ShouldPreventStartAbility_001, TestSize.Level1)
2445 {
2446 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2447 EXPECT_NE(abilityMs_, nullptr);
2448
2449 AbilityRequest abilityRequest;
2450 abilityRequest.appInfo.bundleName = "com.test.demo";
2451 abilityRequest.abilityInfo.name = "MainAbility";
2452 abilityRequest.abilityInfo.type = AbilityType::PAGE;
2453
2454 abilityMs_->ShouldPreventStartAbility(abilityRequest);
2455 }
2456
2457 /*
2458 * Feature: AbilityManagerService
2459 * Function: IsEmbeddedOpenAllowed
2460 * FunctionPoints: IsEmbeddedOpenAllowed
2461 */
2462 HWTEST_F(AbilityManagerServiceThirdTest, IsEmbeddedOpenAllowed_001, TestSize.Level1)
2463 {
2464 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2465 EXPECT_NE(abilityMs_, nullptr);
2466
2467 sptr<IRemoteObject> token = MockToken(AbilityType::PAGE);
2468 abilityMs_->IsEmbeddedOpenAllowed(token, APPID);
2469 }
2470
2471 /*
2472 * Feature: AbilityManagerService
2473 * Function: SignRestartAppFlag
2474 * FunctionPoints: SignRestartAppFlag
2475 */
2476 HWTEST_F(AbilityManagerServiceThirdTest, SignRestartAppFlag_001, TestSize.Level1)
2477 {
2478 auto abilityMs_ = std::make_shared<AbilityManagerService>();
2479 EXPECT_NE(abilityMs_, nullptr);
2480
2481 int32_t uid = 100;
2482 abilityMs_->SignRestartAppFlag(USER_ID_U100, uid, "", AppExecFwk::MultiAppModeType::UNSPECIFIED, 1);
2483 }
2484
2485 /*
2486 * Feature: AbilityManagerService
2487 * Function: StartUIAbilityByPreInstall
2488 * FunctionPoints: AbilityManagerService StartUIAbilityByPreInstall free install not finished
2489 */
2490 HWTEST_F(AbilityManagerServiceThirdTest, AbilityManagerServiceTest_StartUIAbilityByPreInstall_001, TestSize.Level1)
2491 {
2492 auto abilityMs = std::make_shared<AbilityManagerService>();
2493 EXPECT_NE(abilityMs, nullptr);
2494 FreeInstallInfo taskInfo = {
2495 .isFreeInstallFinished = false,
2496 };
2497 int32_t res = abilityMs->StartUIAbilityByPreInstall(taskInfo);
2498 EXPECT_EQ(res, ERR_INVALID_VALUE);
2499 }
2500
2501 /*
2502 * Feature: AbilityManagerService
2503 * Function: StartUIAbilityByPreInstall
2504 * FunctionPoints: AbilityManagerService StartUIAbilityByPreInstall free install failed
2505 */
2506 HWTEST_F(AbilityManagerServiceThirdTest, AbilityManagerServiceTest_StartUIAbilityByPreInstall_002, TestSize.Level1)
2507 {
2508 auto abilityMs = std::make_shared<AbilityManagerService>();
2509 EXPECT_NE(abilityMs, nullptr);
2510 FreeInstallInfo taskInfo = {
2511 .isInstalled = false,
2512 };
2513 int32_t res = abilityMs->StartUIAbilityByPreInstall(taskInfo);
2514 EXPECT_EQ(res, ERR_INVALID_VALUE);
2515 }
2516
2517 /*
2518 * Feature: AbilityManagerService
2519 * Function: StartUIAbilityByPreInstall
2520 * FunctionPoints: AbilityManagerService StartUIAbilityByPreInstall StartUIAbilityBySCB not called
2521 */
2522 HWTEST_F(AbilityManagerServiceThirdTest, AbilityManagerServiceTest_StartUIAbilityByPreInstall_003, TestSize.Level1)
2523 {
2524 auto abilityMs = std::make_shared<AbilityManagerService>();
2525 EXPECT_NE(abilityMs, nullptr);
2526 FreeInstallInfo taskInfo = {
2527 .isStartUIAbilityBySCBCalled = false,
2528 };
2529 int32_t res = abilityMs->StartUIAbilityByPreInstall(taskInfo);
2530 EXPECT_EQ(res, ERR_INVALID_VALUE);
2531 }
2532
2533 /*
2534 * Feature: AbilityManagerService
2535 * Function: StartUIAbilityByPreInstall
2536 * FunctionPoints: AbilityManagerService StartUIAbilityByPreInstall empty sessionId
2537 */
2538 HWTEST_F(AbilityManagerServiceThirdTest, AbilityManagerServiceTest_StartUIAbilityByPreInstall_004, TestSize.Level1)
2539 {
2540 auto abilityMs = std::make_shared<AbilityManagerService>();
2541 EXPECT_NE(abilityMs, nullptr);
2542 FreeInstallInfo taskInfo = {
2543 .isFreeInstallFinished = true,
2544 .isInstalled = true,
2545 .isStartUIAbilityBySCBCalled = true,
2546 };
2547 int32_t res = abilityMs->StartUIAbilityByPreInstall(taskInfo);
2548 EXPECT_EQ(res, ERR_INVALID_VALUE);
2549 }
2550
2551 /*
2552 * Feature: AbilityManagerService
2553 * Function: StartUIAbilityByPreInstall
2554 * FunctionPoints: AbilityManagerService StartUIAbilityByPreInstall session not found
2555 */
2556 HWTEST_F(AbilityManagerServiceThirdTest, AbilityManagerServiceTest_StartUIAbilityByPreInstall_005, TestSize.Level1)
2557 {
2558 auto abilityMs = std::make_shared<AbilityManagerService>();
2559 EXPECT_NE(abilityMs, nullptr);
2560 Want want;
2561 std::string sessionId = "1234567890";
2562 want.SetParam(KEY_SESSION_ID, sessionId);
2563 FreeInstallInfo taskInfo = {
2564 .want = want,
2565 .isFreeInstallFinished = true,
2566 .isInstalled = true,
2567 .isStartUIAbilityBySCBCalled = true,
2568 };
2569 int32_t res = abilityMs->StartUIAbilityByPreInstall(taskInfo);
2570 EXPECT_EQ(res, ERR_INVALID_VALUE);
2571 }
2572
2573 /*
2574 * Feature: AbilityManagerService
2575 * Function: RemovePreStartSession
2576 * FunctionPoints: AbilityManagerService RemovePreStartSession
2577 */
2578 HWTEST_F(AbilityManagerServiceThirdTest, AbilityManagerServiceTest_RemovePreStartSession_001, TestSize.Level1)
2579 {
2580 auto abilityMs = std::make_shared<AbilityManagerService>();
2581 EXPECT_NE(abilityMs, nullptr);
2582 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
2583 std::string sessionId = "123456";
2584 (abilityMs->preStartSessionMap_).insert(std::make_pair(sessionId, sessionInfo));
2585 abilityMs->RemovePreStartSession(sessionId);
2586 EXPECT_EQ((abilityMs->preStartSessionMap_).find(sessionId), (abilityMs->preStartSessionMap_).end());
2587 }
2588
2589 /*
2590 * Feature: AbilityManagerService
2591 * Function: PreStartMission
2592 * FunctionPoints: AbilityManagerService PreStartMission permission denied
2593 */
2594 HWTEST_F(AbilityManagerServiceThirdTest, AbilityManagerServiceTest_PreStartMission_001, TestSize.Level1)
2595 {
2596 auto abilityMs = std::make_shared<AbilityManagerService>();
2597 EXPECT_NE(abilityMs, nullptr);
2598 int res = abilityMs->PreStartMission("bundle", "module", "ability", "startTime");
2599 EXPECT_EQ(res, ERR_PERMISSION_DENIED);
2600 }
2601
2602 /*
2603 * Feature: AbilityManagerService
2604 * Function: OpenLink
2605 * FunctionPoints: AbilityManagerService OpenLink
2606 */
2607 HWTEST_F(AbilityManagerServiceThirdTest, AbilityManagerServiceTest_OpenLink_001, TestSize.Level1)
2608 {
2609 auto abilityMs = std::make_shared<AbilityManagerService>();
2610 EXPECT_NE(abilityMs, nullptr);
2611 Want want;
2612 sptr<IRemoteObject> callerToken = nullptr;
2613 int res = abilityMs->OpenLink(want, callerToken, 0, -1);
2614 EXPECT_NE(res, ERR_OK);
2615 }
2616
2617 /*
2618 * Feature: AbilityManagerService
2619 * Function: CheckUIExtensionCallerPidByHostWindowId
2620 * FunctionPoints: AbilityManagerService CheckUIExtensionCallerPidByHostWindowId
2621 */
2622 HWTEST_F(AbilityManagerServiceThirdTest, CheckUIExtensionCallerPidByHostWindowId_001, TestSize.Level1)
2623 {
2624 auto abilityMs = std::make_shared<AbilityManagerService>();
2625 ASSERT_NE(abilityMs, nullptr);
2626 AbilityRequest abilityRequest = GenerateAbilityRequest("0", "abilityName", "appName", "bundleName", "moduleName");
2627 sptr<IRemoteObject> token = MockToken(AbilityType::PAGE);
2628 ASSERT_NE(token, nullptr);
2629 abilityRequest.callerToken = token;
2630 auto sessionInfo = sptr<SessionInfo>::MakeSptr();
2631 ASSERT_NE(sessionInfo, nullptr);
2632 sessionInfo->hostWindowId = 1;
2633 abilityRequest.sessionInfo = sessionInfo;
2634 abilityMs->CheckUIExtensionCallerPidByHostWindowId(abilityRequest);
2635 }
2636
2637 /*
2638 * Feature: AbilityManagerService
2639 * Function: CheckUIExtensionCallerPidByHostWindowId
2640 * FunctionPoints: AbilityManagerService CheckUIExtensionCallerPidByHostWindowId
2641 */
2642 HWTEST_F(AbilityManagerServiceThirdTest, CheckUIExtensionCallerPidByHostWindowId_002, TestSize.Level1)
2643 {
2644 auto abilityMs = std::make_shared<AbilityManagerService>();
2645 ASSERT_NE(abilityMs, nullptr);
2646 AbilityRequest callerRequest = GenerateAbilityRequest("0", "abilityName", "appName", "bundleName", "moduleName");
2647 callerRequest.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
2648 auto callerRecord = AbilityRecord::CreateAbilityRecord(callerRequest);
2649 ASSERT_NE(callerRecord, nullptr);
2650
2651 AbilityRequest abilityRequest = GenerateAbilityRequest("0", "abilityName", "appName", "bundleName", "moduleName");
2652 abilityRequest.callerToken = callerRecord->GetToken();
2653 auto sessionInfo = sptr<SessionInfo>::MakeSptr();
2654 ASSERT_NE(sessionInfo, nullptr);
2655 sessionInfo->hostWindowId = 1;
2656 abilityRequest.sessionInfo = sessionInfo;
2657 abilityMs->CheckUIExtensionCallerPidByHostWindowId(abilityRequest);
2658 }
2659 } // namespace AAFwk
2660 } // namespace OHOS
2661