1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "ability_connection.h"
19 #include "ability_connect_manager.h"
20 #include "ability_manager_errors.h"
21 #include "ability_manager_service.h"
22 #include "auto_startup_info.h"
23 #include "ability_start_setting.h"
24 #include "connection_observer_errors.h"
25 #include "data_ability_manager.h"
26 #include "hilog_tag_wrapper.h"
27 #include "mock_task_handler_wrap.h"
28 #include "start_ability_utils.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32 using namespace OHOS::AppExecFwk;
33 using OHOS::AppExecFwk::AbilityType;
34 using OHOS::AppExecFwk::ExtensionAbilityType;
35 using DataAbilityRecordPtr = std::shared_ptr<DataAbilityRecord>;
36 using DataAbilityRecordPtrMap = std::map<std::string, DataAbilityRecordPtr>;
37 namespace OHOS {
38 namespace AAFwk {
39 namespace {
40 const int32_t USER_ID_U100 = 100;
41 const int32_t MIN_DUMP_ARGUMENT_NUM = 2;
42 const int32_t MAX_APP_CLONE_INDEX_NUM = 10000;
43 } // namespace
44
45 class MockAbilityToken : public IRemoteStub<IAbilityToken> {
46 public:
47 MockAbilityToken() = default;
48 virtual ~MockAbilityToken() = default;
49
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)50 virtual int OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
51 {
52 return 0;
53 }
54
55 private:
56 DISALLOW_COPY_AND_MOVE(MockAbilityToken);
57 };
58
59 class AbilityManagerServiceTenhtTest : public testing::Test {
60 public:
61 static void SetUpTestCase();
62 static void TearDownTestCase();
63 void SetUp();
64 void TearDown();
65
66 std::shared_ptr<AbilityRecord> GetAbilityRecord();
67 };
68
SetUpTestCase()69 void AbilityManagerServiceTenhtTest::SetUpTestCase() {}
70
TearDownTestCase()71 void AbilityManagerServiceTenhtTest::TearDownTestCase() {}
72
SetUp()73 void AbilityManagerServiceTenhtTest::SetUp() {}
74
TearDown()75 void AbilityManagerServiceTenhtTest::TearDown() {}
76
GetAbilityRecord()77 std::shared_ptr<AbilityRecord> AbilityManagerServiceTenhtTest::GetAbilityRecord()
78 {
79 AbilityRequest abilityRequest;
80 abilityRequest.appInfo.bundleName = "com.example.unittest";
81 abilityRequest.abilityInfo.name = "MainAbility";
82 abilityRequest.abilityInfo.type = AbilityType::PAGE;
83 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
84 return abilityRecord;
85 }
86
87 /*
88 * Feature: AbilityManagerService
89 * Function: DumpStateInner
90 * SubFunction: NA
91 * FunctionPoints: AbilityManagerServiceTenhtTest DumpStateInner
92 */
93 HWTEST_F(AbilityManagerServiceTenhtTest, DumpStateInner_001, TestSize.Level1)
94 {
95 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DumpStateInner_001 start");
96 auto abilityMs_ = std::make_shared<AbilityManagerService>();
97 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
98 abilityMs_->subManagersHelper_->currentConnectManager_ = std::make_shared<AbilityConnectManager>(0);
99
100 std::string args = "";
101 std::vector<std::string> info;
102 abilityMs_->DumpStateInner(args, info);
103 ASSERT_NE(args.size(), MIN_DUMP_ARGUMENT_NUM);
104
105 args = "invalid argument ";
106 abilityMs_->DumpStateInner(args, info);
107
108 args = "invalid ";
109 abilityMs_->DumpStateInner(args, info);
110
111 args = "invalid argument DumpStateInner argument";
112 abilityMs_->DumpStateInner(args, info);
113 ASSERT_NE(args.size(), MIN_DUMP_ARGUMENT_NUM);
114 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DumpStateInner_001 end");
115 }
116
117 /*
118 * Feature: AbilityManagerService
119 * Function: DataDumpStateInner
120 * SubFunction: NA
121 * FunctionPoints: AbilityManagerServiceTenhtTest DataDumpStateInner
122 */
123 HWTEST_F(AbilityManagerServiceTenhtTest, DataDumpStateInner_001, TestSize.Level1)
124 {
125 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DataDumpStateInner_001 start");
126 auto abilityMs_ = std::make_shared<AbilityManagerService>();
127 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
128 abilityMs_->subManagersHelper_->currentDataAbilityManager_ = std::make_shared<DataAbilityManager>();
129
130 std::string args = "";
131 std::vector<std::string> info;
132 abilityMs_->DataDumpStateInner(args, info);
133 ASSERT_NE(args.size(), MIN_DUMP_ARGUMENT_NUM);
134
135 args = "invalid argument ";
136 abilityMs_->DataDumpStateInner(args, info);
137
138 args = "invalid ";
139 abilityMs_->DataDumpStateInner(args, info);
140
141 args = "invalid argument DumpStateInner argument";
142 abilityMs_->DataDumpStateInner(args, info);
143 ASSERT_NE(args.size(), MIN_DUMP_ARGUMENT_NUM);
144 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DataDumpStateInner_001 end");
145 }
146
147 /*
148 * Feature: AbilityManagerService
149 * Function: ScheduleConnectAbilityDone
150 * SubFunction: NA
151 * FunctionPoints: AbilityManagerServiceTenhtTest ScheduleConnectAbilityDone
152 */
153 HWTEST_F(AbilityManagerServiceTenhtTest, ScheduleConnectAbilityDone_001, TestSize.Level1)
154 {
155 auto abilityMs_ = std::make_shared<AbilityManagerService>();
156 AbilityRequest abilityRequest;
157 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
158 abilityRequest.abilityInfo.bundleName = "bundleName";
159 abilityRequest.abilityInfo.name = "name";
160 abilityRequest.abilityInfo.applicationInfo.accessTokenId = 3;
161 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
162 std::shared_ptr<AbilityRecord> callerAbilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
163 auto callerToken = callerAbilityRecord->GetToken();
164 dataAbilityRecord->ability_ = callerAbilityRecord;
165 dataAbilityRecord->request_ = abilityRequest;
166 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
167 auto dataAbilityManager = std::make_shared<DataAbilityManager>();
168 dataAbilityManager->dataAbilityRecordsLoaded_["bundleName.name"] = dataAbilityRecord;
169 abilityMs_->subManagersHelper_->dataAbilityManagers_.emplace(USER_ID_U100, dataAbilityManager);
170 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
171 auto ret = abilityMs_->ScheduleConnectAbilityDone(callerToken, token);
172 ASSERT_EQ(ret, TARGET_ABILITY_NOT_SERVICE);
173
174 abilityRequest.abilityInfo.applicationInfo.accessTokenId = 5;
175 abilityRequest.abilityInfo.applicationInfo.uid = 2000;
176 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::SERVICE;
177 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
178 callerToken = abilityRecord->GetToken();
179 dataAbilityRecord->ability_ = abilityRecord;
180 dataAbilityRecord->request_ = abilityRequest;
181 dataAbilityManager->dataAbilityRecordsLoaded_["bundleName.name"] = dataAbilityRecord;
182 abilityMs_->subManagersHelper_->dataAbilityManagers_.clear();
183 abilityMs_->subManagersHelper_->dataAbilityManagers_.emplace(USER_ID_U100, dataAbilityManager);
184 ret = abilityMs_->ScheduleConnectAbilityDone(callerToken, token);
185 ASSERT_EQ(ret, ERR_INVALID_VALUE);
186
187 auto connectManager = std::make_shared<AbilityConnectManager>(0);
188 abilityMs_->subManagersHelper_->connectManagers_[2000 / BASE_USER_RANGE] = connectManager;
189 ret = abilityMs_->ScheduleConnectAbilityDone(callerToken, token);
190 ASSERT_NE(ret, ERR_INVALID_VALUE);
191 }
192
193 /*
194 * Feature: AbilityManagerService
195 * Function: ScheduleDisconnectAbilityDone
196 * SubFunction: NA
197 * FunctionPoints: AbilityManagerServiceTenhtTest ScheduleDisconnectAbilityDone
198 */
199 HWTEST_F(AbilityManagerServiceTenhtTest, ScheduleDisconnectAbilityDone_001, TestSize.Level1)
200 {
201 auto abilityMs_ = std::make_shared<AbilityManagerService>();
202 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
203 EXPECT_EQ(abilityMs_->ScheduleDisconnectAbilityDone(token), ERR_INVALID_VALUE);
204
205 AbilityRequest abilityRequest;
206 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
207 abilityRequest.abilityInfo.bundleName = "bundleName";
208 abilityRequest.abilityInfo.name = "name";
209 abilityRequest.abilityInfo.applicationInfo.accessTokenId = 3;
210 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
211 std::shared_ptr<AbilityRecord> callerAbilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
212 auto callerToken = callerAbilityRecord->GetToken();
213 dataAbilityRecord->ability_ = callerAbilityRecord;
214 dataAbilityRecord->request_ = abilityRequest;
215 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
216 auto dataAbilityManager = std::make_shared<DataAbilityManager>();
217 dataAbilityManager->dataAbilityRecordsLoaded_["bundleName.name"] = dataAbilityRecord;
218 abilityMs_->subManagersHelper_->dataAbilityManagers_.emplace(USER_ID_U100, dataAbilityManager);
219 auto ret = abilityMs_->ScheduleDisconnectAbilityDone(callerToken);
220 ASSERT_EQ(ret, TARGET_ABILITY_NOT_SERVICE);
221
222 abilityRequest.abilityInfo.applicationInfo.accessTokenId = 5;
223 abilityRequest.abilityInfo.applicationInfo.uid = 2000;
224 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::SERVICE;
225 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
226 callerToken = abilityRecord->GetToken();
227 dataAbilityRecord->ability_ = abilityRecord;
228 dataAbilityRecord->request_ = abilityRequest;
229 dataAbilityManager->dataAbilityRecordsLoaded_["bundleName.name"] = dataAbilityRecord;
230 abilityMs_->subManagersHelper_->dataAbilityManagers_.clear();
231 abilityMs_->subManagersHelper_->dataAbilityManagers_.emplace(USER_ID_U100, dataAbilityManager);
232 ret = abilityMs_->ScheduleDisconnectAbilityDone(callerToken);
233 ASSERT_EQ(ret, ERR_INVALID_VALUE);
234
235 auto connectManager = std::make_shared<AbilityConnectManager>(0);
236 abilityMs_->subManagersHelper_->connectManagers_[2000 / BASE_USER_RANGE] = connectManager;
237 ret = abilityMs_->ScheduleDisconnectAbilityDone(callerToken);
238 ASSERT_NE(ret, ERR_INVALID_VALUE);
239 }
240
241 /*
242 * Feature: AbilityManagerService
243 * Function: ScheduleCommandAbilityDone
244 * SubFunction: NA
245 * FunctionPoints: AbilityManagerServiceTenhtTest ScheduleCommandAbilityDone
246 */
247 HWTEST_F(AbilityManagerServiceTenhtTest, ScheduleCommandAbilityDone_001, TestSize.Level1)
248 {
249 auto abilityMs_ = std::make_shared<AbilityManagerService>();
250 AbilityRequest abilityRequest;
251 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
252 abilityRequest.abilityInfo.bundleName = "bundleName";
253 abilityRequest.abilityInfo.name = "name";
254 abilityRequest.abilityInfo.applicationInfo.accessTokenId = 3;
255 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
256 std::shared_ptr<AbilityRecord> callerAbilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
257 auto callerToken = callerAbilityRecord->GetToken();
258 dataAbilityRecord->ability_ = callerAbilityRecord;
259 dataAbilityRecord->request_ = abilityRequest;
260 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
261 auto dataAbilityManager = std::make_shared<DataAbilityManager>();
262 dataAbilityManager->dataAbilityRecordsLoaded_["bundleName.name"] = dataAbilityRecord;
263 abilityMs_->subManagersHelper_->dataAbilityManagers_.emplace(USER_ID_U100, dataAbilityManager);
264 auto ret = abilityMs_->ScheduleCommandAbilityDone(callerToken);
265 ASSERT_EQ(ret, TARGET_ABILITY_NOT_SERVICE);
266
267 abilityRequest.abilityInfo.applicationInfo.accessTokenId = 5;
268 abilityRequest.abilityInfo.applicationInfo.uid = 2000;
269 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::SERVICE;
270 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
271 callerToken = abilityRecord->GetToken();
272 dataAbilityRecord->ability_ = abilityRecord;
273 dataAbilityRecord->request_ = abilityRequest;
274 dataAbilityManager->dataAbilityRecordsLoaded_["bundleName.name"] = dataAbilityRecord;
275 abilityMs_->subManagersHelper_->dataAbilityManagers_.clear();
276 abilityMs_->subManagersHelper_->dataAbilityManagers_.emplace(USER_ID_U100, dataAbilityManager);
277 ret = abilityMs_->ScheduleCommandAbilityDone(callerToken);
278 ASSERT_EQ(ret, ERR_INVALID_VALUE);
279
280 auto connectManager = std::make_shared<AbilityConnectManager>(0);
281 abilityMs_->subManagersHelper_->connectManagers_[2000 / BASE_USER_RANGE] = connectManager;
282 ret = abilityMs_->ScheduleCommandAbilityDone(callerToken);
283 ASSERT_NE(ret, ERR_INVALID_VALUE);
284 }
285
286 /*
287 * Feature: AbilityManagerService
288 * Name: InitialAbilityRequest_001
289 * Function: InitialAbilityRequest
290 * SubFunction: NA
291 */
292 HWTEST_F(AbilityManagerServiceTenhtTest, InitialAbilityRequest_001, TestSize.Level1)
293 {
294 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest InitialAbilityRequest_001 start");
295 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
296 EXPECT_NE(abilityMs_, nullptr);
297 AbilityRequest request;
298 StartAbilityInfo abilityInfo;
299 auto result = abilityMs_->InitialAbilityRequest(request, abilityInfo);
300 EXPECT_EQ(result, RESOLVE_APP_ERR);
301 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest InitialAbilityRequest_001 end");
302 }
303
304 /*
305 * Feature: AbilityManagerService
306 * Name: InitialAbilityRequest_002
307 * Function: InitialAbilityRequest
308 * SubFunction: NA
309 */
310 HWTEST_F(AbilityManagerServiceTenhtTest, InitialAbilityRequest_002, TestSize.Level1)
311 {
312 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest InitialAbilityRequest_002 start");
313 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
314 EXPECT_NE(abilityMs_, nullptr);
315 AbilityRequest request;
316 StartAbilityInfo startAbilityInfo;
317 startAbilityInfo.abilityInfo.applicationInfo.name = "applicationInfo";
318 startAbilityInfo.abilityInfo.applicationInfo.bundleName = "bundleName";
319 startAbilityInfo.abilityInfo.moduleName = "moduleName";
320 auto result = abilityMs_->InitialAbilityRequest(request, startAbilityInfo);
321 EXPECT_EQ(result, ERR_OK);
322 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest InitialAbilityRequest_002 end");
323 }
324
325 /*
326 * Feature: AbilityManagerService
327 * Name: GetShareDataPairAndReturnData_001
328 * Function: GetShareDataPairAndReturnData
329 * SubFunction: NA
330 */
331 HWTEST_F(AbilityManagerServiceTenhtTest, GetShareDataPairAndReturnData_001, TestSize.Level1)
332 {
333 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest GetShareDataPairAndReturnData_001 start");
334 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
335 EXPECT_NE(abilityMs_, nullptr);
336 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
337 int32_t resultCode = 1;
338 int32_t uniqueId = 1;
339 WantParams wantParam;
340
341 auto result = abilityMs_->GetShareDataPairAndReturnData(abilityRecord, resultCode, uniqueId, wantParam);
342 EXPECT_EQ(result, ERR_INVALID_VALUE);
343 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest GetShareDataPairAndReturnData_001 end");
344 }
345
346 /*
347 * Feature: AbilityManagerService
348 * Name: GetShareDataPairAndReturnData_002
349 * Function: GetShareDataPairAndReturnData
350 * SubFunction: NA
351 */
352 HWTEST_F(AbilityManagerServiceTenhtTest, GetShareDataPairAndReturnData_002, TestSize.Level1)
353 {
354 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest GetShareDataPairAndReturnData_002 start");
355 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
356 EXPECT_NE(abilityMs_, nullptr);
357 sptr<IAcquireShareDataCallback> shareData = nullptr;
358 auto pair = std::make_pair(66, shareData);
359 int32_t num = 6;
360 abilityMs_->iAcquireShareDataMap_.insert(std::make_pair(num, pair));
361 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
362 abilityRecord->recordId_ = 8;
363 int32_t resultCode = 1;
364 int32_t uniqueId = 6;
365 WantParams wantParam;
366 auto result = abilityMs_->GetShareDataPairAndReturnData(abilityRecord, resultCode, uniqueId, wantParam);
367 EXPECT_EQ(result, ERR_INVALID_VALUE);
368 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest GetShareDataPairAndReturnData_002 end");
369 }
370
371 /*
372 * Feature: AbilityManagerService
373 * Name: GetShareDataPairAndReturnData_003
374 * Function: GetShareDataPairAndReturnData
375 * SubFunction: NA
376 */
377 HWTEST_F(AbilityManagerServiceTenhtTest, GetShareDataPairAndReturnData_003, TestSize.Level1)
378 {
379 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest GetShareDataPairAndReturnData_003 start");
380 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
381 EXPECT_NE(abilityMs_, nullptr);
382 sptr<IAcquireShareDataCallback> shareData = nullptr;
383 int32_t num1 = 66;
384 auto pair = std::make_pair(num1, shareData);
385 int32_t num2 = 6;
386 abilityMs_->iAcquireShareDataMap_.insert(std::make_pair(num2, pair));
387 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
388 abilityRecord->recordId_ = 66;
389 int32_t resultCode = 1;
390 int32_t uniqueId = 6;
391 WantParams wantParam;
392 auto result = abilityMs_->GetShareDataPairAndReturnData(abilityRecord, resultCode, uniqueId, wantParam);
393 EXPECT_EQ(result, ERR_INVALID_VALUE);
394 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest GetShareDataPairAndReturnData_003 end");
395 }
396
397 /*
398 * Feature: AbilityManagerService
399 * Name: GetScreenUnlockCallback_001
400 * Function: GetScreenUnlockCallback
401 * SubFunction: NA
402 */
403 HWTEST_F(AbilityManagerServiceTenhtTest, GetScreenUnlockCallback_001, TestSize.Level1)
404 {
405 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest GetScreenUnlockCallback_001 start");
406 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
407 EXPECT_NE(abilityMs_, nullptr);
408 abilityMs_->StartAutoStartupApps();
409 abilityMs_->abilityAutoStartupService_ = std::make_shared<AbilityAutoStartupService>();
410 abilityMs_->StartAutoStartupApps();
411 int32_t userId = 100;
412 abilityMs_->StartKeepAliveApps(userId);
413 auto screenUnlockCallback = abilityMs_->GetScreenUnlockCallback();
414 screenUnlockCallback();
415 EXPECT_NE(screenUnlockCallback, nullptr);
416 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest GetScreenUnlockCallback_001 end");
417 }
418
419 /*
420 * Feature: AbilityManagerService
421 * Name: SubscribeScreenUnlockedEvent_001
422 * Function: SubscribeScreenUnlockedEvent
423 * SubFunction: NA
424 */
425 HWTEST_F(AbilityManagerServiceTenhtTest, SubscribeScreenUnlockedEvent_001, TestSize.Level1)
426 {
427 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest SubscribeScreenUnlockedEvent_001 start");
428 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
429 EXPECT_NE(abilityMs_, nullptr);
430 int32_t userId = 100;
431 abilityMs_->StartResidentApps(userId);
432 std::queue<AutoStartupInfo> infoQueue;
433 abilityMs_->StartAutoStartupApps(infoQueue);
434 AutoStartupInfo autoStartupInfo;
435 infoQueue.push(autoStartupInfo);
436 abilityMs_->StartAutoStartupApps(infoQueue);
437 abilityMs_->SubscribeScreenUnlockedEvent();
438 EXPECT_NE(abilityMs_->screenSubscriber_, nullptr);
439 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest SubscribeScreenUnlockedEvent_001 end");
440 }
441
442 /*
443 * Feature: AbilityManagerService
444 * Name: ScheduleCommandAbilityWindowDone_001
445 * Function: ScheduleCommandAbilityWindowDone
446 * SubFunction: NA
447 */
448 HWTEST_F(AbilityManagerServiceTenhtTest, ScheduleCommandAbilityWindowDone_001, TestSize.Level1)
449 {
450 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest ScheduleCommandAbilityWindowDone_001 start");
451 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
452 EXPECT_NE(abilityMs_, nullptr);
453 sptr<IRemoteObject> token = nullptr;
454 sptr<SessionInfo> sessionInfo;
455 WindowCommand winCmd = WIN_CMD_FOREGROUND;
456 AbilityCommand abilityCmd = ABILITY_CMD_FOREGROUND;
457 auto ret = abilityMs_->ScheduleCommandAbilityWindowDone(token, sessionInfo, winCmd, abilityCmd);
458 EXPECT_EQ(ret, ERR_INVALID_VALUE);
459 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest ScheduleCommandAbilityWindowDone_001 end");
460 }
461
462 /*
463 * Feature: AbilityManagerService
464 * Name: ScheduleCommandAbilityWindowDone_002
465 * Function: ScheduleCommandAbilityWindowDone
466 * SubFunction: NA
467 */
468 HWTEST_F(AbilityManagerServiceTenhtTest, ScheduleCommandAbilityWindowDone_002, TestSize.Level1)
469 {
470 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest ScheduleCommandAbilityWindowDone_002 start");
471 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
472 EXPECT_NE(abilityMs_, nullptr);
473 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
474
475 std::shared_ptr<TaskHandlerWrap> taskHandler = nullptr;
476 std::shared_ptr<AbilityEventHandler> eventHandler = nullptr;
477 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(taskHandler, eventHandler);
478 auto dataAbilityManager = std::make_shared<DataAbilityManager>();
479 AbilityRequest req;
480 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(req);
481 dataAbilityRecord->ability_ = abilityRecord;
482 DataAbilityRecordPtrMap dataAbilityRecordPtrMap;
483 std::string test = "test";
484 dataAbilityRecordPtrMap.insert(std::make_pair(test, dataAbilityRecord));
485 dataAbilityManager->dataAbilityRecordsLoaded_ = dataAbilityRecordPtrMap;
486 int32_t num = 10;
487 abilityMs_->subManagersHelper_->dataAbilityManagers_.insert(std::make_pair(num, dataAbilityManager));
488
489 sptr<IRemoteObject> token = new Token(abilityRecord);
490 sptr<SessionInfo> sessionInfo;
491 WindowCommand winCmd = WIN_CMD_FOREGROUND;
492 AbilityCommand abilityCmd = ABILITY_CMD_FOREGROUND;
493 auto ret = abilityMs_->ScheduleCommandAbilityWindowDone(token, sessionInfo, winCmd, abilityCmd);
494 EXPECT_EQ(ret, ERR_INVALID_VALUE);
495 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest ScheduleCommandAbilityWindowDone_002 end");
496 }
497
498 /*
499 * Feature: AbilityManagerService
500 * Name: ScheduleCommandAbilityWindowDone_003
501 * Function: ScheduleCommandAbilityWindowDone
502 * SubFunction: NA
503 */
504 HWTEST_F(AbilityManagerServiceTenhtTest, ScheduleCommandAbilityWindowDone_003, TestSize.Level1)
505 {
506 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest ScheduleCommandAbilityWindowDone_003 start");
507 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
508 EXPECT_NE(abilityMs_, nullptr);
509 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
510 AppExecFwk::AbilityInfo abilityInfo;
511 abilityInfo.extensionAbilityType = ExtensionAbilityType::WINDOW;
512 abilityRecord->abilityInfo_ = abilityInfo;
513
514 std::shared_ptr<TaskHandlerWrap> taskHandler = nullptr;
515 std::shared_ptr<AbilityEventHandler> eventHandler = nullptr;
516 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(taskHandler, eventHandler);
517 auto dataAbilityManager = std::make_shared<DataAbilityManager>();
518 AbilityRequest req;
519 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(req);
520 dataAbilityRecord->ability_ = abilityRecord;
521 DataAbilityRecordPtrMap dataAbilityRecordPtrMap;
522 std::string test = "test";
523 dataAbilityRecordPtrMap.insert(std::make_pair(test, dataAbilityRecord));
524 dataAbilityManager->dataAbilityRecordsLoaded_ = dataAbilityRecordPtrMap;
525 int32_t num = 10;
526 abilityMs_->subManagersHelper_->dataAbilityManagers_.insert(std::make_pair(num, dataAbilityManager));
527
528 sptr<IRemoteObject> token = new Token(abilityRecord);
529 sptr<SessionInfo> sessionInfo;
530 WindowCommand winCmd = WIN_CMD_FOREGROUND;
531 AbilityCommand abilityCmd = ABILITY_CMD_FOREGROUND;
532 auto ret = abilityMs_->ScheduleCommandAbilityWindowDone(token, sessionInfo, winCmd, abilityCmd);
533 EXPECT_EQ(ret, ERR_INVALID_VALUE);
534 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest ScheduleCommandAbilityWindowDone_003 end");
535 }
536
537 /*
538 * Feature: AbilityManagerService
539 * Name: ScheduleCommandAbilityWindowDone_004
540 * Function: ScheduleCommandAbilityWindowDone
541 * SubFunction: NA
542 */
543 HWTEST_F(AbilityManagerServiceTenhtTest, ScheduleCommandAbilityWindowDone_004, TestSize.Level1)
544 {
545 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest ScheduleCommandAbilityWindowDone_004 start");
546 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
547 EXPECT_NE(abilityMs_, nullptr);
548 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
549 ApplicationInfo applicationInfo;
550 applicationInfo.uid = 2000000;
551 AppExecFwk::AbilityInfo abilityInfo;
552 abilityInfo.applicationInfo = applicationInfo;
553 abilityInfo.extensionAbilityType = ExtensionAbilityType::WINDOW;
554 abilityRecord->abilityInfo_ = abilityInfo;
555
556 std::shared_ptr<TaskHandlerWrap> taskHandler = nullptr;
557 std::shared_ptr<AbilityEventHandler> eventHandler = nullptr;
558 abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(taskHandler, eventHandler);
559 auto dataAbilityManager = std::make_shared<DataAbilityManager>();
560 AbilityRequest req;
561 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(req);
562 dataAbilityRecord->ability_ = abilityRecord;
563 DataAbilityRecordPtrMap dataAbilityRecordPtrMap;
564 std::string test = "test";
565 dataAbilityRecordPtrMap.insert(std::make_pair(test, dataAbilityRecord));
566 dataAbilityManager->dataAbilityRecordsLoaded_ = dataAbilityRecordPtrMap;
567 int32_t num = 10;
568 abilityMs_->subManagersHelper_->dataAbilityManagers_.insert(std::make_pair(num, dataAbilityManager));
569
570 auto abilityConnectManager = std::make_shared<AbilityConnectManager>(num);
571 abilityMs_->subManagersHelper_->connectManagers_.insert(std::make_pair(num, abilityConnectManager));
572 sptr<IRemoteObject> token = new Token(abilityRecord);
573 sptr<SessionInfo> sessionInfo;
574 WindowCommand winCmd = WIN_CMD_FOREGROUND;
575 AbilityCommand abilityCmd = ABILITY_CMD_FOREGROUND;
576 auto ret = abilityMs_->ScheduleCommandAbilityWindowDone(token, sessionInfo, winCmd, abilityCmd);
577 EXPECT_EQ(ret, ERR_INVALID_VALUE);
578 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest ScheduleCommandAbilityWindowDone_004 end");
579 }
580 #ifndef DISABLE_LAUNCHER
581 /*
582 * Feature: AbilityManagerService
583 * Name: StartHighestPriorityAbility_001
584 * Function: StartHighestPriorityAbility
585 * SubFunction: NA
586 */
587 HWTEST_F(AbilityManagerServiceTenhtTest, StartHighestPriorityAbility_001, TestSize.Level1)
588 {
589 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest StartHighestPriorityAbility_001 start");
590 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
591 EXPECT_NE(abilityMs_, nullptr);
592 int32_t userId = 1;
593 bool isBoot = false;
594 bool isAppRecovery = true;
595 auto ret = abilityMs_->StartHighestPriorityAbility(userId, isBoot, isAppRecovery);
596 EXPECT_EQ(ret, RESOLVE_ABILITY_ERR);
597 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest StartHighestPriorityAbility_001 end");
598 }
599 #endif
600 /*
601 * Feature: AbilityManagerService
602 * Name: DelegatorDoAbilityBackground_001
603 * Function: DelegatorDoAbilityBackground
604 * SubFunction: NA
605 */
606 HWTEST_F(AbilityManagerServiceTenhtTest, DelegatorDoAbilityBackground_001, TestSize.Level1)
607 {
608 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DelegatorDoAbilityBackground_001 start");
609 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
610 EXPECT_NE(abilityMs_, nullptr);
611 sptr<IRemoteObject> token = nullptr;
612 int result = abilityMs_->DelegatorDoAbilityForeground(token);
613 ASSERT_EQ(result, CHECK_PERMISSION_FAILED);
614 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DelegatorDoAbilityBackground_001 end");
615 }
616
617 /*
618 * Feature: AbilityManagerService
619 * Name: DelegatorDoAbilityBackground_002
620 * Function: DelegatorDoAbilityBackground
621 * SubFunction: NA
622 */
623 HWTEST_F(AbilityManagerServiceTenhtTest, DelegatorDoAbilityBackground_002, TestSize.Level1)
624 {
625 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DelegatorDoAbilityBackground_002 start");
626 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
627 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
628 abilityRecord->SetPid(IPCSkeleton::GetCallingPid());
629 sptr<IRemoteObject> token = new Token(abilityRecord);
630 int result = abilityMs_->DelegatorDoAbilityBackground(token);
631 ASSERT_EQ(result, ERR_INVALID_VALUE);
632 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DelegatorDoAbilityBackground_002 end");
633 }
634
635 /*
636 * Feature: AbilityManagerService
637 * Name: DelegatorDoAbilityBackground_003
638 * Function: DelegatorDoAbilityBackground
639 * SubFunction: NA
640 */
641 HWTEST_F(AbilityManagerServiceTenhtTest, DelegatorDoAbilityBackground_003, TestSize.Level1)
642 {
643 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DelegatorDoAbilityBackground_003 start");
644 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
645 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
646 abilityRecord->SetPid(IPCSkeleton::GetCallingPid() + 1);
647 sptr<IRemoteObject> token = new Token(abilityRecord);
648 int result = abilityMs_->DelegatorDoAbilityBackground(token);
649 ASSERT_EQ(result, ERR_INVALID_VALUE);
650 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DelegatorDoAbilityBackground_003 end");
651 }
652
653 /*
654 * Feature: AbilityManagerService
655 * Name: DoAbilityForeground_001
656 * Function: DoAbilityForeground
657 * SubFunction: NA
658 */
659 HWTEST_F(AbilityManagerServiceTenhtTest, DoAbilityForeground_001, TestSize.Level1)
660 {
661 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DoAbilityForeground_001 start");
662 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
663 EXPECT_NE(abilityMs_, nullptr);
664 sptr<IRemoteObject> token = nullptr;
665 uint32_t flag = 0;
666 int result = abilityMs_->DoAbilityForeground(token, flag);
667 ASSERT_EQ(result, ERR_INVALID_VALUE);
668 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DoAbilityForeground_001 end");
669 }
670
671 /*
672 * Feature: AbilityManagerService
673 * Name: DoAbilityForeground_002
674 * Function: DoAbilityForeground
675 * SubFunction: NA
676 */
677 HWTEST_F(AbilityManagerServiceTenhtTest, DoAbilityForeground_002, TestSize.Level1)
678 {
679 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DoAbilityForeground_002 start");
680 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
681 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
682 sptr<IRemoteObject> token = new Token(abilityRecord);
683 uint32_t flag = 0;
684 int result = abilityMs_->DoAbilityForeground(token, flag);
685 ASSERT_EQ(result, ERR_INVALID_VALUE);
686 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DoAbilityForeground_002 end");
687 }
688
689 /*
690 * Feature: AbilityManagerService
691 * Name: DoAbilityForeground_003
692 * Function: DoAbilityForeground
693 * SubFunction: NA
694 */
695 HWTEST_F(AbilityManagerServiceTenhtTest, DoAbilityForeground_003, TestSize.Level1)
696 {
697 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DoAbilityForeground_003 start");
698 std::shared_ptr<AbilityManagerService> abilityMs_ = std::make_shared<AbilityManagerService>();
699 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
700 sptr<IRemoteObject> token = new Token(abilityRecord);
701 abilityMs_->SetAbilityController(nullptr, true);
702 uint32_t flag = 0;
703 int result = abilityMs_->DoAbilityForeground(token, flag);
704 ASSERT_EQ(result, ERR_INVALID_VALUE);
705 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest DoAbilityForeground_003 end");
706 }
707
708 /*
709 * Feature: AbilityManagerService
710 * Name: StartAutoStartupApps_001
711 * Function: StartAutoStartupApps
712 * SubFunction: NA
713 */
714 HWTEST_F(AbilityManagerServiceTenhtTest, StartAutoStartupApps_001, TestSize.Level1)
715 {
716 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest StartAutoStartupApps_001 start");
717 auto abilityMs = std::make_shared<AbilityManagerService>();
718 EXPECT_NE(abilityMs, nullptr);
719 auto taskHandler = MockTaskHandlerWrap::CreateQueueHandler("AbilityManagerServiceTenhtTest");
720 abilityMs->taskHandler_ = taskHandler;
721 EXPECT_CALL(*taskHandler, SubmitTaskInner(_, _)).Times(testing::AtLeast(1));
722 AutoStartupInfo autoStartupInfo;
723 autoStartupInfo.abilityTypeName = AbilityRuntime::EXTENSION_TYPE_APP_SERVICE;
724 std::queue<AutoStartupInfo> infoQueue;
725 infoQueue.push(autoStartupInfo);
726 abilityMs->StartAutoStartupApps(infoQueue);
727 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest StartAutoStartupApps_001 end");
728 }
729
730 /*
731 * Feature: AbilityManagerService
732 * Name: StartAutoStartupApps_002
733 * Function: StartAutoStartupApps
734 * SubFunction: NA
735 */
736 HWTEST_F(AbilityManagerServiceTenhtTest, StartAutoStartupApps_002, TestSize.Level1)
737 {
738 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest StartAutoStartupApps_002 start");
739 auto abilityMs = std::make_shared<AbilityManagerService>();
740 EXPECT_NE(abilityMs, nullptr);
741 auto taskHandler = MockTaskHandlerWrap::CreateQueueHandler("AbilityManagerServiceTenhtTest");
742 abilityMs->taskHandler_ = taskHandler;
743 EXPECT_CALL(*taskHandler, SubmitTaskInner(_, _)).Times(testing::AtLeast(1));
744 AutoStartupInfo autoStartupInfo;
745 autoStartupInfo.appCloneIndex = MAX_APP_CLONE_INDEX_NUM;
746 std::queue<AutoStartupInfo> infoQueue;
747 infoQueue.push(autoStartupInfo);
748 abilityMs->StartAutoStartupApps(infoQueue);
749 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest StartAutoStartupApps_002 end");
750 }
751
752 /*
753 * Feature: AbilityManagerService
754 * Name: StartAutoStartupApps_003
755 * Function: StartAutoStartupApps
756 * SubFunction: NA
757 */
758 HWTEST_F(AbilityManagerServiceTenhtTest, StartAutoStartupApps_003, TestSize.Level1)
759 {
760 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest StartAutoStartupApps_003 start");
761 auto abilityMs = std::make_shared<AbilityManagerService>();
762 EXPECT_NE(abilityMs, nullptr);
763 auto taskHandler = MockTaskHandlerWrap::CreateQueueHandler("AbilityManagerServiceTenhtTest");
764 abilityMs->taskHandler_ = taskHandler;
765 EXPECT_CALL(*taskHandler, SubmitTaskInner(_, _)).Times(0);
766 std::queue<AutoStartupInfo> infoQueue;
767 abilityMs->StartAutoStartupApps(infoQueue);
768 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest StartAutoStartupApps_003 end");
769 }
770
771 /*
772 * Feature: AbilityManagerService
773 * Name: StartAutoStartupApps_004
774 * Function: StartAutoStartupApps
775 * SubFunction: NA
776 */
777 HWTEST_F(AbilityManagerServiceTenhtTest, StartAutoStartupApps_004, TestSize.Level1)
778 {
779 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest StartAutoStartupApps_004 start");
780 auto abilityMs = std::make_shared<AbilityManagerService>();
781 EXPECT_NE(abilityMs, nullptr);
782 auto taskHandler = MockTaskHandlerWrap::CreateQueueHandler("AbilityManagerServiceTenhtTest");
783 abilityMs->taskHandler_ = taskHandler;
784 EXPECT_CALL(*taskHandler, SubmitTaskInner(_, _)).Times(testing::AtLeast(1));
785 AutoStartupInfo autoStartupInfo;
786 std::queue<AutoStartupInfo> infoQueue;
787 infoQueue.push(autoStartupInfo);
788 abilityMs->StartAutoStartupApps(infoQueue);
789 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTenhtTest StartAutoStartupApps_004 end");
790 }
791 } // namespace AAFwk
792 } // namespace OHOS
793