1 /*
2 * Copyright (c) 2021-2022 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 <chrono>
17 #include <thread>
18 #include <gtest/gtest.h>
19
20 #define private public
21 #define protected public
22 #include "data_ability_manager.h"
23 #include "app_scheduler.h"
24 #undef private
25 #undef protected
26
27 #include "ability_scheduler_mock.h"
28 #include "mock_app_mgr_client.h"
29 #include "ability_manager_errors.h"
30
31 using namespace testing::ext;
32 using namespace testing;
33 using namespace std::chrono;
34
35 namespace {
36 const std::string STRING_DATA_ABILITY = "com.example.data_ability";
37 constexpr size_t SIZE_ONE = 1;
38 } // namespace
39
40 namespace OHOS {
41 namespace AAFwk {
42 class DataAbilityManagerTest : public testing::TestWithParam<OHOS::AAFwk::AbilityState> {
43 public:
44 static void SetUpTestCase(void);
45 static void TearDownTestCase(void);
46 void SetUp();
47 void TearDown();
48
49 protected:
50 sptr<AbilitySchedulerMock> abilitySchedulerMock_ {nullptr};
51 AbilityRequest abilityRequest_ {};
52 std::shared_ptr<AbilityRecord> abilityRecordClient_ {nullptr};
53 OHOS::AAFwk::AbilityState abilityState_ {};
54 };
55
SetUpTestCase(void)56 void DataAbilityManagerTest::SetUpTestCase(void)
57 {}
TearDownTestCase(void)58 void DataAbilityManagerTest::TearDownTestCase(void)
59 {}
60
SetUp(void)61 void DataAbilityManagerTest::SetUp(void)
62 {
63 if (abilitySchedulerMock_ == nullptr) {
64 abilitySchedulerMock_ = new AbilitySchedulerMock();
65 }
66
67 abilityRequest_.appInfo.bundleName = "com.test.data_ability";
68 abilityRequest_.appInfo.name = "com.test.data_ability";
69 abilityRequest_.abilityInfo.name = "DataAbilityHiworld";
70 abilityRequest_.abilityInfo.type = AbilityType::DATA;
71 abilityRequest_.abilityInfo.bundleName = "com.test.data_ability";
72 abilityRequest_.abilityInfo.deviceId = "device";
73
74 if (abilityRecordClient_ == nullptr) {
75 OHOS::AppExecFwk::AbilityInfo abilityInfo;
76 abilityInfo.name = "DataAbilityClient";
77 abilityInfo.type = AbilityType::PAGE;
78 abilityInfo.bundleName = "com.test.request";
79 abilityInfo.deviceId = "device";
80 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
81 applicationInfo.bundleName = "com.test.request";
82 applicationInfo.name = "com.test.request";
83 const Want want;
84 abilityRecordClient_ = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
85 abilityRecordClient_->Init();
86 }
87 abilityState_ = INITIAL;
88 }
89
TearDown(void)90 void DataAbilityManagerTest::TearDown(void)
91 {
92 abilitySchedulerMock_.clear();
93 }
94
95 /**
96 * @tc.name: AaFwk_DataAbilityManager_DumpSysState_0100
97 * @tc.desc: DumpSysState with no args
98 * @tc.type: FUNC
99 * @tc.require: SR000GH1GO
100 */
101 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpSysState_0100, TestSize.Level1)
102 {
103 HILOG_INFO("AaFwk_DataAbilityManager_DumpSysState_0100 start");
104
105 AbilityRequest abilityRequest;
106 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
107
108 Want want;
109 OHOS::AppExecFwk::AbilityInfo abilityInfo;
110 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
111 auto abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
112 dataAbilityRecord->ability_ = abilityRecord;
113
114 auto dataAbilityManager = std::make_unique<DataAbilityManager>();
115 dataAbilityManager->dataAbilityRecordsLoaded_ = {{STRING_DATA_ABILITY, dataAbilityRecord}};
116
117 std::vector<std::string> info;
118 bool isClient = false;
119 std::string args = "";
120 dataAbilityManager->DumpSysState(info, isClient, args);
121 EXPECT_GT(info.size(), SIZE_ONE);
122
123 HILOG_INFO("info.size() = %{public}zu", info.size());
124 for (auto item : info) {
125 HILOG_INFO("item = %{public}s", item.c_str());
126 }
127
128 HILOG_INFO("AaFwk_DataAbilityManager_DumpSysState_0100 end");
129 }
130
131 /**
132 * @tc.name: AaFwk_DataAbilityManager_DumpSysState_0200
133 * @tc.desc: DumpSysState with args
134 * @tc.type: FUNC
135 * @tc.require: SR000GH1GO
136 */
137 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpSysState_0200, TestSize.Level1)
138 {
139 HILOG_INFO("AaFwk_DataAbilityManager_DumpSysState_0200 start");
140
141 AbilityRequest abilityRequest;
142 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
143
144 Want want;
145 OHOS::AppExecFwk::AbilityInfo abilityInfo;
146 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
147 auto abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
148 dataAbilityRecord->ability_ = abilityRecord;
149
150 auto dataAbilityManager = std::make_unique<DataAbilityManager>();
151 dataAbilityManager->dataAbilityRecordsLoaded_ = {{STRING_DATA_ABILITY, dataAbilityRecord}};
152
153 std::vector<std::string> info;
154 bool isClient = false;
155 std::string args = STRING_DATA_ABILITY;
156 dataAbilityManager->DumpSysState(info, isClient, args);
157 EXPECT_GT(info.size(), SIZE_ONE);
158
159 HILOG_INFO("info.size() = %{public}zu", info.size());
160 for (auto item : info) {
161 HILOG_INFO("item = %{public}s", item.c_str());
162 }
163
164 HILOG_INFO("AaFwk_DataAbilityManager_DumpSysState_0200 end");
165 }
166
167 /*
168 * Feature: AbilityManager
169 * Function: DataAbility
170 * SubFunction: Normal Flow
171 * FunctionPoints: DataAbilityManager simple flow.
172 * EnvConditions: Can run ohos test framework
173 * CaseDescription: Verify the DataAbilityManager simple flow.
174 */
175 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Flow_001, TestSize.Level1)
176 {
177 HILOG_INFO("AaFwk_DataAbilityManager_Flow_001 start.");
178
179 std::shared_ptr<DataAbilityManager> dataAbilityManager = std::make_shared<DataAbilityManager>();
180 std::unique_ptr<MockAppMgrClient> mockAppMgrClient = std::make_unique<MockAppMgrClient>();
181
182 // mock AppScheduler
183 DelayedSingleton<AppScheduler>::GetInstance()->appMgrClient_ = std::move(mockAppMgrClient);
184
__anond8d2ef6a0202() 185 auto func = [this, &dataAbilityManager]() {
186 usleep(200 * 1000); // 200 ms
187 sptr<IRemoteObject> tokenAsyn =
188 (reinterpret_cast<MockAppMgrClient *>(DelayedSingleton<AppScheduler>::GetInstance()->appMgrClient_.get()))
189 ->GetToken();
190 dataAbilityManager->AttachAbilityThread(abilitySchedulerMock_, tokenAsyn);
191 dataAbilityManager->AbilityTransitionDone(tokenAsyn, ACTIVE);
192 };
193
194 std::thread(func).detach();
195 EXPECT_CALL(*abilitySchedulerMock_, ScheduleAbilityTransaction(_, _)).Times(1);
196 EXPECT_NE(dataAbilityManager->Acquire(abilityRequest_, true, abilityRecordClient_->GetToken(), false), nullptr);
197
198 sptr<IRemoteObject> token =
199 (reinterpret_cast<MockAppMgrClient *>(DelayedSingleton<AppScheduler>::GetInstance()->appMgrClient_.get()))
200 ->GetToken();
201 std::shared_ptr<AbilityRecord> abilityRecord = Token::GetAbilityRecordByToken(token);
202 EXPECT_TRUE(abilityRecord);
203
204 // existing ability record
205 EXPECT_NE(dataAbilityManager->GetAbilityRecordByToken(token), nullptr);
206 EXPECT_NE(dataAbilityManager->GetAbilityRecordByScheduler(abilitySchedulerMock_), nullptr);
207 EXPECT_NE(dataAbilityManager->GetAbilityRecordById(abilityRecord->GetRecordId()), nullptr);
208
209 // ability died, clear data ability record
210 dataAbilityManager->OnAbilityDied(abilityRecord);
211
212 // ability has released
213 EXPECT_EQ(dataAbilityManager->GetAbilityRecordByToken(token), nullptr);
214 EXPECT_EQ(dataAbilityManager->GetAbilityRecordByScheduler(abilitySchedulerMock_), nullptr);
215 EXPECT_EQ(dataAbilityManager->GetAbilityRecordById(abilityRecord->GetRecordId()), nullptr);
216
217 HILOG_INFO("AaFwk_DataAbilityManager_Flow_001 end.");
218 }
219
220 /*
221 * Feature: AbilityManager
222 * Function: DataAbility
223 * SubFunction: Acquire
224 * FunctionPoints: The parameter of function Acquire.
225 * EnvConditions: Can run ohos test framework
226 * CaseDescription: Verify function Acquire parameter is nullptr.
227 */
228 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Acquire_001, TestSize.Level1)
229 {
230 HILOG_INFO("AaFwk_DataAbilityManager_Acquire_001 start.");
231
232 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
233
234 EXPECT_EQ(dataAbilityManager->Acquire(abilityRequest_, true, nullptr, false), nullptr);
235
236 HILOG_INFO("AaFwk_DataAbilityManager_Acquire_001 end.");
237 }
238
239 /*
240 * Feature: AbilityManager
241 * Function: DataAbility
242 * SubFunction: Acquire
243 * FunctionPoints: The parameter of function Acquire.
244 * EnvConditions: Can run ohos test framework
245 * CaseDescription: Verify function Acquire parameter ability type is not data
246 */
247 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Acquire_002, TestSize.Level1)
248 {
249 HILOG_INFO("AaFwk_DataAbilityManager_Acquire_002 start.");
250
251 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
252
253 // page ability type
254 abilityRequest_.abilityInfo.type = AbilityType::PAGE;
255 EXPECT_EQ(dataAbilityManager->Acquire(abilityRequest_, true, abilityRecordClient_->GetToken(), false), nullptr);
256
257 HILOG_INFO("AaFwk_DataAbilityManager_Acquire_002 end.");
258 }
259
260 /*
261 * Feature: AbilityManager
262 * Function: DataAbility
263 * SubFunction: Acquire
264 * FunctionPoints: The parameter of function Acquire.
265 * EnvConditions: Can run ohos test framework
266 * CaseDescription: Verify function Acquire parameter appinfo bundlename empty
267 */
268 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Acquire_003, TestSize.Level1)
269 {
270 HILOG_INFO("AaFwk_DataAbilityManager_Acquire_003 start.");
271
272 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
273
274 // appinfo bundle name empty
275 abilityRequest_.appInfo.bundleName = "";
276 EXPECT_EQ(dataAbilityManager->Acquire(abilityRequest_, true, abilityRecordClient_->GetToken(), false), nullptr);
277
278 HILOG_INFO("AaFwk_DataAbilityManager_Acquire_003 end.");
279 }
280
281 /*
282 * Feature: AbilityManager
283 * Function: DataAbility
284 * SubFunction: Acquire
285 * FunctionPoints: The parameter of function Acquire.
286 * EnvConditions: Can run ohos test framework
287 * CaseDescription: Verify function Acquire parameter ability name empty
288 */
289 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Acquire_004, TestSize.Level1)
290 {
291 HILOG_INFO("AaFwk_DataAbilityManager_Acquire_004 start.");
292
293 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
294
295 // ability name empty
296 abilityRequest_.abilityInfo.name = "";
297 EXPECT_EQ(dataAbilityManager->Acquire(abilityRequest_, true, abilityRecordClient_->GetToken(), false), nullptr);
298
299 HILOG_INFO("AaFwk_DataAbilityManager_Acquire_004 end.");
300 }
301
302 /*
303 * Feature: AbilityManager
304 * Function: DataAbility
305 * SubFunction: Acquire
306 * FunctionPoints: The parameter of function Acquire.
307 * EnvConditions: Can run ohos test framework
308 * CaseDescription: Verify function Acquire parameter same bundle name and ability name
309 */
310 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Acquire_005, TestSize.Level1)
311 {
312 HILOG_INFO("AaFwk_DataAbilityManager_Acquire_005 start.");
313
314 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
315
316 // same bundle name and ability name
317 OHOS::AppExecFwk::AbilityInfo abilityInfo;
318 abilityInfo.name = abilityRequest_.abilityInfo.name;
319 abilityInfo.type = AbilityType::PAGE;
320 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
321 applicationInfo.bundleName = abilityRequest_.appInfo.bundleName;
322 applicationInfo.name = abilityRequest_.appInfo.name;
323 const Want want;
324 std::shared_ptr abilityRecordClient = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
325 abilityRecordClient->Init();
326
327 EXPECT_EQ(dataAbilityManager->Acquire(abilityRequest_, true, abilityRecordClient->GetToken(), false), nullptr);
328
329 HILOG_INFO("AaFwk_DataAbilityManager_Acquire_005 end.");
330 }
331
332 /*
333 * Feature: AbilityManager
334 * Function: DataAbility
335 * SubFunction: Acquire
336 * FunctionPoints: The parameter of function Acquire.
337 * EnvConditions: Can run ohos test framework
338 * CaseDescription: Verify function Acquire waitforloaded timeout.
339 */
340 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Acquire_006, TestSize.Level1)
341 {
342 HILOG_INFO("AaFwk_DataAbilityManager_Acquire_006 start.");
343
344 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
345
346 EXPECT_EQ(dataAbilityManager->Acquire(abilityRequest_, true, abilityRecordClient_->GetToken(), false), nullptr);
347
348 HILOG_INFO("AaFwk_DataAbilityManager_Acquire_006 end.");
349 }
350
351 /*
352 * Feature: AbilityManager
353 * Function: DataAbility
354 * SubFunction: Acquire
355 * FunctionPoints: The parameter of function Acquire.
356 * EnvConditions: Can run ohos test framework
357 * CaseDescription: Verify function Acquire waitforloaded timeout.
358 */
359 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Acquire_007, TestSize.Level1)
360 {
361 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
362 AbilityRequest abilityRequest;
363 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
364 abilityRequest.abilityInfo.bundleName = "";
365 auto res = dataAbilityManager->Acquire(abilityRequest, true, abilityRecordClient_->GetToken(), false);
366 EXPECT_EQ(res, nullptr);
367 }
368
369 /*
370 * Feature: AbilityManager
371 * Function: DataAbility
372 * SubFunction: Acquire
373 * FunctionPoints: The parameter of function Acquire.
374 * EnvConditions: Can run ohos test framework
375 * CaseDescription: Verify function Acquire waitforloaded timeout.
376 */
377 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Acquire_008, TestSize.Level1)
378 {
379 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
380 AbilityRequest abilityRequest;
381 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
382 abilityRequest.abilityInfo.bundleName = "bundleName";
383 abilityRequest.abilityInfo.name = "name";
384 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
385 dataAbilityRecord->ability_ = abilityRecordClient_;
386 dataAbilityManager->dataAbilityRecordsLoaded_["bundleName.name"] = dataAbilityRecord;
387 dataAbilityRecord->scheduler_ = nullptr;
388 auto res = dataAbilityManager->Acquire(abilityRequest, true, dataAbilityRecord->GetToken(), true);
389 EXPECT_EQ(res, nullptr);
390 }
391
392 /*
393 * Feature: AbilityManager
394 * Function: DataAbility
395 * SubFunction: Acquire
396 * FunctionPoints: The parameter of function Acquire.
397 * EnvConditions: Can run ohos test framework
398 * CaseDescription: Verify function Acquire waitforloaded timeout.
399 */
400 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Acquire_009, TestSize.Level1)
401 {
402 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
403 AbilityRequest abilityRequest;
404 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
405 abilityRequest.abilityInfo.bundleName = "bundleName";
406 abilityRequest.abilityInfo.name = "name";
407 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
408 dataAbilityRecord->ability_ = abilityRecordClient_;
409 auto res = dataAbilityManager->Acquire(abilityRequest, true, dataAbilityRecord->GetToken(), true);
410 EXPECT_EQ(res, nullptr);
411 }
412
413 /*
414 * Feature: AbilityManager
415 * Function: DataAbility
416 * SubFunction: Release
417 * FunctionPoints: The parameter of function Release.
418 * EnvConditions: Can run ohos test framework
419 * CaseDescription: Verify function Release client is nullptr
420 */
421 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Release_001, TestSize.Level1)
422 {
423 HILOG_INFO("AaFwk_DataAbilityManager_Release_001 start.");
424
425 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
426
427 EXPECT_EQ(dataAbilityManager->Release(abilitySchedulerMock_, nullptr, false), ERR_NULL_OBJECT);
428
429 HILOG_INFO("AaFwk_DataAbilityManager_Release_001 end.");
430 }
431
432 /*
433 * Feature: AbilityManager
434 * Function: DataAbility
435 * SubFunction: Release
436 * FunctionPoints: The parameter of function Release.
437 * EnvConditions: Can run ohos test framework
438 * CaseDescription: Verify function Release scheduler is nullptr
439 */
440 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Release_002, TestSize.Level1)
441 {
442 HILOG_INFO("AaFwk_DataAbilityManager_Release_002 start.");
443
444 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
445
446 EXPECT_EQ(dataAbilityManager->Release(nullptr, abilityRecordClient_->GetToken(), false), ERR_NULL_OBJECT);
447
448 HILOG_INFO("AaFwk_DataAbilityManager_Release_002 end.");
449 }
450
451 /*
452 * Feature: AbilityManager
453 * Function: DataAbility
454 * SubFunction: Release
455 * FunctionPoints: The parameter of function Release.
456 * EnvConditions: Can run ohos test framework
457 * CaseDescription: Verify function Release ability record invalid
458 */
459 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Release_003, TestSize.Level1)
460 {
461 HILOG_INFO("AaFwk_DataAbilityManager_Release_003 start.");
462
463 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
464
465 EXPECT_EQ(dataAbilityManager->Release(abilitySchedulerMock_, abilityRecordClient_->GetToken(), false),
466 ERR_UNKNOWN_OBJECT);
467
468 HILOG_INFO("AaFwk_DataAbilityManager_Release_003 end.");
469 }
470
471 /*
472 * Feature: AbilityManager
473 * Function: DataAbility
474 * SubFunction: Release
475 * FunctionPoints: The parameter of function Release.
476 * EnvConditions: Can run ohos test framework
477 * CaseDescription: Verify Release
478 */
479 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Release_004, TestSize.Level1)
480 {
481 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
482 AbilityRequest abilityRequest;
483 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
484 abilityRequest.abilityInfo.bundleName = "bundleName";
485 abilityRequest.abilityInfo.name = "name";
486 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
487 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
488 abilityRecord->abilityInfo_.visible = false;
489 abilityRecord->SetAbilityState(ACTIVE);
490 dataAbilityRecord->ability_ = abilityRecord;
491 dataAbilityRecord->scheduler_ = abilitySchedulerMock_;
492 dataAbilityManager->dataAbilityRecordsLoaded_["bundleName.name"] = dataAbilityRecord;
493 int res = dataAbilityManager->Release(abilitySchedulerMock_, dataAbilityRecord->GetToken(), false);
494 EXPECT_EQ(res, ABILITY_VISIBLE_FALSE_DENY_REQUEST);
495 }
496
497 /*
498 * Feature: AbilityManager
499 * Function: DataAbility
500 * SubFunction: Release
501 * FunctionPoints: The parameter of function Release.
502 * EnvConditions: Can run ohos test framework
503 * CaseDescription: Verify Release
504 */
505 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Release_005, TestSize.Level1)
506 {
507 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
508 AbilityRequest abilityRequest;
509 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
510 abilityRequest.abilityInfo.bundleName = "bundleName";
511 abilityRequest.abilityInfo.name = "name";
512 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
513 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
514 abilityRecord->abilityInfo_.visible = true;
515 abilityRecord->SetAbilityState(ACTIVE);
516 dataAbilityRecord->ability_ = abilityRecord;
517 dataAbilityRecord->scheduler_ = abilitySchedulerMock_;
518 dataAbilityManager->dataAbilityRecordsLoaded_["bundleName.name"] = dataAbilityRecord;
519 int res = dataAbilityManager->Release(abilitySchedulerMock_, dataAbilityRecord->GetToken(), false);
520 EXPECT_EQ(res, ERR_UNKNOWN_OBJECT);
521 }
522
523 /*
524 * Feature: AbilityManager
525 * Function: DataAbility
526 * SubFunction: Release
527 * FunctionPoints: The parameter of function Release.
528 * EnvConditions: Can run ohos test framework
529 * CaseDescription: Verify Release
530 */
531 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Release_006, TestSize.Level1)
532 {
533 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
534 AbilityRequest abilityRequest;
535 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
536 abilityRequest.abilityInfo.bundleName = "bundleName";
537 abilityRequest.abilityInfo.name = "name";
538 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
539 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
540 abilityRecord->abilityInfo_.visible = true;
541 abilityRecord->SetAbilityState(ACTIVE);
542 dataAbilityRecord->ability_ = abilityRecord;
543 dataAbilityRecord->scheduler_ = abilitySchedulerMock_;
544 dataAbilityManager->dataAbilityRecordsLoaded_["bundleName.name"] = dataAbilityRecord;
545 DataAbilityRecord::ClientInfo ci;
546 ci.client = dataAbilityRecord->GetToken();
547 dataAbilityRecord->clients_.push_back(ci);
548 int res = dataAbilityManager->Release(abilitySchedulerMock_, dataAbilityRecord->GetToken(), false);
549 EXPECT_EQ(res, ERR_OK);
550 }
551
552 /*
553 * Feature: AbilityManager
554 * Function: DataAbility
555 * SubFunction: Release
556 * FunctionPoints: The parameter of function Release.
557 * EnvConditions: Can run ohos test framework
558 * CaseDescription: Verify Release
559 */
560 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Release_007, TestSize.Level1)
561 {
562 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
563 AbilityRequest abilityRequest;
564 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
565 abilityRequest.abilityInfo.bundleName = "bundleName";
566 abilityRequest.abilityInfo.name = "name";
567 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
568 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
569 dataAbilityRecord->ability_ = abilityRecord;
570 dataAbilityRecord->scheduler_ = new AbilitySchedulerMock();
571 dataAbilityManager->dataAbilityRecordsLoaded_["bundleName.name"] = dataAbilityRecord;
572 int res = dataAbilityManager->Release(abilitySchedulerMock_, dataAbilityRecord->GetToken(), false);
573 EXPECT_EQ(res, ERR_UNKNOWN_OBJECT);
574 }
575
576 /*
577 * Feature: AbilityManager
578 * Function: DataAbility
579 * SubFunction: Release
580 * FunctionPoints: The parameter of function Release.
581 * EnvConditions: Can run ohos test framework
582 * CaseDescription: Verify Release
583 */
584 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Release_008, TestSize.Level1)
585 {
586 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
587 AbilityRequest abilityRequest;
588 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
589 abilityRequest.abilityInfo.bundleName = "bundleName";
590 abilityRequest.abilityInfo.name = "name";
591 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
592 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
593 dataAbilityRecord->ability_ = abilityRecord;
594 dataAbilityRecord->scheduler_ = nullptr;
595 dataAbilityManager->dataAbilityRecordsLoaded_["bundleName.name"] = dataAbilityRecord;
596 int res = dataAbilityManager->Release(abilitySchedulerMock_, dataAbilityRecord->GetToken(), false);
597 EXPECT_EQ(res, ERR_UNKNOWN_OBJECT);
598 }
599
600 /*
601 * Feature: AbilityManager
602 * Function: DataAbility
603 * SubFunction: Release
604 * FunctionPoints: The parameter of function Release.
605 * EnvConditions: Can run ohos test framework
606 * CaseDescription: Verify Release
607 */
608 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_Release_009, TestSize.Level1)
609 {
610 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
611 AbilityRequest abilityRequest;
612 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
613 abilityRequest.abilityInfo.bundleName = "bundleName";
614 abilityRequest.abilityInfo.name = "name";
615 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
616 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
617 dataAbilityRecord->ability_ = abilityRecord;
618 dataAbilityManager->dataAbilityRecordsLoaded_["bundleName.name"] = nullptr;
619 int res = dataAbilityManager->Release(abilitySchedulerMock_, dataAbilityRecord->GetToken(), false);
620 EXPECT_EQ(res, ERR_UNKNOWN_OBJECT);
621 }
622
623 /*
624 * Feature: AbilityManager
625 * Function: DataAbility
626 * SubFunction: ContainsDataAbility
627 * FunctionPoints: The parameter of function ContainsDataAbility.
628 * EnvConditions: Can run ohos test framework
629 * CaseDescription: Verify ContainsDataAbility
630 */
631 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_ContainsDataAbility_001, TestSize.Level1)
632 {
633 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
634 AbilityRequest abilityRequest;
635 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
636 abilityRequest.abilityInfo.bundleName = "bundleName";
637 abilityRequest.abilityInfo.name = "name";
638 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
639 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
640 dataAbilityRecord->ability_ = abilityRecord;
641 dataAbilityRecord->scheduler_ = abilitySchedulerMock_;
642 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = dataAbilityRecord;
643 dataAbilityRecord->scheduler_ = new AbilitySchedulerMock();
644 dataAbilityManager->dataAbilityRecordsLoaded_["b"] = dataAbilityRecord;
645 dataAbilityRecord->scheduler_ = nullptr;
646 dataAbilityManager->dataAbilityRecordsLoaded_["c"] = dataAbilityRecord;
647 dataAbilityManager->dataAbilityRecordsLoaded_["d"] = nullptr;
648 int res = dataAbilityManager->ContainsDataAbility(abilitySchedulerMock_);
649 EXPECT_EQ(res, ERR_OK);
650 }
651
652 /*
653 * Feature: AbilityManager
654 * Function: DataAbility
655 * SubFunction: AttachAbilityThread
656 * FunctionPoints: The parameter of function AttachAbilityThread.
657 * EnvConditions: Can run ohos test framework
658 * CaseDescription: Verify function AttachAbilityThread client is nullptr
659 */
660 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_AttachAbilityThread_001, TestSize.Level1)
661 {
662 HILOG_INFO("AaFwk_DataAbilityManager_AttachAbilityThread_001 start.");
663
664 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
665
666 EXPECT_EQ(dataAbilityManager->AttachAbilityThread(abilitySchedulerMock_, nullptr), ERR_NULL_OBJECT);
667
668 HILOG_INFO("AaFwk_DataAbilityManager_AttachAbilityThread_001 end.");
669 }
670
671 /*
672 * Feature: AbilityManager
673 * Function: DataAbility
674 * SubFunction: AttachAbilityThread
675 * FunctionPoints: The parameter of function AttachAbilityThread.
676 * EnvConditions: Can run ohos test framework
677 * CaseDescription: Verify function AttachAbilityThread scheduler is nullptr
678 */
679 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_AttachAbilityThread_002, TestSize.Level1)
680 {
681 HILOG_INFO("AaFwk_DataAbilityManager_AttachAbilityThread_002 start.");
682
683 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
684
685 EXPECT_EQ(dataAbilityManager->AttachAbilityThread(nullptr, abilityRecordClient_->GetToken()), ERR_NULL_OBJECT);
686
687 HILOG_INFO("AaFwk_DataAbilityManager_AttachAbilityThread_002 end.");
688 }
689
690 /*
691 * Feature: AbilityManager
692 * Function: DataAbility
693 * SubFunction: AttachAbilityThread
694 * FunctionPoints: The parameter of function AttachAbilityThread.
695 * EnvConditions: Can run ohos test framework
696 * CaseDescription: Verify function AttachAbilityThread ability record invalid
697 */
698 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_AttachAbilityThread_003, TestSize.Level1)
699 {
700 HILOG_INFO("AaFwk_DataAbilityManager_AttachAbilityThread_003 start.");
701
702 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
703
704 EXPECT_EQ(dataAbilityManager->AttachAbilityThread(abilitySchedulerMock_, abilityRecordClient_->GetToken()),
705 ERR_UNKNOWN_OBJECT);
706
707 HILOG_INFO("AaFwk_DataAbilityManager_AttachAbilityThread_003 end.");
708 }
709
710 /*
711 * Feature: AbilityManager
712 * Function: DataAbility
713 * SubFunction: AbilityTransitionDone
714 * FunctionPoints: The parameter of function AbilityTransitionDone.
715 * EnvConditions: Can run ohos test framework
716 * CaseDescription: Verify function AbilityTransitionDone token is nullptr
717 */
718 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_AbilityTransitionDone_001, TestSize.Level1)
719 {
720 HILOG_INFO("AaFwk_DataAbilityManager_AbilityTransitionDone_001 start.");
721
722 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
723 EXPECT_EQ(dataAbilityManager->AbilityTransitionDone(nullptr, INACTIVE), ERR_NULL_OBJECT);
724
725 HILOG_INFO("AaFwk_DataAbilityManager_AbilityTransitionDone_001 end.");
726 }
727
728 /*
729 * Feature: AbilityManager
730 * Function: DataAbility
731 * SubFunction: AbilityTransitionDone
732 * FunctionPoints: The parameter of function AbilityTransitionDone.
733 * EnvConditions: Can run ohos test framework
734 * CaseDescription: Verify function AbilityTransitionDone ability record invalid
735 */
736 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_AbilityTransitionDone_002, TestSize.Level1)
737 {
738 HILOG_INFO("AaFwk_DataAbilityManager_AbilityTransitionDone_002 start.");
739
740 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
741
742 EXPECT_EQ(
743 dataAbilityManager->AbilityTransitionDone(abilityRecordClient_->GetToken(), INACTIVE), ERR_UNKNOWN_OBJECT);
744
745 HILOG_INFO("AaFwk_DataAbilityManager_AbilityTransitionDone_002 end.");
746 }
747
748 /*
749 * Feature: AbilityManager
750 * Function: DataAbility
751 * SubFunction: OnAbilityDied
752 * FunctionPoints: The parameter of function OnAbilityDied.
753 * EnvConditions: Can run ohos test framework
754 * CaseDescription: Verify OnAbilityDied
755 */
756 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_OnAbilityDied_001, TestSize.Level1)
757 {
758 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
759 AbilityRequest abilityRequest;
760 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
761 abilityRequest.abilityInfo.bundleName = "bundleName";
762 abilityRequest.abilityInfo.name = "name";
763 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
764 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
765 dataAbilityRecord->ability_ = nullptr;
766 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = dataAbilityRecord;
767 dataAbilityManager->OnAbilityDied(abilityRecord);
768 }
769
770 /*
771 * Feature: AbilityManager
772 * Function: DataAbility
773 * SubFunction: OnAbilityDied
774 * FunctionPoints: The parameter of function OnAbilityDied.
775 * EnvConditions: Can run ohos test framework
776 * CaseDescription: Verify OnAbilityDied
777 */
778 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_OnAbilityDied_002, TestSize.Level1)
779 {
780 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
781 AbilityRequest abilityRequest;
782 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
783 abilityRequest.abilityInfo.bundleName = "bundleName";
784 abilityRequest.abilityInfo.name = "name";
785 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
786 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
787 dataAbilityRecord->ability_ = nullptr;
788 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = nullptr;
789 dataAbilityManager->OnAbilityDied(abilityRecord);
790 }
791
792 /*
793 * Feature: AbilityManager
794 * Function: DataAbility
795 * SubFunction: OnAbilityDied
796 * FunctionPoints: The parameter of function OnAbilityDied.
797 * EnvConditions: Can run ohos test framework
798 * CaseDescription: Verify OnAbilityDied
799 */
800 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_OnAbilityDied_003, TestSize.Level1)
801 {
802 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
803 AbilityRequest abilityRequest;
804 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::PAGE;
805 abilityRequest.abilityInfo.bundleName = "bundleName";
806 abilityRequest.abilityInfo.name = "name";
807 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
808 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
809 dataAbilityRecord->ability_ = nullptr;
810 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = nullptr;
811 dataAbilityManager->OnAbilityDied(abilityRecord);
812 }
813
814 /*
815 * Feature: AbilityManager
816 * Function: DataAbility
817 * SubFunction: OnAppStateChanged
818 * FunctionPoints: The parameter of function OnAppStateChanged.
819 * EnvConditions: Can run ohos test framework
820 * CaseDescription: Verify OnAppStateChanged
821 */
822 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_OnAppStateChanged_001, TestSize.Level1)
823 {
824 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
825 AppInfo info;
826 std::string processName = "processName";
827 std::string appName = "appName";
828 int32_t uid = 0;
829 AppData data;
830 data.appName = appName;
831 data.uid = uid;
832 info.processName = processName;
833 info.appData.push_back(data);
834 AbilityRequest abilityRequest;
835 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::PAGE;
836 abilityRequest.abilityInfo.bundleName = "bundleName";
837 abilityRequest.abilityInfo.name = "name";
838 auto dataAbilityRecord1 = std::make_shared<DataAbilityRecord>(abilityRequest);
839 std::shared_ptr<AbilityRecord> abilityRecord1 = AbilityRecord::CreateAbilityRecord(abilityRequest);
840 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = nullptr;
841 dataAbilityManager->dataAbilityRecordsLoading_["a"] = nullptr;
842 abilityRecord1->abilityInfo_.process = processName;
843 abilityRecord1->applicationInfo_.bundleName = "";
844 abilityRecord1->applicationInfo_.name = appName;
845 abilityRecord1->abilityInfo_.applicationInfo.uid = uid;
846 dataAbilityRecord1->ability_ = abilityRecord1;
847 dataAbilityManager->dataAbilityRecordsLoaded_["b"] = dataAbilityRecord1;
848 dataAbilityManager->dataAbilityRecordsLoading_["b"] = dataAbilityRecord1;
849 auto dataAbilityRecord2 = std::make_shared<DataAbilityRecord>(abilityRequest);
850 std::shared_ptr<AbilityRecord> abilityRecord2 = AbilityRecord::CreateAbilityRecord(abilityRequest);
851 abilityRecord2->abilityInfo_.process = "";
852 abilityRecord2->applicationInfo_.bundleName = processName;
853 abilityRecord2->applicationInfo_.name = "";
854 abilityRecord2->abilityInfo_.applicationInfo.uid = 0;
855 dataAbilityRecord2->ability_ = abilityRecord2;
856 dataAbilityManager->dataAbilityRecordsLoaded_["c"] = dataAbilityRecord2;
857 dataAbilityManager->dataAbilityRecordsLoading_["c"] = dataAbilityRecord2;
858 auto dataAbilityRecord3 = std::make_shared<DataAbilityRecord>(abilityRequest);
859 std::shared_ptr<AbilityRecord> abilityRecord3 = AbilityRecord::CreateAbilityRecord(abilityRequest);
860 abilityRecord3->abilityInfo_.process = "";
861 abilityRecord3->applicationInfo_.bundleName = "";
862 dataAbilityRecord3->ability_ = abilityRecord3;
863 dataAbilityManager->dataAbilityRecordsLoaded_["d"] = dataAbilityRecord3;
864 dataAbilityManager->dataAbilityRecordsLoading_["d"] = dataAbilityRecord3;
865 auto dataAbilityRecord4 = std::make_shared<DataAbilityRecord>(abilityRequest);
866 dataAbilityRecord4->ability_ = nullptr;
867 dataAbilityManager->dataAbilityRecordsLoaded_["e"] = dataAbilityRecord4;
868 dataAbilityManager->dataAbilityRecordsLoading_["e"] = dataAbilityRecord4;
869 dataAbilityManager->OnAppStateChanged(info);
870 }
871
872 /*
873 * Feature: AbilityManager
874 * Function: DataAbility
875 * SubFunction: GetAbilityRecordById
876 * FunctionPoints: The parameter of function GetAbilityRecordById.
877 * EnvConditions: Can run ohos test framework
878 * CaseDescription: Verify function GetAbilityRecordById
879 */
880 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_GetAbilityRecordById_002, TestSize.Level1)
881 {
882 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
883 int64_t id = 0;
884 AbilityRequest abilityRequest;
885 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::PAGE;
886 abilityRequest.abilityInfo.bundleName = "bundleName";
887 abilityRequest.abilityInfo.name = "name";
888 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
889 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
890 abilityRecord->recordId_ = 1;
891 dataAbilityRecord->ability_ = abilityRecord;
892 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = nullptr;
893 dataAbilityManager->dataAbilityRecordsLoaded_["b"] = dataAbilityRecord;
894 auto res = dataAbilityManager->GetAbilityRecordById(id);
895 EXPECT_EQ(res, nullptr);
896 }
897
898 /*
899 * Feature: AbilityManager
900 * Function: DataAbility
901 * SubFunction: GetAbilityRecordByToken
902 * FunctionPoints: The parameter of function GetAbilityRecordByToken.
903 * EnvConditions: Can run ohos test framework
904 * CaseDescription: Verify function GetAbilityRecordByToken token is nullptr.
905 */
906 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_GetAbilityRecordByToken_001, TestSize.Level1)
907 {
908 HILOG_INFO("AaFwk_DataAbilityManager_GetAbilityRecordByToken_001 start.");
909
910 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
911 EXPECT_EQ(dataAbilityManager->GetAbilityRecordByToken(nullptr), nullptr);
912
913 HILOG_INFO("AaFwk_DataAbilityManager_GetAbilityRecordByToken_001 end.");
914 }
915
916 /*
917 * Feature: AbilityManager
918 * Function: DataAbility
919 * SubFunction: GetAbilityRecordByToken
920 * FunctionPoints: The parameter of function GetAbilityRecordByToken.
921 * EnvConditions: Can run ohos test framework
922 * CaseDescription: Verify function GetAbilityRecordByToken token is nullptr.
923 */
924 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_GetAbilityRecordByToken_002, TestSize.Level1)
925 {
926 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
927 AbilityRequest abilityRequest;
928 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::PAGE;
929 abilityRequest.abilityInfo.bundleName = "bundleName";
930 abilityRequest.abilityInfo.name = "name";
931 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
932 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
933 dataAbilityRecord->ability_ = abilityRecord;
934 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = nullptr;
935 dataAbilityManager->dataAbilityRecordsLoading_["a"] = nullptr;
936 dataAbilityManager->dataAbilityRecordsLoading_["b"] = dataAbilityRecord;
937 auto res = dataAbilityManager->GetAbilityRecordByToken(dataAbilityRecord->GetToken());
938 EXPECT_NE(res, nullptr);
939 }
940
941 /*
942 * Feature: AbilityManager
943 * Function: DataAbility
944 * SubFunction: GetAbilityRecordByScheduler
945 * FunctionPoints: The parameter of function GetAbilityRecordByScheduler.
946 * EnvConditions: Can run ohos test framework
947 * CaseDescription: Verify function GetAbilityRecordByScheduler token is nullptr.
948 */
949 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_GetAbilityRecordByScheduler_001, TestSize.Level1)
950 {
951 HILOG_INFO("AaFwk_DataAbilityManager_GetAbilityRecordByScheduler_001 start.");
952
953 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
954 EXPECT_EQ(dataAbilityManager->GetAbilityRecordByScheduler(nullptr), nullptr);
955
956 HILOG_INFO("AaFwk_DataAbilityManager_GetAbilityRecordByScheduler_001 end.");
957 }
958
959 /*
960 * Feature: AbilityManager
961 * Function: DataAbility
962 * SubFunction: GetAbilityRecordByScheduler
963 * FunctionPoints: The parameter of function GetAbilityRecordByScheduler.
964 * EnvConditions: Can run ohos test framework
965 * CaseDescription: Verify function GetAbilityRecordByScheduler
966 */
967 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_GetAbilityRecordByScheduler_002, TestSize.Level1)
968 {
969 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
970 AbilityRequest abilityRequest;
971 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::PAGE;
972 abilityRequest.abilityInfo.bundleName = "bundleName";
973 abilityRequest.abilityInfo.name = "name";
974 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
975 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
976 dataAbilityRecord->ability_ = abilityRecord;
977 dataAbilityRecord->scheduler_ = new AbilitySchedulerMock();
978 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = dataAbilityRecord;
979 dataAbilityRecord->scheduler_ = nullptr;
980 dataAbilityManager->dataAbilityRecordsLoaded_["b"] = dataAbilityRecord;
981 dataAbilityManager->dataAbilityRecordsLoaded_["c"] = nullptr;
982 auto res = dataAbilityManager->GetAbilityRecordByScheduler(abilitySchedulerMock_);
983 EXPECT_EQ(res, nullptr);
984 }
985
986 /*
987 * Feature: AbilityManager
988 * Function: DataAbility
989 * SubFunction: GetAbilityRecordById
990 * FunctionPoints: The parameter of function GetAbilityRecordById.
991 * EnvConditions: Can run ohos test framework
992 * CaseDescription: Verify function GetAbilityRecordById id is -1.
993 */
994 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_GetAbilityRecordById_001, TestSize.Level1)
995 {
996 HILOG_INFO("AaFwk_DataAbilityManager_GetAbilityRecordById_001 start.");
997
998 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
999 EXPECT_EQ(dataAbilityManager->GetAbilityRecordById(-1), nullptr);
1000
1001 HILOG_INFO("AaFwk_DataAbilityManager_GetAbilityRecordById_001 end.");
1002 }
1003
1004 /*
1005 * Feature: AbilityManager
1006 * Function: DataAbility
1007 * SubFunction: LoadLocked
1008 * FunctionPoints: The parameter of function LoadLocked.
1009 * EnvConditions: Can run ohos test framework
1010 * CaseDescription: Verify function LoadLocked
1011 */
1012 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_LoadLocked_001, TestSize.Level1)
1013 {
1014 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1015 std::string name = "name";
1016 AbilityRequest abilityRequest;
1017 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::PAGE;
1018 abilityRequest.abilityInfo.bundleName = "bundleName";
1019 abilityRequest.abilityInfo.name = "name";
1020 dataAbilityManager->dataAbilityRecordsLoading_.clear();
1021 auto res = dataAbilityManager->LoadLocked(name, abilityRequest);
1022 EXPECT_EQ(res, nullptr);
1023 }
1024
1025 /*
1026 * Feature: AbilityManager
1027 * Function: DataAbility
1028 * SubFunction: LoadLocked
1029 * FunctionPoints: The parameter of function LoadLocked.
1030 * EnvConditions: Can run ohos test framework
1031 * CaseDescription: Verify function LoadLocked
1032 */
1033 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_LoadLocked_002, TestSize.Level1)
1034 {
1035 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1036 std::string name = "name";
1037 AbilityRequest abilityRequest;
1038 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1039 abilityRequest.abilityInfo.bundleName = "bundleName";
1040 abilityRequest.abilityInfo.name = "name";
1041 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1042 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1043 dataAbilityRecord->ability_ = abilityRecord;
1044 dataAbilityManager->dataAbilityRecordsLoading_[name] = dataAbilityRecord;
1045 auto res = dataAbilityManager->LoadLocked(name, abilityRequest);
1046 EXPECT_EQ(res, nullptr);
1047 }
1048
1049 /*
1050 * Feature: AbilityManager
1051 * Function: DataAbility
1052 * SubFunction: DumpLocked
1053 * FunctionPoints: The parameter of function DumpLocked.
1054 * EnvConditions: Can run ohos test framework
1055 * CaseDescription: Verify function DumpLocked
1056 */
1057 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpLocked_001, TestSize.Level1)
1058 {
1059 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1060 const char func[1] = "";
1061 int line = 0;
1062 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = nullptr;
1063 dataAbilityManager->dataAbilityRecordsLoading_["a"] = nullptr;
1064 dataAbilityManager->DumpLocked(func, line);
1065 }
1066
1067 /*
1068 * Feature: AbilityManager
1069 * Function: DataAbility
1070 * SubFunction: DumpLocked
1071 * FunctionPoints: The parameter of function DumpLocked.
1072 * EnvConditions: Can run ohos test framework
1073 * CaseDescription: Verify function DumpLocked
1074 */
1075 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpLocked_002, TestSize.Level1)
1076 {
1077 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1078 const char func[2] = "a";
1079 int line = 0;
1080 AbilityRequest abilityRequest;
1081 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1082 abilityRequest.abilityInfo.bundleName = "bundleName";
1083 abilityRequest.abilityInfo.name = "name";
1084 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1085 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1086 dataAbilityRecord->ability_ = abilityRecord;
1087 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = dataAbilityRecord;
1088 dataAbilityManager->dataAbilityRecordsLoading_["a"] = dataAbilityRecord;
1089 dataAbilityManager->DumpLocked(func, line);
1090 }
1091
1092 /*
1093 * Feature: AbilityManager
1094 * Function: DataAbility
1095 * SubFunction: DumpLocked
1096 * FunctionPoints: The parameter of function DumpLocked.
1097 * EnvConditions: Can run ohos test framework
1098 * CaseDescription: Verify function DumpLocked
1099 */
1100 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpLocked_003, TestSize.Level1)
1101 {
1102 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1103 const char func[2] = "a";
1104 int line = -1;
1105 dataAbilityManager->dataAbilityRecordsLoaded_.clear();
1106 dataAbilityManager->dataAbilityRecordsLoading_.clear();
1107 dataAbilityManager->DumpLocked(func, line);
1108 }
1109
1110 /*
1111 * Feature: AbilityManager
1112 * Function: DataAbility
1113 * SubFunction: DumpState
1114 * FunctionPoints: The parameter of function DumpState.
1115 * EnvConditions: Can run ohos test framework
1116 * CaseDescription: Verify function DumpState
1117 */
1118 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpState_001, TestSize.Level1)
1119 {
1120 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1121 std::vector<std::string> info;
1122 std::string args = "args";
1123 AbilityRequest abilityRequest;
1124 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1125 abilityRequest.abilityInfo.bundleName = "bundleName";
1126 abilityRequest.abilityInfo.name = "name";
1127 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1128 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1129 dataAbilityRecord->ability_ = abilityRecord;
1130 dataAbilityManager->dataAbilityRecordsLoaded_["args"] = dataAbilityRecord;
1131 dataAbilityManager->DumpState(info, args);
1132 dataAbilityManager->dataAbilityRecordsLoaded_["args"] = nullptr;
1133 dataAbilityManager->DumpState(info, args);
1134 }
1135
1136 /*
1137 * Feature: AbilityManager
1138 * Function: DataAbility
1139 * SubFunction: DumpState
1140 * FunctionPoints: The parameter of function DumpState.
1141 * EnvConditions: Can run ohos test framework
1142 * CaseDescription: Verify function DumpState
1143 */
1144 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpState_002, TestSize.Level1)
1145 {
1146 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1147 std::vector<std::string> info;
1148 std::string args = "args";
1149 dataAbilityManager->dataAbilityRecordsLoaded_.clear();
1150 dataAbilityManager->DumpState(info, args);
1151 }
1152
1153 /*
1154 * Feature: AbilityManager
1155 * Function: DataAbility
1156 * SubFunction: DumpState
1157 * FunctionPoints: The parameter of function DumpState.
1158 * EnvConditions: Can run ohos test framework
1159 * CaseDescription: Verify function DumpState
1160 */
1161 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpState_003, TestSize.Level1)
1162 {
1163 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1164 std::vector<std::string> info;
1165 std::string args = "";
1166 AbilityRequest abilityRequest;
1167 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1168 abilityRequest.abilityInfo.bundleName = "bundleName";
1169 abilityRequest.abilityInfo.name = "name";
1170 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1171 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1172 dataAbilityRecord->ability_ = abilityRecord;
1173 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = dataAbilityRecord;
1174 dataAbilityManager->dataAbilityRecordsLoaded_["b"] = nullptr;
1175 dataAbilityManager->DumpState(info, args);
1176 }
1177
1178 /*
1179 * Feature: AbilityManager
1180 * Function: DataAbility
1181 * SubFunction: DumpSysState
1182 * FunctionPoints: The parameter of function DumpSysState.
1183 * EnvConditions: Can run ohos test framework
1184 * CaseDescription: Verify function DumpSysState
1185 */
1186 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpSysState_001, TestSize.Level1)
1187 {
1188 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1189 std::vector<std::string> info;
1190 bool isClient = true;
1191 std::string args = "args";
1192 AbilityRequest abilityRequest;
1193 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1194 abilityRequest.abilityInfo.bundleName = "bundleName";
1195 abilityRequest.abilityInfo.name = "name";
1196 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1197 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1198 abilityRecord->isReady_ = true;
1199 dataAbilityRecord->ability_ = abilityRecord;
1200 dataAbilityRecord->scheduler_ = abilitySchedulerMock_;
1201 dataAbilityManager->dataAbilityRecordsLoaded_["args"] = dataAbilityRecord;
1202 dataAbilityManager->DumpSysState(info, isClient, args);
1203 }
1204
1205 /*
1206 * Feature: AbilityManager
1207 * Function: DataAbility
1208 * SubFunction: DumpSysState
1209 * FunctionPoints: The parameter of function DumpSysState.
1210 * EnvConditions: Can run ohos test framework
1211 * CaseDescription: Verify function DumpSysState
1212 */
1213 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpSysState_002, TestSize.Level1)
1214 {
1215 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1216 std::vector<std::string> info;
1217 bool isClient = true;
1218 std::string args = "args";
1219 AbilityRequest abilityRequest;
1220 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1221 abilityRequest.abilityInfo.bundleName = "bundleName";
1222 abilityRequest.abilityInfo.name = "name";
1223 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1224 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1225 abilityRecord->isReady_ = false;
1226 dataAbilityRecord->ability_ = abilityRecord;
1227 dataAbilityRecord->scheduler_ = abilitySchedulerMock_;
1228 dataAbilityManager->dataAbilityRecordsLoaded_["args"] = dataAbilityRecord;
1229 dataAbilityManager->DumpSysState(info, isClient, args);
1230 }
1231
1232 /*
1233 * Feature: AbilityManager
1234 * Function: DataAbility
1235 * SubFunction: DumpSysState
1236 * FunctionPoints: The parameter of function DumpSysState.
1237 * EnvConditions: Can run ohos test framework
1238 * CaseDescription: Verify function DumpSysState
1239 */
1240 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpSysState_003, TestSize.Level1)
1241 {
1242 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1243 std::vector<std::string> info;
1244 bool isClient = true;
1245 std::string args = "args";
1246 AbilityRequest abilityRequest;
1247 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1248 abilityRequest.abilityInfo.bundleName = "bundleName";
1249 abilityRequest.abilityInfo.name = "name";
1250 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1251 dataAbilityRecord->ability_ = nullptr;
1252 dataAbilityRecord->scheduler_ = abilitySchedulerMock_;
1253 dataAbilityManager->dataAbilityRecordsLoaded_["args"] = dataAbilityRecord;
1254 dataAbilityManager->DumpSysState(info, isClient, args);
1255 }
1256
1257 /*
1258 * Feature: AbilityManager
1259 * Function: DataAbility
1260 * SubFunction: DumpSysState
1261 * FunctionPoints: The parameter of function DumpSysState.
1262 * EnvConditions: Can run ohos test framework
1263 * CaseDescription: Verify function DumpSysState
1264 */
1265 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpSysState_004, TestSize.Level1)
1266 {
1267 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1268 std::vector<std::string> info;
1269 bool isClient = true;
1270 std::string args = "args";
1271 AbilityRequest abilityRequest;
1272 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1273 abilityRequest.abilityInfo.bundleName = "bundleName";
1274 abilityRequest.abilityInfo.name = "name";
1275 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1276 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1277 dataAbilityRecord->scheduler_ = nullptr;
1278 dataAbilityManager->dataAbilityRecordsLoaded_["args"] = dataAbilityRecord;
1279 dataAbilityManager->DumpSysState(info, isClient, args);
1280 }
1281
1282 /*
1283 * Feature: AbilityManager
1284 * Function: DataAbility
1285 * SubFunction: DumpSysState
1286 * FunctionPoints: The parameter of function DumpSysState.
1287 * EnvConditions: Can run ohos test framework
1288 * CaseDescription: Verify function DumpSysState
1289 */
1290 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpSysState_005, TestSize.Level1)
1291 {
1292 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1293 std::vector<std::string> info;
1294 bool isClient = true;
1295 std::string args = "args";
1296 dataAbilityManager->dataAbilityRecordsLoaded_["args"] = nullptr;
1297 dataAbilityManager->DumpSysState(info, isClient, args);
1298 }
1299
1300 /*
1301 * Feature: AbilityManager
1302 * Function: DataAbility
1303 * SubFunction: DumpSysState
1304 * FunctionPoints: The parameter of function DumpSysState.
1305 * EnvConditions: Can run ohos test framework
1306 * CaseDescription: Verify function DumpSysState
1307 */
1308 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpSysState_006, TestSize.Level1)
1309 {
1310 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1311 std::vector<std::string> info;
1312 bool isClient = false;
1313 std::string args = "args";
1314 dataAbilityManager->dataAbilityRecordsLoaded_["args"] = nullptr;
1315 dataAbilityManager->DumpSysState(info, isClient, args);
1316 }
1317
1318 /*
1319 * Feature: AbilityManager
1320 * Function: DataAbility
1321 * SubFunction: DumpSysState
1322 * FunctionPoints: The parameter of function DumpSysState.
1323 * EnvConditions: Can run ohos test framework
1324 * CaseDescription: Verify function DumpSysState
1325 */
1326 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpSysState_007, TestSize.Level1)
1327 {
1328 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1329 std::vector<std::string> info;
1330 bool isClient = false;
1331 std::string args = "args";
1332 dataAbilityManager->dataAbilityRecordsLoaded_.clear();
1333 dataAbilityManager->DumpSysState(info, isClient, args);
1334 }
1335
1336 /*
1337 * Feature: AbilityManager
1338 * Function: DataAbility
1339 * SubFunction: DumpSysState
1340 * FunctionPoints: The parameter of function DumpSysState.
1341 * EnvConditions: Can run ohos test framework
1342 * CaseDescription: Verify function DumpSysState
1343 */
1344 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpSysState_008, TestSize.Level1)
1345 {
1346 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1347 std::vector<std::string> info;
1348 bool isClient = true;
1349 std::string args = "";
1350 AbilityRequest abilityRequest;
1351 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1352 abilityRequest.abilityInfo.bundleName = "bundleName";
1353 abilityRequest.abilityInfo.name = "name";
1354 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1355 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1356 abilityRecord->isReady_ = true;
1357 dataAbilityRecord->ability_ = abilityRecord;
1358 dataAbilityRecord->scheduler_ = abilitySchedulerMock_;
1359 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = dataAbilityRecord;
1360 dataAbilityManager->DumpSysState(info, isClient, args);
1361 }
1362
1363 /*
1364 * Feature: AbilityManager
1365 * Function: DataAbility
1366 * SubFunction: DumpSysState
1367 * FunctionPoints: The parameter of function DumpSysState.
1368 * EnvConditions: Can run ohos test framework
1369 * CaseDescription: Verify function DumpSysState
1370 */
1371 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpSysState_009, TestSize.Level1)
1372 {
1373 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1374 std::vector<std::string> info;
1375 bool isClient = true;
1376 std::string args = "";
1377 AbilityRequest abilityRequest;
1378 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1379 abilityRequest.abilityInfo.bundleName = "bundleName";
1380 abilityRequest.abilityInfo.name = "name";
1381 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1382 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1383 abilityRecord->isReady_ = false;
1384 dataAbilityRecord->ability_ = abilityRecord;
1385 dataAbilityRecord->scheduler_ = abilitySchedulerMock_;
1386 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = dataAbilityRecord;
1387 dataAbilityManager->DumpSysState(info, isClient, args);
1388 }
1389
1390 /*
1391 * Feature: AbilityManager
1392 * Function: DataAbility
1393 * SubFunction: DumpSysState
1394 * FunctionPoints: The parameter of function DumpSysState.
1395 * EnvConditions: Can run ohos test framework
1396 * CaseDescription: Verify function DumpSysState
1397 */
1398 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpSysState_010, TestSize.Level1)
1399 {
1400 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1401 std::vector<std::string> info;
1402 bool isClient = true;
1403 std::string args = "";
1404 AbilityRequest abilityRequest;
1405 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1406 abilityRequest.abilityInfo.bundleName = "bundleName";
1407 abilityRequest.abilityInfo.name = "name";
1408 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1409 dataAbilityRecord->ability_ = nullptr;
1410 dataAbilityRecord->scheduler_ = abilitySchedulerMock_;
1411 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = dataAbilityRecord;
1412 dataAbilityManager->DumpSysState(info, isClient, args);
1413 }
1414
1415 /*
1416 * Feature: AbilityManager
1417 * Function: DataAbility
1418 * SubFunction: DumpSysState
1419 * FunctionPoints: The parameter of function DumpSysState.
1420 * EnvConditions: Can run ohos test framework
1421 * CaseDescription: Verify function DumpSysState
1422 */
1423 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpSysState_011, TestSize.Level1)
1424 {
1425 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1426 std::vector<std::string> info;
1427 bool isClient = true;
1428 std::string args = "";
1429 AbilityRequest abilityRequest;
1430 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1431 abilityRequest.abilityInfo.bundleName = "bundleName";
1432 abilityRequest.abilityInfo.name = "name";
1433 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1434 dataAbilityRecord->scheduler_ = nullptr;
1435 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = dataAbilityRecord;
1436 dataAbilityManager->DumpSysState(info, isClient, args);
1437 }
1438
1439 /*
1440 * Feature: AbilityManager
1441 * Function: DataAbility
1442 * SubFunction: DumpSysState
1443 * FunctionPoints: The parameter of function DumpSysState.
1444 * EnvConditions: Can run ohos test framework
1445 * CaseDescription: Verify function DumpSysState
1446 */
1447 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpSysState_012, TestSize.Level1)
1448 {
1449 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1450 std::vector<std::string> info;
1451 bool isClient = true;
1452 std::string args = "";
1453 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = nullptr;
1454 dataAbilityManager->DumpSysState(info, isClient, args);
1455 }
1456
1457 /*
1458 * Feature: AbilityManager
1459 * Function: DataAbility
1460 * SubFunction: DumpSysState
1461 * FunctionPoints: The parameter of function DumpSysState.
1462 * EnvConditions: Can run ohos test framework
1463 * CaseDescription: Verify function DumpSysState
1464 */
1465 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_DumpSysState_013, TestSize.Level1)
1466 {
1467 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1468 std::vector<std::string> info;
1469 bool isClient = false;
1470 std::string args = "";
1471 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = nullptr;
1472 dataAbilityManager->DumpSysState(info, isClient, args);
1473 }
1474
1475 /*
1476 * Feature: AbilityManager
1477 * Function: DataAbility
1478 * SubFunction: GetAbilityRunningInfos
1479 * FunctionPoints: The parameter of function GetAbilityRunningInfos.
1480 * EnvConditions: Can run ohos test framework
1481 * CaseDescription: Verify function GetAbilityRunningInfos
1482 */
1483 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_GetAbilityRunningInfos_001, TestSize.Level1)
1484 {
1485 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1486 std::vector<AbilityRunningInfo> info;
1487 bool isPerm = true;
1488 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = nullptr;
1489 dataAbilityManager->GetAbilityRunningInfos(info, isPerm);
1490 }
1491
1492 /*
1493 * Feature: AbilityManager
1494 * Function: DataAbility
1495 * SubFunction: GetAbilityRunningInfos
1496 * FunctionPoints: The parameter of function GetAbilityRunningInfos.
1497 * EnvConditions: Can run ohos test framework
1498 * CaseDescription: Verify function GetAbilityRunningInfos
1499 */
1500 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_GetAbilityRunningInfos_002, TestSize.Level1)
1501 {
1502 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1503 std::vector<AbilityRunningInfo> info;
1504 bool isPerm = true;
1505 AbilityRequest abilityRequest;
1506 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1507 abilityRequest.abilityInfo.bundleName = "bundleName";
1508 abilityRequest.abilityInfo.name = "name";
1509 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1510 dataAbilityRecord->ability_ = nullptr;
1511 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = dataAbilityRecord;
1512 dataAbilityManager->GetAbilityRunningInfos(info, isPerm);
1513 }
1514
1515 /*
1516 * Feature: AbilityManager
1517 * Function: DataAbility
1518 * SubFunction: GetAbilityRunningInfos
1519 * FunctionPoints: The parameter of function GetAbilityRunningInfos.
1520 * EnvConditions: Can run ohos test framework
1521 * CaseDescription: Verify function GetAbilityRunningInfos
1522 */
1523 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_GetAbilityRunningInfos_003, TestSize.Level1)
1524 {
1525 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1526 std::vector<AbilityRunningInfo> info;
1527 bool isPerm = false;
1528 AbilityRequest abilityRequest;
1529 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1530 abilityRequest.abilityInfo.bundleName = "bundleName";
1531 abilityRequest.abilityInfo.name = "name";
1532 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1533 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1534 abilityRecord->applicationInfo_.accessTokenId = -1;
1535 dataAbilityRecord->ability_ = abilityRecord;
1536 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = dataAbilityRecord;
1537 dataAbilityManager->GetAbilityRunningInfos(info, isPerm);
1538 }
1539
1540 /*
1541 * Feature: AbilityManager
1542 * Function: DataAbility
1543 * SubFunction: GetAbilityRunningInfos
1544 * FunctionPoints: The parameter of function GetAbilityRunningInfos.
1545 * EnvConditions: Can run ohos test framework
1546 * CaseDescription: Verify function GetAbilityRunningInfos
1547 */
1548 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_GetAbilityRunningInfos_004, TestSize.Level1)
1549 {
1550 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1551 std::vector<AbilityRunningInfo> info;
1552 bool isPerm = false;
1553 AbilityRequest abilityRequest;
1554 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1555 abilityRequest.abilityInfo.bundleName = "bundleName";
1556 abilityRequest.abilityInfo.name = "name";
1557 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1558 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1559 abilityRecord->applicationInfo_.accessTokenId = IPCSkeleton::GetCallingTokenID();
1560 dataAbilityRecord->ability_ = abilityRecord;
1561 dataAbilityManager->dataAbilityRecordsLoaded_["a"] = dataAbilityRecord;
1562 dataAbilityManager->GetAbilityRunningInfos(info, isPerm);
1563 }
1564
1565 /*
1566 * Feature: AbilityManager
1567 * Function: DataAbility
1568 * SubFunction: RestartDataAbility
1569 * FunctionPoints: The parameter of function RestartDataAbility.
1570 * EnvConditions: Can run ohos test framework
1571 * CaseDescription: Verify function RestartDataAbility
1572 */
1573 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_RestartDataAbility_001, TestSize.Level1)
1574 {
1575 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1576 std::vector<AbilityRunningInfo> info;
1577 AbilityRequest abilityRequest;
1578 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1579 abilityRequest.abilityInfo.bundleName = "bundleName";
1580 abilityRequest.abilityInfo.name = "name";
1581 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1582 dataAbilityManager->RestartDataAbility(abilityRecord);
1583 }
1584
1585 /*
1586 * Feature: AbilityManager
1587 * Function: DataAbility
1588 * SubFunction: ReportDataAbilityAcquired
1589 * FunctionPoints: The parameter of function ReportDataAbilityAcquired.
1590 * EnvConditions: Can run ohos test framework
1591 * CaseDescription: Verify function ReportDataAbilityAcquired
1592 */
1593 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_ReportDataAbilityAcquired_001, TestSize.Level1)
1594 {
1595 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1596 bool isNotHap = true;
1597 AbilityRequest abilityRequest;
1598 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1599 abilityRequest.abilityInfo.bundleName = "bundleName";
1600 abilityRequest.abilityInfo.name = "name";
1601 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1602 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1603 dataAbilityRecord->ability_ = abilityRecord;
1604 dataAbilityManager->ReportDataAbilityAcquired(dataAbilityRecord->GetToken(), isNotHap, dataAbilityRecord);
1605 }
1606
1607 /*
1608 * Feature: AbilityManager
1609 * Function: DataAbility
1610 * SubFunction: ReportDataAbilityAcquired
1611 * FunctionPoints: The parameter of function ReportDataAbilityAcquired.
1612 * EnvConditions: Can run ohos test framework
1613 * CaseDescription: Verify function ReportDataAbilityAcquired
1614 */
1615 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_ReportDataAbilityAcquired_002, TestSize.Level1)
1616 {
1617 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1618 bool isNotHap = true;
1619 AbilityRequest abilityRequest;
1620 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1621 abilityRequest.abilityInfo.bundleName = "bundleName";
1622 abilityRequest.abilityInfo.name = "name";
1623 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1624 dataAbilityManager->ReportDataAbilityAcquired(nullptr, isNotHap, dataAbilityRecord);
1625 }
1626
1627 /*
1628 * Feature: AbilityManager
1629 * Function: DataAbility
1630 * SubFunction: ReportDataAbilityReleased
1631 * FunctionPoints: The parameter of function ReportDataAbilityReleased.
1632 * EnvConditions: Can run ohos test framework
1633 * CaseDescription: Verify function ReportDataAbilityReleased
1634 */
1635 HWTEST_F(DataAbilityManagerTest, AaFwk_DataAbilityManager_ReportDataAbilityReleased_001, TestSize.Level1)
1636 {
1637 std::unique_ptr<DataAbilityManager> dataAbilityManager = std::make_unique<DataAbilityManager>();
1638 bool isNotHap = true;
1639 AbilityRequest abilityRequest;
1640 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::DATA;
1641 abilityRequest.abilityInfo.bundleName = "bundleName";
1642 abilityRequest.abilityInfo.name = "name";
1643 auto dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
1644 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1645 dataAbilityRecord->ability_ = abilityRecord;
1646 dataAbilityManager->ReportDataAbilityReleased(dataAbilityRecord->GetToken(), isNotHap, dataAbilityRecord);
1647 }
1648 } // namespace AAFwk
1649 } // namespace OHOS
1650