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