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