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