1 /*
2 * Copyright (c) 2022-2024 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 <string>
17 #include <thread>
18
19 #include <gtest/gtest.h>
20 #include "system_ability_definition.h"
21
22 #include "bundle_active_service.h"
23 #include "bundle_active_user_service.h"
24 #include "bundle_active_event.h"
25 #include "app_group_callback_stub.h"
26 #include "app_group_callback_info.h"
27 #include "bundle_active_usage_database.h"
28 #include "bundle_active_user_history.h"
29 #include "bundle_active_group_controller.h"
30 #include "bundle_active_log.h"
31 #include "bundle_active_config_reader.h"
32 #include "accesstoken_kit.h"
33 #include "token_setproc.h"
34 #include "nativetoken_kit.h"
35
36 using namespace testing::ext;
37
38 namespace OHOS {
39 namespace DeviceUsageStats {
40 using namespace Security::AccessToken;
41 class DeviceUsageStatisticsServiceTest : public testing::Test {
42 public:
43 static void SetUpTestCase(void);
44 static void TearDownTestCase(void);
45 void SetUp();
46 void TearDown();
47 static std::shared_ptr<BundleActiveCore> bundleActiveCore_;
48 };
49
50 std::shared_ptr<BundleActiveCore> DeviceUsageStatisticsServiceTest::bundleActiveCore_ = nullptr;
51
SetUpTestCase(void)52 void DeviceUsageStatisticsServiceTest::SetUpTestCase(void)
53 {
54 static const char *perms[] = {
55 "ohos.permission.BUNDLE_ACTIVE_INFO",
56 };
57 uint64_t tokenId;
58 NativeTokenInfoParams infoInstance = {
59 .dcapsNum = 0,
60 .permsNum = 1,
61 .aclsNum = 0,
62 .dcaps = nullptr,
63 .perms = perms,
64 .acls = nullptr,
65 .processName = "DeviceUsageStatisticsServiceTest",
66 .aplStr = "system_core",
67 };
68 tokenId = GetAccessTokenId(&infoInstance);
69 SetSelfTokenID(tokenId);
70 AccessTokenKit::ReloadNativeTokenInfo();
71 bundleActiveCore_ = std::make_shared<BundleActiveCore>();
72 bundleActiveCore_->Init();
73 bundleActiveCore_->InitBundleGroupController();
74 }
75
TearDownTestCase(void)76 void DeviceUsageStatisticsServiceTest::TearDownTestCase(void)
77 {
78 bundleActiveCore_->bundleGroupHandler_->ffrtQueue_.reset();
79 int64_t sleepTime = 10;
80 std::this_thread::sleep_for(std::chrono::seconds(sleepTime));
81 }
82
SetUp(void)83 void DeviceUsageStatisticsServiceTest::SetUp(void)
84 {
85 }
86
TearDown(void)87 void DeviceUsageStatisticsServiceTest::TearDown(void)
88 {
89 int64_t sleepTime = 300;
90 std::this_thread::sleep_for(std::chrono::milliseconds(sleepTime));
91 }
92
93 class TestServiceAppGroupChangeCallback : public AppGroupCallbackStub {
94 public:
95 ErrCode OnAppGroupChanged(const AppGroupCallbackInfo &appGroupCallbackInfo) override;
96 };
97
OnAppGroupChanged(const AppGroupCallbackInfo & appGroupCallbackInfo)98 ErrCode TestServiceAppGroupChangeCallback::OnAppGroupChanged(const AppGroupCallbackInfo &appGroupCallbackInfo)
99 {
100 BUNDLE_ACTIVE_LOGI("TestServiceAppGroupChangeCallback::OnAppGroupChanged!");
101 return ERR_OK;
102 }
103
104 /*
105 * @tc.name: DeviceUsageStatisticsServiceTest_GetServiceObject_001
106 * @tc.desc: get service object
107 * @tc.type: FUNC
108 * @tc.require: issuesI5SOZY
109 */
110 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetServiceObject_001,
111 Function | MediumTest | Level0)
112 {
113 sptr<ISystemAbilityManager> systemAbilityManager =
114 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
115 EXPECT_NE(systemAbilityManager, nullptr);
116
117 sptr<IRemoteObject> remoteObject =
118 systemAbilityManager->GetSystemAbility(BACKGROUND_TASK_MANAGER_SERVICE_ID);
119 EXPECT_NE(remoteObject, nullptr);
120 }
121
122 /*
123 * @tc.name: DeviceUsageStatisticsServiceTest_GetNameAndIndexForUid_001
124 * @tc.desc: get service object
125 * @tc.type: FUNC
126 * @tc.require: issuesI5SOZY
127 */
128 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetNameAndIndexForUid_001,
129 Function | MediumTest | Level0)
130 {
131 auto bundleActiveService = std::make_shared<BundleActiveService>();
132 int32_t uid = 10;
133 int32_t result = bundleActiveService->GetNameAndIndexForUid(uid);
134 EXPECT_TRUE(result == -1);
135 }
136
137 /*
138 * @tc.name: DeviceUsageStatisticsServiceTest_dump_001
139 * @tc.desc: test dump
140 * @tc.type: FUNC
141 * @tc.require: issuesI5SOZY
142 */
143 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_dump_001, Function | MediumTest | Level0)
144 {
145 auto bundleActiveService = std::make_shared<BundleActiveService>();
146 bundleActiveService->bundleActiveCore_ = std::make_shared<BundleActiveCore>();
147 bundleActiveService->bundleActiveCore_->Init();
148 BUNDLE_ACTIVE_LOGI("DeviceUsageStatisticsServiceTest create BundleActiveService!");
149
150 std::vector<std::string> dumpOption{"-A", "Events"};
151 std::vector<std::string> dumpInfo;
152 bundleActiveService->ShellDump(dumpOption, dumpInfo);
153
154 dumpOption.clear();
155 dumpInfo.clear();
156 dumpOption = {"-A", "Events", "0", "20000000000000", "100"};
157 bundleActiveService->ShellDump(dumpOption, dumpInfo);
158
159 dumpOption.clear();
160 dumpInfo.clear();
161 dumpOption = {"-A", "PackageUsage"};
162 bundleActiveService->ShellDump(dumpOption, dumpInfo);
163
164 dumpOption.clear();
165 dumpInfo.clear();
166 dumpOption = {"-A", "PackageUsage", "1", "0", "20000000000000", "100"};
167 bundleActiveService->ShellDump(dumpOption, dumpInfo);
168
169 dumpOption.clear();
170 dumpInfo.clear();
171 dumpOption = {"-A", "ModuleUsage"};
172 int32_t ret;
173 ret = bundleActiveService->ShellDump(dumpOption, dumpInfo);
174 EXPECT_TRUE(ret == -1);
175
176 dumpOption.clear();
177 dumpInfo.clear();
178 dumpOption = {"-A", "ModuleUsage", "1", "100"};
179 bundleActiveService->ShellDump(dumpOption, dumpInfo);
180
181 std::vector<std::u16string> args;
182 bundleActiveService->Dump(-1, args);
183
184 args.clear();
185 args = {to_utf16("-h")};
186 bundleActiveService->Dump(-1, args);
187
188 args.clear();
189 args = {to_utf16("-A")};
190 bundleActiveService->Dump(-1, args);
191
192 args.clear();
193 args = {to_utf16("-D")};
194 bundleActiveService->Dump(-1, args);
195 }
196
197 /*
198 * @tc.name: DeviceUsageStatisticsServiceTest_QueryModuleUsageRecords_001
199 * @tc.desc: QueryModuleUsageRecords
200 * @tc.type: FUNC
201 * @tc.require: issuesI5SOZY
202 */
203 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryModuleUsageRecords_001,
204 Function | MediumTest | Level0)
205 {
206 auto bundleActiveService = std::make_shared<BundleActiveService>();
207 std::vector<BundleActiveModuleRecord> results;
208 int32_t maxNum = 0;
209 ErrCode code = bundleActiveService->QueryModuleUsageRecords(maxNum, results, 100);
210 EXPECT_NE(code, 0);
211
212 maxNum = 1001;
213 code = bundleActiveService->QueryModuleUsageRecords(maxNum, results, 100);
214 EXPECT_NE(code, 0);
215 }
216
217 /*
218 * @tc.name: DeviceUsageStatisticsServiceTest_AppGroupCallback_001
219 * @tc.desc: AppGroupCallback
220 * @tc.type: FUNC
221 * @tc.require: issuesI5SOZY
222 */
223 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_AppGroupCallback_001,
224 Function | MediumTest | Level0)
225 {
226 auto bundleActiveService = std::make_shared<BundleActiveService>();
227 BUNDLE_ACTIVE_LOGI("DeviceUsageStatisticsServiceTest create BundleActiveService!");
228 sptr<TestServiceAppGroupChangeCallback> observer = new (std::nothrow) TestServiceAppGroupChangeCallback();
229 bundleActiveService->bundleActiveCore_ = std::make_shared<BundleActiveCore>();
230 EXPECT_EQ(bundleActiveService->RegisterAppGroupCallBack(observer), ERR_OK);
231 EXPECT_NE(bundleActiveService->RegisterAppGroupCallBack(observer), ERR_OK);
232 bundleActiveService->bundleActiveCore_->AddObserverDeathRecipient(observer);
233
234 EXPECT_EQ(bundleActiveService->UnRegisterAppGroupCallBack(observer), ERR_OK);
235 EXPECT_NE(bundleActiveService->UnRegisterAppGroupCallBack(observer), ERR_OK);
236
237 observer = nullptr;
238 EXPECT_NE(bundleActiveService->RegisterAppGroupCallBack(observer), ERR_OK);
239
240 bundleActiveService->bundleActiveCore_->AddObserverDeathRecipient(observer);
241 bundleActiveService->bundleActiveCore_->RemoveObserverDeathRecipient(observer);
242
243 wptr<IRemoteObject> remote = nullptr;
244 bundleActiveService->bundleActiveCore_->OnObserverDied(remote);
245 bundleActiveService->bundleActiveCore_->OnObserverDiedInner(remote);
246 }
247
248 /*
249 * @tc.name: DeviceUsageStatisticsServiceTest_AppGroupCallback_002
250 * @tc.desc: AppGroupCallback
251 * @tc.type: FUNC
252 * @tc.require: issuesI5SOZY
253 */
254 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_AppGroupCallback_002,
255 Function | MediumTest | Level0)
256 {
257 sptr<TestServiceAppGroupChangeCallback> observer = new (std::nothrow) TestServiceAppGroupChangeCallback();
258 Security::AccessToken::AccessTokenID tokenId {};
259 bundleActiveCore_->groupChangeObservers_[tokenId] = observer;
260 int32_t userId = 100;
261 int32_t newGroup = 10;
262 int32_t oldGroup = 60;
263 int32_t reasonInGroup = 0;
264 AppGroupCallbackInfo appGroupCallbackInfo(userId, newGroup, oldGroup, reasonInGroup, "test");
265 bundleActiveCore_->OnAppGroupChanged(appGroupCallbackInfo);
266 SUCCEED();
267 }
268
269 /*
270 * @tc.name: DeviceUsageStatisticsServiceTest_OnUserRemoved_001
271 * @tc.desc: OnUserRemoved
272 * @tc.type: FUNC
273 * @tc.require: issuesI5SOZY
274 */
275 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_OnUserRemoved_001,
276 Function | MediumTest | Level0)
277 {
278 int userId = 100;
279 auto coreObject = bundleActiveCore_;
280 coreObject->RestoreToDatabase(userId);
281 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
282 coreObject->userStatServices_[userId] = userService;
283
284 BundleActiveEvent event;
285 coreObject->ReportEventToAllUserId(event);
286 coreObject->currentUsedUser_ = userId;
287 coreObject->OnUserRemoved(userId);
288 coreObject->OnUserSwitched(userId);
289 EXPECT_NE(coreObject, nullptr);
290 }
291
292 /*
293 * @tc.name: DeviceUsageStatisticsServiceTest_RestoreAllData_001
294 * @tc.desc: RestoreAllData
295 * @tc.type: FUNC
296 * @tc.require: issuesI5SOZY
297 */
298 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RestoreAllData_001,
299 Function | MediumTest | Level0)
300 {
301 auto coreObject = bundleActiveCore_;
302 int userId = 100;
303 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
304 int64_t timeStamp = 20000000000000;
305 userService->Init(timeStamp);
306 coreObject->userStatServices_[userId] = userService;
307 userId = 101;
308 coreObject->userStatServices_[userId] = nullptr;
309 coreObject->RestoreAllData();
310
311 BundleActiveEvent event;
312 coreObject->ReportEventToAllUserId(event);
313 EXPECT_NE(coreObject, nullptr);
314 }
315
316 /*
317 * @tc.name: DeviceUsageStatisticsServiceTest_ObtainSystemEventName_001
318 * @tc.desc: ObtainSystemEventName
319 * @tc.type: FUNC
320 * @tc.require: issuesI5SOZY
321 */
322 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ObtainSystemEventName_001,
323 Function | MediumTest | Level0)
324 {
325 auto coreObject = bundleActiveCore_;
326 BundleActiveEvent event;
327 event.eventId_ = BundleActiveEvent::SYSTEM_LOCK;
328 coreObject->ObtainSystemEventName(event);
329
330 event.eventId_ = BundleActiveEvent::SYSTEM_UNLOCK;
331 coreObject->ObtainSystemEventName(event);
332
333 event.eventId_ = BundleActiveEvent::SYSTEM_SLEEP;
334 coreObject->ObtainSystemEventName(event);
335
336 event.eventId_ = BundleActiveEvent::SYSTEM_WAKEUP;
337 coreObject->ObtainSystemEventName(event);
338 EXPECT_NE(coreObject, nullptr);
339 }
340
341 /*
342 * @tc.name: DeviceUsageStatisticsServiceTest_JudgeQueryCondition_001
343 * @tc.desc: JudgeQueryCondition
344 * @tc.type: FUNC
345 * @tc.require: issuesI5SOZY
346 */
347 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_JudgeQueryCondition_001,
348 Function | MediumTest | Level0)
349 {
350 auto database = std::make_shared<BundleActiveUsageDatabase>();
351 int64_t beginTime = 0;
352 int64_t endTime = 0;
353 int64_t eventTableTime = 0;
354 database->eventTableName_ = "defaultTableName";
355 EXPECT_EQ(database->JudgeQueryCondition(beginTime, endTime, eventTableTime), QUERY_CONDITION_INVALID);
356
357 endTime = 10;
358 eventTableTime = 11;
359 EXPECT_EQ(database->JudgeQueryCondition(beginTime, endTime, eventTableTime), QUERY_CONDITION_INVALID);
360 }
361
362 /*
363 * @tc.name: DeviceUsageStatisticsServiceTest_GetSystemEventName_001
364 * @tc.desc: GetSystemEventName
365 * @tc.type: FUNC
366 * @tc.require: issuesI5SOZY
367 */
368 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetSystemEventName_001,
369 Function | MediumTest | Level0)
370 {
371 auto database = std::make_shared<BundleActiveUsageDatabase>();
372 int32_t userId = BundleActiveEvent::SYSTEM_LOCK;
373 EXPECT_EQ(database->GetSystemEventName(userId), "SYSTEM_LOCK");
374
375 userId = BundleActiveEvent::SYSTEM_UNLOCK;
376 EXPECT_EQ(database->GetSystemEventName(userId), "SYSTEM_UNLOCK");
377
378 userId = BundleActiveEvent::SYSTEM_SLEEP;
379 EXPECT_EQ(database->GetSystemEventName(userId), "SYSTEM_SLEEP");
380
381 userId = BundleActiveEvent::SYSTEM_WAKEUP;
382 EXPECT_EQ(database->GetSystemEventName(userId), "SYSTEM_WAKEUP");
383
384 userId = BundleActiveEvent::ABILITY_FOREGROUND;
385 EXPECT_EQ(database->GetSystemEventName(userId), "");
386 }
387
388 /*
389 * @tc.name: DeviceUsageStatisticsServiceTest_GetOverdueTableCreateTime_001
390 * @tc.desc: GetOverdueTableCreateTime
391 * @tc.type: FUNC
392 * @tc.require: issuesI5SOZY
393 */
394 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetOverdueTableCreateTime_001,
395 Function | MediumTest | Level0)
396 {
397 auto database = std::make_shared<BundleActiveUsageDatabase>();
398 uint32_t databaseType = 4;
399 int64_t currentTimeMillis = 20000000000000;
400 database->GetOverdueTableCreateTime(databaseType, currentTimeMillis);
401
402 databaseType = 0;
403 database->GetOverdueTableCreateTime(databaseType, currentTimeMillis);
404 EXPECT_NE(database, nullptr);
405 }
406
407 /*
408 * @tc.name: DeviceUsageStatisticsServiceTest_DeleteInvalidTable_001
409 * @tc.desc: DeleteInvalidTable
410 * @tc.type: FUNC
411 * @tc.require: issuesI5SOZY
412 */
413 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_DeleteInvalidTable_001,
414 Function | MediumTest | Level0)
415 {
416 auto database = std::make_shared<BundleActiveUsageDatabase>();
417 uint32_t databaseType = 4;
418 int64_t currentTimeMillis = 20000000000000;
419 database->DeleteInvalidTable(databaseType, currentTimeMillis);
420
421 databaseType = 0;
422 database->DeleteInvalidTable(databaseType, currentTimeMillis);
423 EXPECT_NE(database, nullptr);
424 }
425
426 /*
427 * @tc.name: DeviceUsageStatisticsServiceTest_CreatePackageLogTable_001
428 * @tc.desc: CreatePackageLogTable
429 * @tc.type: FUNC
430 * @tc.require: issuesI5SOZY
431 */
432 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CreatePackageLogTable_001,
433 Function | MediumTest | Level0)
434 {
435 auto database = std::make_shared<BundleActiveUsageDatabase>();
436 uint32_t databaseType = 0;
437 int64_t currentTimeMillis = 20000000000000;
438 database->CreatePackageLogTable(databaseType, currentTimeMillis);
439 EXPECT_NE(database, nullptr);
440 }
441
442 /*
443 * @tc.name: DeviceUsageStatisticsServiceTest_CreateModuleRecordTable_001
444 * @tc.desc: CreateModuleRecordTable
445 * @tc.type: FUNC
446 * @tc.require: issuesI5SOZY
447 */
448 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CreateModuleRecordTable_001,
449 Function | MediumTest | Level0)
450 {
451 auto database = std::make_shared<BundleActiveUsageDatabase>();
452 uint32_t databaseType = 0;
453 int64_t currentTimeMillis = 20000000000000;
454 database->CreateModuleRecordTable(databaseType, currentTimeMillis);
455 EXPECT_NE(database, nullptr);
456 }
457
458 /*
459 * @tc.name: DeviceUsageStatisticsServiceTest_CreateFormRecordTable_001
460 * @tc.desc: CreateFormRecordTable
461 * @tc.type: FUNC
462 * @tc.require: issuesI5SOZY
463 */
464 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CreateFormRecordTable_001,
465 Function | MediumTest | Level0)
466 {
467 auto database = std::make_shared<BundleActiveUsageDatabase>();
468 uint32_t databaseType = 0;
469 int64_t currentTimeMillis = 20000000000000;
470 database->CreateFormRecordTable(databaseType, currentTimeMillis);
471 EXPECT_NE(database, nullptr);
472 }
473
474 /*
475 * @tc.name: DeviceUsageStatisticsServiceTest_CreateDurationTable_001
476 * @tc.desc: CreateDurationTable
477 * @tc.type: FUNC
478 * @tc.require: issuesI5SOZY
479 */
480 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CreateDurationTable_001,
481 Function | MediumTest | Level0)
482 {
483 auto database = std::make_shared<BundleActiveUsageDatabase>();
484 int32_t databaseType = DAILY_DATABASE_INDEX;
485 bool forModuleRecords = true;
486 database->InitUsageGroupDatabase(databaseType, forModuleRecords);
487 EXPECT_NE(database, nullptr);
488 }
489
490 /*
491 * @tc.name: DeviceUsageStatisticsServiceTest_CreateBundleHistoryTable_001
492 * @tc.desc: CreateBundleHistoryTable
493 * @tc.type: FUNC
494 * @tc.require: issuesI5SOZY
495 */
496 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CreateBundleHistoryTable_001,
497 Function | MediumTest | Level0)
498 {
499 auto database = std::make_shared<BundleActiveUsageDatabase>();
500 uint32_t databaseType = 0;
501 database->CreateBundleHistoryTable(databaseType);
502 EXPECT_NE(database, nullptr);
503 }
504
505 /*
506 * @tc.name: DeviceUsageStatisticsServiceTest_PutBundleHistoryData_001
507 * @tc.desc: PutBundleHistoryData
508 * @tc.type: FUNC
509 * @tc.require: issuesI5SOZY
510 */
511 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_PutBundleHistoryData_001,
512 Function | MediumTest | Level0)
513 {
514 auto database = std::make_shared<BundleActiveUsageDatabase>();
515 int32_t userId = 100;
516 std::shared_ptr<std::map<std::string, std::shared_ptr<BundleActivePackageHistory>>> userHistory = nullptr;
517 database->PutBundleHistoryData(userId, userHistory);
518
519 userHistory = std::make_shared<std::map<string, std::shared_ptr<BundleActivePackageHistory>>>();
520 userHistory->emplace("defaultTest", std::make_shared<BundleActivePackageHistory>());
521 database->PutBundleHistoryData(userId, userHistory);
522 database->PutBundleHistoryData(userId, userHistory);
523 EXPECT_NE(database, nullptr);
524 }
525
526 /*
527 * @tc.name: DeviceUsageStatisticsServiceTest_GetBundleHistoryData_001
528 * @tc.desc: GetBundleHistoryData
529 * @tc.type: FUNC
530 * @tc.require: issuesI5SOZY
531 */
532 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetBundleHistoryData_001,
533 Function | MediumTest | Level0)
534 {
535 auto database = std::make_shared<BundleActiveUsageDatabase>();
536 int32_t userId = 100;
537 database->GetBundleHistoryData(userId);
538 EXPECT_NE(database, nullptr);
539 }
540
541 /*
542 * @tc.name: DeviceUsageStatisticsServiceTest_FlushPackageInfo_001
543 * @tc.desc: FlushPackageInfo
544 * @tc.type: FUNC
545 * @tc.require: issuesI5SOZY
546 */
547 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_FlushPackageInfo_001,
548 Function | MediumTest | Level0)
549 {
550 auto database = std::make_shared<BundleActiveUsageDatabase>();
551 uint32_t databaseType = 0;
552 BundleActivePeriodStats stats;
553 stats.bundleStats_.emplace("defaultTest", std::make_shared<BundleActivePackageStats>());
554 database->FlushPackageInfo(databaseType, stats);
555 EXPECT_NE(database, nullptr);
556 }
557
558 /*
559 * @tc.name: DeviceUsageStatisticsServiceTest_GetCurrentUsageData_001
560 * @tc.desc: GetCurrentUsageData
561 * @tc.type: FUNC
562 * @tc.require: issuesI5SOZY
563 */
564 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetCurrentUsageData_001,
565 Function | MediumTest | Level0)
566 {
567 auto database = std::make_shared<BundleActiveUsageDatabase>();
568 int32_t databaseType = -1;
569 int32_t userId = 100;
570 database->GetCurrentUsageData(databaseType, userId);
571
572 databaseType = 4;
573 database->GetCurrentUsageData(databaseType, userId);
574
575 databaseType = 0;
576 database->GetCurrentUsageData(databaseType, userId);
577 EXPECT_NE(database, nullptr);
578 }
579
580 /*
581 * @tc.name: DeviceUsageStatisticsServiceTest_GetTableIndexSql_001
582 * @tc.desc: GetTableIndexSql
583 * @tc.type: FUNC
584 * @tc.require: issuesI5SOZY
585 */
586 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetTableIndexSql_001,
587 Function | MediumTest | Level0)
588 {
589 auto database = std::make_shared<BundleActiveUsageDatabase>();
590 uint32_t databaseType = 0;
591 int64_t tableTime = 20000000000000;
592 bool createFlag = false;
593 int32_t indexFlag = 0;
594 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
595
596 createFlag = true;
597 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
598
599 databaseType = 4;
600 createFlag = false;
601 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
602
603 databaseType = 5;
604 createFlag = false;
605 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
606 indexFlag = BUNDLE_ACTIVE_DB_INDEX_MODULE;
607 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
608
609 createFlag = true;
610 indexFlag = BUNDLE_ACTIVE_DB_INDEX_NORMAL;
611 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
612
613 indexFlag = BUNDLE_ACTIVE_DB_INDEX_MODULE;
614 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
615 EXPECT_NE(database, nullptr);
616 }
617
618 /*
619 * @tc.name: DeviceUsageStatisticsServiceTest_RenameTableName_001
620 * @tc.desc: RenameTableName
621 * @tc.type: FUNC
622 * @tc.require: issuesI5SOZY
623 */
624 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RenameTableName_001,
625 Function | MediumTest | Level0)
626 {
627 auto database = std::make_shared<BundleActiveUsageDatabase>();
628 uint32_t databaseType = 0;
629 int64_t tableOldTime = 0;
630 int64_t tableNewTime = 20000000000000;
631 database->RenameTableName(databaseType, tableOldTime, tableNewTime);
632
633 databaseType = 4;
634 database->RenameTableName(databaseType, tableOldTime, tableNewTime);
635
636 databaseType = 5;
637 database->RenameTableName(databaseType, tableOldTime, tableNewTime);
638 EXPECT_NE(database, nullptr);
639 }
640
641 /*
642 * @tc.name: DeviceUsageStatisticsServiceTest_RemoveOldData_001
643 * @tc.desc: RemoveOldData
644 * @tc.type: FUNC
645 * @tc.require: issuesI5SOZY
646 */
647 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RemoveOldData_001,
648 Function | MediumTest | Level0)
649 {
650 auto database = std::make_shared<BundleActiveUsageDatabase>();
651 int64_t currentTime = 20000000000000;
652 database->RemoveOldData(currentTime);
653 EXPECT_NE(database, nullptr);
654 }
655
656 /*
657 * @tc.name: DeviceUsageStatisticsServiceTest_QueryDatabaseUsageStats_001
658 * @tc.desc: QueryDatabaseUsageStats
659 * @tc.type: FUNC
660 * @tc.require: issuesI5SOZY
661 */
662 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryDatabaseUsageStats_001,
663 Function | MediumTest | Level0)
664 {
665 auto database = std::make_shared<BundleActiveUsageDatabase>();
666 int32_t databaseType = -1;
667 int64_t beginTime = 0;
668 int64_t endTime = 0;
669 int32_t userId = 100;
670 EXPECT_EQ(database->QueryDatabaseUsageStats(databaseType, beginTime, endTime, userId).size(), 0);
671
672 databaseType = 4;
673 EXPECT_EQ(database->QueryDatabaseUsageStats(databaseType, beginTime, endTime, userId).size(), 0);
674
675 databaseType = 0;
676 EXPECT_EQ(database->QueryDatabaseUsageStats(databaseType, beginTime, endTime, userId).size(), 0);
677
678 databaseType = 0;
679 endTime = 20000000000000;
680 database->QueryDatabaseUsageStats(databaseType, beginTime, endTime, userId);
681 EXPECT_NE(database, nullptr);
682 }
683
684 /*
685 * @tc.name: DeviceUsageStatisticsServiceTest_GetSystemTimeMs_001
686 * @tc.desc: GetSystemTimeMs
687 * @tc.type: FUNC
688 * @tc.require: issuesI5SOZY
689 */
690 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetSystemTimeMs_001,
691 Function | MediumTest | Level0)
692 {
693 auto database = std::make_shared<BundleActiveUsageDatabase>();
694 database->GetSystemTimeMs();
695 EXPECT_NE(database, nullptr);
696 }
697
698 /*
699 * @tc.name: DeviceUsageStatisticsServiceTest_ReportEvent_001
700 * @tc.desc: ReportEvent
701 * @tc.type: FUNC
702 * @tc.require: issuesI5SOZY
703 */
704 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ReportEvent_001,
705 Function | MediumTest | Level0)
706 {
707 bundleActiveCore_ = std::make_shared<BundleActiveCore>();
708 bundleActiveCore_->Init();
709 bundleActiveCore_->InitBundleGroupController();
710 BundleActiveEvent event;
711 int32_t userId = 0;
712 EXPECT_NE(bundleActiveCore_->ReportEvent(event, userId), ERR_OK);
713
714 userId = 101;
715 event.bundleName_ = "com.ohos.launcher";
716 EXPECT_EQ(bundleActiveCore_->ReportEvent(event, userId), ERR_OK);
717
718 event.bundleName_ = "com.ohos.settings";
719 event.eventId_ = 15;
720 EXPECT_EQ(bundleActiveCore_->ReportEvent(event, userId), ERR_OK);
721
722 event.eventId_ = 16;
723 EXPECT_EQ(bundleActiveCore_->ReportEvent(event, userId), ERR_OK);
724 }
725
726 /*
727 * @tc.name: DeviceUsageStatisticsServiceTest_InitBundleGroupController_001
728 * @tc.desc: InitBundleGroupController
729 * @tc.type: FUNC
730 * @tc.require: issuesI5SOZY
731 */
732 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_InitBundleGroupController_001,
733 Function | MediumTest | Level0)
734 {
735 auto coreObject = bundleActiveCore_;
736 coreObject->InitBundleGroupController();
737 }
738
739 /*
740 * @tc.name: DeviceUsageStatisticsServiceTest_ReportEventToAllUserId_001
741 * @tc.desc: ReportEventToAllUserId
742 * @tc.type: FUNC
743 * @tc.require: issuesI5SOZY
744 */
745 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ReportEventToAllUserId_001,
746 Function | MediumTest | Level0)
747 {
748 auto coreObject = std::make_shared<BundleActiveCore>();
749 int userId = 100;
750 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
751 coreObject->userStatServices_[userId] = userService;
752 userId = 101;
753 coreObject->userStatServices_[userId] = nullptr;
754 BundleActiveEvent event;
755 coreObject->ReportEventToAllUserId(event);
756
757 coreObject->Init();
758 coreObject->InitBundleGroupController();
759 coreObject->ReportEventToAllUserId(event);
760 EXPECT_NE(coreObject, nullptr);
761 }
762
763 /*
764 * @tc.name: DeviceUsageStatisticsServiceTest_RestoreToDatabase_001
765 * @tc.desc: RestoreToDatabase
766 * @tc.type: FUNC
767 * @tc.require: issuesI5SOZY
768 */
769 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RestoreToDatabase_001,
770 Function | MediumTest | Level0)
771 {
772 auto coreObject = bundleActiveCore_;
773 int userId = 100;
774 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
775 int64_t timeStamp = 20000000000000;
776 userService->Init(timeStamp);
777 coreObject->userStatServices_[userId] = userService;
778 coreObject->RestoreToDatabase(userId);
779
780 userId = 101;
781 coreObject->RestoreToDatabase(userId);
782 EXPECT_NE(coreObject, nullptr);
783 }
784
785 /*
786 * @tc.name: BundleActiveGroupControllerTest_001
787 * @tc.desc: test the interface
788 * @tc.type: FUNC
789 * @tc.require: DTS2023121404861
790 */
791 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_001,
792 Function | MediumTest | Level0)
793 {
794 auto coreObject = bundleActiveCore_;
795 int userId = 100;
796 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
797 int64_t timeStamp = 20000000000000;
798 userService->Init(timeStamp);
799 coreObject->userStatServices_[userId] = userService;
800 coreObject->OnUserRemoved(userId);
801 SUCCEED();
802 }
803
804 /*
805 * @tc.name: BundleActiveGroupControllerTest_002
806 * @tc.desc: test the interface
807 * @tc.type: FUNC
808 * @tc.require: DTS2023121404861
809 */
810 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_002,
811 Function | MediumTest | Level0)
812 {
813 auto coreObject = bundleActiveCore_;
814 int userId = 100;
815 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
816 int64_t timeStamp = 20000000000000;
817 userService->Init(timeStamp);
818 coreObject->userStatServices_[userId] = userService;
819 coreObject->bundleGroupController_->OnUserSwitched(userId, userId);
820 SUCCEED();
821 }
822
823 /*
824 * @tc.name: BundleActiveGroupControllerTest_003
825 * @tc.desc: test the interface
826 * @tc.type: FUNC
827 * @tc.require: DTS2023121404861
828 */
829 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_003,
830 Function | MediumTest | Level0)
831 {
832 auto coreObject = bundleActiveCore_;
833 int userId = 100;
834 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
835 int64_t timeStamp = 20000000000000;
836 userService->Init(timeStamp);
837 coreObject->userStatServices_[userId] = userService;
838 EXPECT_EQ(coreObject->bundleGroupController_->GetNewGroup("test", userId, timeStamp, 0), -1);
839 }
840
841 /*
842 * @tc.name: BundleActiveGroupControllerTest_004
843 * @tc.desc: test the interface
844 * @tc.type: FUNC
845 * @tc.require: DTS2023121404861
846 */
847 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_004,
848 Function | MediumTest | Level0)
849 {
850 auto coreObject = bundleActiveCore_;
851 int userId = 100;
852 BundleActiveEvent event;
853 int64_t timeStamp = 20000000000000;
854 coreObject->bundleGroupController_->ReportEvent(event, timeStamp, userId);
855 SUCCEED();
856 coreObject->bundleGroupController_->ReportEvent(event, timeStamp, 19);
857 SUCCEED();
858 coreObject->bundleGroupController_->ReportEvent(event, timeStamp, 7);
859 SUCCEED();
860 coreObject->bundleGroupController_->bundleGroupEnable_ = false;
861 SUCCEED();
862 coreObject->bundleGroupController_->ReportEvent(event, timeStamp, userId);
863 SUCCEED();
864 }
865
866 /*
867 * @tc.name: BundleActiveGroupControllerTest_005
868 * @tc.desc: test the interface
869 * @tc.type: FUNC
870 * @tc.require: DTS2023121404861
871 */
872 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_005,
873 Function | MediumTest | Level0)
874 {
875 auto coreObject = bundleActiveCore_;
876 int userId = 100;
877 int64_t timeStamp = 20000000000000;
878 coreObject->bundleGroupController_->CheckAndUpdateGroup("test", userId, 0, timeStamp);
879 SUCCEED();
880 }
881
882 /*
883 * @tc.name: BundleActiveGroupControllerTest_006
884 * @tc.desc: test the interface
885 * @tc.type: FUNC
886 * @tc.require: DTS2023121404861
887 */
888 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_006,
889 Function | MediumTest | Level0)
890 {
891 auto coreObject = bundleActiveCore_;
892 int userId = 100;
893 int64_t time = 20000000000000;
894 EXPECT_EQ(coreObject->bundleGroupController_->SetAppGroup("test", userId, 0, 0, time, true),
895 ERR_NO_APP_GROUP_INFO_IN_DATABASE);
896 }
897
898 /*
899 * @tc.name: BundleActiveGroupControllerTest_007
900 * @tc.desc: test the interface
901 * @tc.type: FUNC
902 * @tc.require: DTS2023121404861
903 */
904 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_007,
905 Function | MediumTest | Level0)
906 {
907 auto coreObject = bundleActiveCore_;
908 int userId = 100;
909 EXPECT_EQ(coreObject->bundleGroupController_->IsBundleIdle("test", userId), -1);
910 }
911
912 /*
913 * @tc.name: BundleActiveGroupControllerTest_009
914 * @tc.desc: test the interface
915 * @tc.type: FUNC
916 * @tc.require: DTS2023121404861
917 */
918 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_009,
919 Function | MediumTest | Level0)
920 {
921 auto coreObject = std::make_shared<BundleActiveCore>();
922 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(true);
923 coreObject->InitBundleGroupController();
924 int userId = 100;
925 EXPECT_EQ(coreObject->bundleGroupController_->IsBundleInstalled("test", userId), false);
926 coreObject->bundleGroupController_->sptrBundleMgr_ = nullptr;
927 EXPECT_EQ(coreObject->bundleGroupController_->IsBundleInstalled("test", userId), false);
928 }
929
930 /*
931 * @tc.name: BundleActiveGroupControllerTest_010
932 * @tc.desc: test the interface
933 * @tc.type: FUNC
934 * @tc.require: DTS2023121404861
935 */
936 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_010,
937 Function | MediumTest | Level0)
938 {
939 auto coreObject = bundleActiveCore_;
940 int userId = 100;
941 int64_t timeStamp = 20000000000000;
942 coreObject->bundleGroupController_->ShutDown(timeStamp, userId);
943 SUCCEED();
944 }
945
946 /*
947 * @tc.name: BundleActiveGroupControllerTest_011
948 * @tc.desc: test the interface
949 * @tc.type: FUNC
950 * @tc.require: IssuesIA9M7I
951 */
952 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_011,
953 Function | MediumTest | Level0)
954 {
955 bool isScreenOn = true;
956 int64_t timeStamp = 0;
957 bundleActiveCore_->bundleGroupController_->OnScreenChanged(isScreenOn, timeStamp);
958 SUCCEED();
959 }
960
961 /*
962 * @tc.name: BundleActiveGroupControllerTest_012
963 * @tc.desc: test the interface
964 * @tc.type: FUNC
965 * @tc.require: IssuesIA9M7I
966 */
967 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_012,
968 Function | MediumTest | Level0)
969 {
970 bundleActiveCore_->bundleGroupController_->ShutDown(1, 10);
971 EXPECT_NE(bundleActiveCore_->bundleGroupController_->bundleUserHistory_, nullptr);
972 }
973
974 /*
975 * @tc.name: BundleActiveGroupControllerTest_013
976 * @tc.desc: test the interface
977 * @tc.type: FUNC
978 * @tc.require: IssuesIA9M7I
979 */
980 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_013,
981 Function | MediumTest | Level0)
982 {
983 bundleActiveCore_->bundleGroupController_->OnUserRemoved(10);
984 EXPECT_NE(bundleActiveCore_->bundleGroupController_->bundleUserHistory_, nullptr);
985 }
986
987 /*
988 * @tc.name: BundleActiveGroupControllerTest_014
989 * @tc.desc: test the interface
990 * @tc.type: FUNC
991 * @tc.require: IssuesIA9M7I
992 */
993 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_014,
994 Function | MediumTest | Level0)
995 {
996 bundleActiveCore_->bundleGroupController_->OnUserSwitched(1, 10);
997 EXPECT_NE(bundleActiveCore_->bundleGroupController_->bundleUserHistory_, nullptr);
998 }
999
1000 /*
1001 * @tc.name: BundleActiveUserHistoryTest_001
1002 * @tc.desc: test the interface
1003 * @tc.type: FUNC
1004 * @tc.require: DTS2023121404861
1005 */
1006 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_001,
1007 Function | MediumTest | Level0)
1008 {
1009 int64_t bootBasedTimeStamp = 2000;
1010 std::vector<int64_t> screenTimeLevel;
1011 std::vector<int64_t> bootFromTimeLevel;
1012 auto bundleUserHistory_ = std::make_shared<BundleActiveUserHistory>(bootBasedTimeStamp, bundleActiveCore_);
1013 bundleUserHistory_->GetLevelIndex("test", 0, 20000, screenTimeLevel, bootFromTimeLevel, 0);
1014 }
1015
1016 /*
1017 * @tc.name: BundleActiveUserHistoryTest_002
1018 * @tc.desc: test the interface
1019 * @tc.type: FUNC
1020 * @tc.require: DTS2023121404861
1021 */
1022 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_002,
1023 Function | MediumTest | Level0)
1024 {
1025 int64_t bootBasedTimeStamp = 2000;
1026 auto bundleUserHistory_ = std::make_shared<BundleActiveUserHistory>(bootBasedTimeStamp, bundleActiveCore_);
1027 bundleUserHistory_->WriteDeviceDuration();
1028 bundleUserHistory_->OnBundleUninstalled(0, "test", 0, 0);
1029 SUCCEED();
1030 }
1031
1032 /*
1033 * @tc.name: BundleActiveUserHistoryTest_003
1034 * @tc.desc: test the interface
1035 * @tc.type: FUNC
1036 * @tc.require: DTS2023121404861
1037 */
1038 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_003,
1039 Function | MediumTest | Level0)
1040 {
1041 int64_t bootBasedTimeStamp = 2000;
1042 auto oneBundleUsageHistory = std::make_shared<BundleActivePackageHistory>();
1043 auto bundleUserHistory_ = std::make_shared<BundleActiveUserHistory>(bootBasedTimeStamp, bundleActiveCore_);
1044 bundleUserHistory_->ReportUsage(oneBundleUsageHistory, "test", 0, 0, 1000, 2000, 100, 0);
1045 SUCCEED();
1046 bundleUserHistory_->ReportUsage(oneBundleUsageHistory, "test", 0, 0, 2000, 1000, 100, 0);
1047 SUCCEED();
1048 bundleUserHistory_->ReportUsage(oneBundleUsageHistory, "test", 10, 0, 1000, 2000, 100, 0);
1049 SUCCEED();
1050 bundleUserHistory_->ReportUsage(oneBundleUsageHistory, "test", 20, 0, 1000, 2000, 100, 0);
1051 SUCCEED();
1052 bundleUserHistory_->ReportUsage(oneBundleUsageHistory, "test", 20, 0, 0, 2000, 100, 0);
1053 SUCCEED();
1054 }
1055
1056 /*
1057 * @tc.name: BundleActiveUserHistoryTest_004
1058 * @tc.desc: test the interface
1059 * @tc.type: FUNC
1060 * @tc.require: DTS2023121404861
1061 */
1062 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_004,
1063 Function | MediumTest | Level0)
1064 {
1065 int32_t userId = 100;
1066 int64_t bootBasedTimeStamp = 2000;
1067 int32_t newgroup = 0;
1068 uint32_t groupReason = 0;
1069 int32_t uid = 0;
1070 auto bundleUserHistory_ = std::make_shared<BundleActiveUserHistory>(bootBasedTimeStamp, bundleActiveCore_);
1071 bundleUserHistory_->SetAppGroup("test", userId, uid, bootBasedTimeStamp, newgroup, groupReason, true);
1072 SUCCEED();
1073 bundleUserHistory_->SetAppGroup("test", userId, uid, bootBasedTimeStamp, newgroup, groupReason, false);
1074 SUCCEED();
1075 }
1076
1077 /*
1078 * @tc.name: BundleActiveUserHistoryTest_005
1079 * @tc.desc: test the interface
1080 * @tc.type: FUNC
1081 * @tc.require: DTS2023121404861
1082 */
1083 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_005,
1084 Function | MediumTest | Level0)
1085 {
1086 int64_t bootBasedTimeStamp = 2000;
1087 auto bundleUserHistory_ = std::make_shared<BundleActiveUserHistory>(bootBasedTimeStamp, bundleActiveCore_);
1088 bundleUserHistory_->PrintData(0);
1089 SUCCEED();
1090 }
1091
1092 /*
1093 * @tc.name: DeviceUsageStatisticsServiceTest_ShutDown_001
1094 * @tc.desc: ShutDown
1095 * @tc.type: FUNC
1096 * @tc.require: issuesI5SOZY
1097 */
1098 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ShutDown_001,
1099 Function | MediumTest | Level0)
1100 {
1101 auto coreObject = bundleActiveCore_;
1102 coreObject->ShutDown();
1103 EXPECT_NE(coreObject, nullptr);
1104 }
1105
1106 /*
1107 * @tc.name: DeviceUsageStatisticsServiceTest_CheckTimeChangeAndGetWallTime_001
1108 * @tc.desc: CheckTimeChangeAndGetWallTime
1109 * @tc.type: FUNC
1110 * @tc.require: issuesI5SOZY
1111 */
1112 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CheckTimeChangeAndGetWallTime_001,
1113 Function | MediumTest | Level0)
1114 {
1115 int userId = 100;
1116 auto coreObject = bundleActiveCore_;
1117 coreObject->OnUserRemoved(100);
1118 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
1119 coreObject->userStatServices_[userId] = userService;
1120
1121 coreObject->CheckTimeChangeAndGetWallTime(userId);
1122 coreObject->OnUserSwitched(userId);
1123 EXPECT_NE(coreObject, nullptr);
1124 }
1125
1126 /*
1127 * @tc.name: DeviceUsageStatisticsServiceTest_QueryAppGroup_001
1128 * @tc.desc: QueryAppGroup
1129 * @tc.type: FUNC
1130 * @tc.require: issuesI5SOZY
1131 */
1132 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryAppGroup_001,
1133 Function | MediumTest | Level0)
1134 {
1135 auto groupController = bundleActiveCore_->bundleGroupController_;
1136 int32_t appGroup = 10;
1137 std::string bundleName = "";
1138 int32_t userId = 100;
1139 EXPECT_NE(groupController->QueryAppGroup(appGroup, bundleName, userId), ERR_OK);
1140
1141 groupController->sptrBundleMgr_ = nullptr;
1142 bundleName = "defaultBundleName";
1143 EXPECT_NE(groupController->QueryAppGroup(appGroup, bundleName, userId), ERR_OK);
1144 }
1145
1146 /*
1147 * @tc.name: DeviceUsageStatisticsServiceTest_ControllerReportEvent_001
1148 * @tc.desc: ControllerReportEvent
1149 * @tc.type: FUNC
1150 * @tc.require: issuesI5SOZY
1151 */
1152 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ControllerReportEvent_001,
1153 Function | MediumTest | Level0)
1154 {
1155 auto coreObject = bundleActiveCore_;
1156
1157 int64_t bootBasedTimeStamp = 20000000000000;
1158 BundleActiveEvent event;
1159 int32_t userId = 100;
1160 coreObject->bundleGroupController_->bundleGroupEnable_ = false;
1161 coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId);
1162
1163 coreObject->bundleGroupController_->bundleGroupEnable_ = true;
1164 event.bundleName_ = "com.ohos.camera";
1165 coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId);
1166
1167 event.eventId_ = BundleActiveEvent::NOTIFICATION_SEEN;
1168 coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId);
1169
1170 event.eventId_ = BundleActiveEvent::SYSTEM_INTERACTIVE;
1171 coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId);
1172 EXPECT_NE(coreObject, nullptr);
1173 }
1174
1175 /*
1176 * @tc.name: DeviceUsageStatisticsServiceTest_CheckAndUpdateGroup_001
1177 * @tc.desc: CheckAndUpdateGroup
1178 * @tc.type: FUNC
1179 * @tc.require: issuesI5SOZY
1180 */
1181 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CheckAndUpdateGroup_001,
1182 Function | MediumTest | Level0)
1183 {
1184 auto coreObject = bundleActiveCore_;
1185
1186 std::string bundleName = "com.ohos.camera";
1187 int32_t userId = 100;
1188 int64_t bootBasedTimeStamp = 20000000000000;
1189 int32_t newGroup = 30;
1190 uint32_t reason = GROUP_CONTROL_REASON_TIMEOUT;
1191 bool isFlush = false;
1192
1193 int32_t appGroup = 0;
1194 coreObject->bundleGroupController_->QueryAppGroup(appGroup, bundleName, userId);
1195
1196 coreObject->bundleGroupController_->SetAppGroup(bundleName, userId, newGroup, reason, bootBasedTimeStamp, isFlush);
1197 coreObject->bundleGroupController_->CheckAndUpdateGroup(bundleName, 0, userId, bootBasedTimeStamp);
1198
1199 newGroup = 20;
1200 reason = GROUP_CONTROL_REASON_CALCULATED;
1201 coreObject->bundleGroupController_->SetAppGroup(bundleName, userId, newGroup, reason, bootBasedTimeStamp, isFlush);
1202 coreObject->bundleGroupController_->CheckAndUpdateGroup(bundleName, 0, userId, bootBasedTimeStamp);
1203 EXPECT_NE(coreObject, nullptr);
1204 }
1205
1206 /*
1207 * @tc.name: DeviceUsageStatisticsServiceTest_PreservePowerStateInfo_001
1208 * @tc.desc: PreservePowerStateInfo
1209 * @tc.type: FUNC
1210 * @tc.require: issuesI5SOZY
1211 */
1212 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_PreservePowerStateInfo_001,
1213 Function | MediumTest | Level0)
1214 {
1215 auto coreObject = bundleActiveCore_;
1216
1217 int32_t eventId = BundleActiveEvent::ABILITY_FOREGROUND;
1218 coreObject->PreservePowerStateInfo(eventId);
1219 EXPECT_NE(coreObject, nullptr);
1220 }
1221
1222 /*
1223 * @tc.name: DeviceUsageStatisticsServiceTest_UpdateModuleData_001
1224 * @tc.desc: UpdateModuleData
1225 * @tc.type: FUNC
1226 * @tc.require: issuesI5SOZY
1227 */
1228 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_UpdateModuleData_001,
1229 Function | MediumTest | Level0)
1230 {
1231 auto database = std::make_shared<BundleActiveUsageDatabase>();
1232 auto moduleRecords = std::map<std::string, std::shared_ptr<BundleActiveModuleRecord>>();
1233 int64_t timeStamp = 20000000000;
1234 int32_t userId = 100;
1235 database->UpdateModuleData(userId, moduleRecords, timeStamp);
1236 EXPECT_NE(database, nullptr);
1237 }
1238
1239 /*
1240 * @tc.name: DeviceUsageStatisticsServiceTest_QueryNotificationEventStats_001
1241 * @tc.desc: QueryNotificationEventStats
1242 * @tc.type: FUNC
1243 * @tc.require: issuesI5SOZY
1244 */
1245 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryNotificationEventStats_001,
1246 Function | MediumTest | Level0)
1247 {
1248 auto database = std::make_shared<BundleActiveUsageDatabase>();
1249
1250 int32_t eventId = 2;
1251 int64_t beginTime = 0;
1252 int64_t endTime = 0;
1253 auto notificationEventStats = std::map<std::string, BundleActiveEventStats>();
1254 int32_t userId = 100;
1255 BUNDLE_ACTIVE_LOGI("database->QueryNotificationEventStats");
1256 database->QueryNotificationEventStats(eventId, beginTime, endTime, notificationEventStats, userId);
1257 EXPECT_NE(database, nullptr);
1258 }
1259
1260 /*
1261 * @tc.name: DeviceUsageStatisticsServiceTest_QueryDeviceEventStats_001
1262 * @tc.desc: QueryDeviceEventStats
1263 * @tc.type: FUNC
1264 * @tc.require: issuesI5SOZY
1265 */
1266 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryDeviceEventStats_001,
1267 Function | MediumTest | Level0)
1268 {
1269 auto database = std::make_shared<BundleActiveUsageDatabase>();
1270
1271 int32_t eventId = 2;
1272 int64_t beginTime = 0;
1273 int64_t endTime = 0;
1274 auto eventStats = std::map<std::string, BundleActiveEventStats>();
1275 int32_t userId = 100;
1276 BUNDLE_ACTIVE_LOGI("database->QueryDeviceEventStats");
1277 database->QueryDeviceEventStats(eventId, beginTime, endTime, eventStats, userId);
1278 EXPECT_NE(database, nullptr);
1279 }
1280
1281 /*
1282 * @tc.name: DeviceUsageStatisticsServiceTest_QueryDatabaseEvents_001
1283 * @tc.desc: QueryDatabaseEvents
1284 * @tc.type: FUNC
1285 * @tc.require: issuesI5SOZY
1286 */
1287 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryDatabaseEvents_001,
1288 Function | MediumTest | Level0)
1289 {
1290 auto database = std::make_shared<BundleActiveUsageDatabase>();
1291
1292 int64_t beginTime = 0;
1293 int64_t endTime = 0;
1294 std::string bundleName;
1295 int32_t userId = 100;
1296 BUNDLE_ACTIVE_LOGI("database->QueryDatabaseEvents");
1297 database->QueryDatabaseEvents(beginTime, endTime, userId, bundleName);
1298
1299 bundleName = "com.ohos.camera";
1300 database->QueryDatabaseEvents(beginTime, endTime, userId, bundleName);
1301 EXPECT_NE(database, nullptr);
1302 }
1303
1304 /*
1305 * @tc.name: DeviceUsageStatisticsServiceTest_UpdateEventData_001
1306 * @tc.desc: UpdateEventData
1307 * @tc.type: FUNC
1308 * @tc.require: issuesI5SOZY
1309 */
1310 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_UpdateEventData_001,
1311 Function | MediumTest | Level0)
1312 {
1313 auto database = std::make_shared<BundleActiveUsageDatabase>();
1314
1315 int32_t databaseType = WEEKLY_DATABASE_INDEX;
1316 BundleActivePeriodStats stats;
1317 database->UpdateEventData(databaseType, stats);
1318
1319 databaseType = DAILY_DATABASE_INDEX;
1320 database->UpdateEventData(databaseType, stats);
1321 EXPECT_NE(database, nullptr);
1322 }
1323
1324 /*
1325 * @tc.name: DeviceUsageStatisticsServiceTest_UpdateBundleUsageData_001
1326 * @tc.desc: UpdateBundleUsageData
1327 * @tc.type: FUNC
1328 * @tc.require: issuesI5SOZY
1329 */
1330 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_UpdateBundleUsageData_001,
1331 Function | MediumTest | Level0)
1332 {
1333 auto database = std::make_shared<BundleActiveUsageDatabase>();
1334
1335 int32_t databaseType = -1;
1336 BundleActivePeriodStats stats;
1337 database->UpdateBundleUsageData(databaseType, stats);
1338
1339 databaseType = EVENT_DATABASE_INDEX;
1340 database->UpdateBundleUsageData(databaseType, stats);
1341
1342 databaseType = DAILY_DATABASE_INDEX;
1343 database->UpdateBundleUsageData(databaseType, stats);
1344 EXPECT_NE(database, nullptr);
1345 }
1346
1347 /*
1348 * @tc.name: DeviceUsageStatisticsServiceTest_RenewTableTime_001
1349 * @tc.desc: RenewTableTime
1350 * @tc.type: FUNC
1351 * @tc.require: issuesI5SOZY
1352 */
1353 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RenewTableTime_001,
1354 Function | MediumTest | Level0)
1355 {
1356 auto database = std::make_shared<BundleActiveUsageDatabase>();
1357
1358 int64_t timeDiffMillis = 0;
1359 database->sortedTableArray_[0] = {-1, 0};
1360 database->RenewTableTime(timeDiffMillis);
1361
1362 database->eventTableName_ = "";
1363 database->RenewTableTime(timeDiffMillis);
1364
1365 database->eventTableName_ = "defaultTableName";
1366 database->RenewTableTime(timeDiffMillis);
1367
1368 database->formRecordsTableName_ = "defaultFormRecordsTableName";
1369 database->RenewTableTime(timeDiffMillis);
1370
1371 database->moduleRecordsTableName_ = "defaultModuleRecordsTableName_";
1372 database->RenewTableTime(timeDiffMillis);
1373 EXPECT_NE(database, nullptr);
1374 }
1375
1376 /*
1377 * @tc.name: DeviceUsageStatisticsServiceTest_SetNewIndexWhenTimeChanged_001
1378 * @tc.desc: SetNewIndexWhenTimeChanged
1379 * @tc.type: FUNC
1380 * @tc.require: issuesI5SOZY
1381 */
1382 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_SetNewIndexWhenTimeChanged_001,
1383 Function | MediumTest | Level0)
1384 {
1385 auto database = std::make_shared<BundleActiveUsageDatabase>();
1386
1387 uint32_t databaseType = APP_GROUP_DATABASE_INDEX;
1388 int64_t tableOldTime = 0;
1389 int64_t tableNewTime = 20000000000000;
1390 std::shared_ptr<NativeRdb::RdbStore> rdbStore = nullptr;
1391 EXPECT_NE(database->SetNewIndexWhenTimeChanged(databaseType, tableOldTime, tableNewTime, rdbStore), ERR_OK);
1392
1393 rdbStore = database->GetBundleActiveRdbStore(databaseType);
1394 database->SetNewIndexWhenTimeChanged(databaseType, tableOldTime, tableNewTime, rdbStore);
1395 EXPECT_NE(database, nullptr);
1396 }
1397
1398 /*
1399 * @tc.name: DeviceUsageStatisticsServiceTest_ReportContinuousTaskEvent_001
1400 * @tc.desc: ReportContinuousTaskEvent
1401 * @tc.type: FUNC
1402 * @tc.require: issuesI5SOZY
1403 */
1404 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ReportContinuousTaskEvent_001,
1405 Function | MediumTest | Level0)
1406 {
1407 #ifdef BGTASKMGR_ENABLE
1408 auto bgtaskObserver = std::make_shared<BundleActiveContinuousTaskObserver>();
1409 auto continuousTaskCallbackInfo = std::shared_ptr<OHOS::BackgroundTaskMgr::ContinuousTaskCallbackInfo>();
1410 continuousTaskCallbackInfo->creatorUid_ = 20000000;
1411 bool isStart = false;
1412 bgtaskObserver->ReportContinuousTaskEvent(continuousTaskCallbackInfo, isStart);
1413
1414 isStart = true;
1415 bgtaskObserver->ReportContinuousTaskEvent(continuousTaskCallbackInfo, isStart);
1416 EXPECT_NE(bgtaskObserver, nullptr);
1417 #endif
1418 }
1419
1420 /*
1421 * @tc.name: DeviceUsageStatisticsServiceTest_RemoveFormData_001
1422 * @tc.desc: RemoveFormData
1423 * @tc.type: FUNC
1424 * @tc.require: issuesI5SOZY
1425 */
1426 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RemoveFormData_001,
1427 Function | MediumTest | Level0)
1428 {
1429 auto database = std::make_shared<BundleActiveUsageDatabase>();
1430 int32_t userId = 100;
1431 std::string bundleName = "defaultBundleName";
1432 std::string moduleName = "defaultModuleName";
1433 std::string formName = "defaultFormName";
1434 database->InitUsageGroupDatabase(0, true);
1435 database->RemoveFormData(userId, bundleName, moduleName, formName, 0, 0, 0);
1436 EXPECT_NE(database, nullptr);
1437 }
1438
1439 /*
1440 * @tc.name: DeviceUsageStatisticsServiceTest_UpdateFormData_001
1441 * @tc.desc: UpdateFormData
1442 * @tc.type: FUNC
1443 * @tc.require: issuesI5SOZY
1444 */
1445 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_UpdateFormData_001,
1446 Function | MediumTest | Level0)
1447 {
1448 auto database = std::make_shared<BundleActiveUsageDatabase>();
1449 int32_t userId = 100;
1450 std::string bundleName = "defaultBundleName";
1451 std::string moduleName = "defaultModuleName";
1452 std::string formName = "defaultFormName";
1453 std::vector<NativeRdb::ValuesBucket> formValueBuckets;
1454 database->InitUsageGroupDatabase(0, true);
1455 BundleActiveFormRecord formRecord;
1456 auto rdbStore = database->GetBundleActiveRdbStore(0);
1457 database->UpdateFormData(userId, bundleName, moduleName, formRecord, rdbStore, formValueBuckets);
1458 EXPECT_NE(database, nullptr);
1459 }
1460
1461 /*
1462 * @tc.name: DeviceUsageStatisticsServiceTest_DeleteUninstalledBundleStats_001
1463 * @tc.desc: onstart
1464 * @tc.type: FUNC
1465 * @tc.require: issuesI9Q9ZJ
1466 */
1467 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_DeleteUninstalledBundleStats_001,
1468 Function | MediumTest | Level0)
1469 {
1470 auto coreObject = bundleActiveCore_;
1471 int userId = 100;
1472 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
1473 int appIndex = 1;
1474 std::vector<std::shared_ptr<BundleActivePeriodStats>> curStats;
1475 std::shared_ptr<BundleActivePeriodStats> stats = std::make_shared<BundleActivePeriodStats>();
1476 stats->bundleStats_["test0"] = std::make_shared<BundleActivePackageStats>();
1477 stats->bundleStats_["test1"] = std::make_shared<BundleActivePackageStats>();
1478 stats->bundleStats_["test2"] = std::make_shared<BundleActivePackageStats>();
1479 curStats.push_back(stats);
1480 userService->currentStats_ = curStats;
1481 userService->DeleteUninstalledBundleStats("test", 0, appIndex);
1482 appIndex = 0;
1483 userService->DeleteUninstalledBundleStats("test", 0, appIndex);
1484 userService->OnUserRemoved();
1485 userService->NotifyNewUpdate();
1486 }
1487
1488 /*
1489 * @tc.name: DeviceUsageStatisticsServiceTest_DeleteUninstalledBundleStats_002
1490 * @tc.desc: onstart
1491 * @tc.type: FUNC
1492 * @tc.require: issuesI9Q9ZJ
1493 */
1494 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_DeleteUninstalledBundleStats_002,
1495 Function | MediumTest | Level0)
1496 {
1497 auto coreObject = bundleActiveCore_;
1498 int userId = 100;
1499 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
1500 int appIndex = 1;
1501 std::vector<std::shared_ptr<BundleActivePeriodStats>> curStats;
1502 std::shared_ptr<BundleActivePeriodStats> stats = std::make_shared<BundleActivePeriodStats>();
1503 stats->bundleStats_["test0"] = std::make_shared<BundleActivePackageStats>();
1504 stats->bundleStats_["test1"] = std::make_shared<BundleActivePackageStats>();
1505 stats->bundleStats_["test2"] = std::make_shared<BundleActivePackageStats>();
1506
1507 BundleActiveEvent event;
1508 event.bundleName_ = "test";
1509 event.uid_ = 0;
1510 stats->events_.Insert(event);
1511 BundleActiveEvent event2;
1512 event.bundleName_ = "test";
1513 event.uid_ = 1;
1514 stats->events_.Insert(event);
1515 curStats.push_back(stats);
1516 userService->moduleRecords_["test0"] = std::make_shared<BundleActiveModuleRecord>();
1517 userService->moduleRecords_["test1"] = std::make_shared<BundleActiveModuleRecord>();
1518 userService->moduleRecords_["test2"] = std::make_shared<BundleActiveModuleRecord>();
1519 userService->currentStats_ = curStats;
1520 userService->DeleteUninstalledBundleStats("test", 100, appIndex);
1521 appIndex = 0;
1522 userService->DeleteUninstalledBundleStats("test", 100, appIndex);
1523 }
1524
1525 /*
1526 * @tc.name: DeviceUsageStatisticsServiceTest_ConfigReader_001
1527 * @tc.desc: ConfigReader
1528 * @tc.type: FUNC
1529 * @tc.require: issuesIBCE1G
1530 */
1531 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ConfigReader_001,
1532 Function | MediumTest | Level0)
1533 {
1534 auto bundleActiveConfigReader = std::make_shared<BundleActiveConfigReader>();
1535 EXPECT_NE(bundleActiveConfigReader, nullptr);
1536 bundleActiveConfigReader->LoadConfig();
1537 EXPECT_NE(bundleActiveConfigReader->GetApplicationUsePeriodicallyConfig().minUseTimes, 0);
1538 }
1539
1540 /*
1541 * @tc.name: DeviceUsageStatisticsServiceTest_ConfigReader_002
1542 * @tc.desc: ConfigReader
1543 * @tc.type: FUNC
1544 * @tc.require: issuesIBCE1G
1545 */
1546 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ConfigReader_002,
1547 Function | MediumTest | Level0)
1548 {
1549 auto bundleActiveConfigReader = std::make_shared<BundleActiveConfigReader>();
1550 EXPECT_NE(bundleActiveConfigReader, nullptr);
1551 const char *path = "test";
1552 bundleActiveConfigReader->LoadApplicationUsePeriodically(path);
1553 EXPECT_EQ(bundleActiveConfigReader->GetApplicationUsePeriodicallyConfig().minUseTimes, 0);
1554 }
1555
1556 /*
1557 * @tc.name: DeviceUsageStatisticsServiceTest_ConfigReader_003
1558 * @tc.desc: ConfigReader
1559 * @tc.type: FUNC
1560 * @tc.require: issuesIBCE1G
1561 */
1562 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ConfigReader_003,
1563 Function | MediumTest | Level0)
1564 {
1565 auto bundleActiveConfigReader = std::make_shared<BundleActiveConfigReader>();
1566 EXPECT_NE(bundleActiveConfigReader, nullptr);
1567 const char *path = "test";
1568 Json::Value root;
1569 bool result = bundleActiveConfigReader->GetJsonFromFile(path, root);
1570 EXPECT_EQ(result, false);
1571 }
1572
1573 /*
1574 * @tc.name: DeviceUsageStatisticsServiceTest_ConfigReader_004
1575 * @tc.desc: ConfigReader
1576 * @tc.type: FUNC
1577 * @tc.require: issuesIBCE1G
1578 */
1579 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ConfigReader_004,
1580 Function | MediumTest | Level0)
1581 {
1582 auto bundleActiveConfigReader = std::make_shared<BundleActiveConfigReader>();
1583 EXPECT_NE(bundleActiveConfigReader, nullptr);
1584 std::string partialPath = "test";
1585 std::string fullPath = "";
1586 bool result = bundleActiveConfigReader->ConvertFullPath(partialPath, fullPath);
1587 EXPECT_EQ(result, false);
1588 }
1589
1590 /*
1591 * @tc.name: DeviceUsageStatisticsServiceTest_MergePackageStats_001
1592 * @tc.desc: MergePackageStats
1593 * @tc.type: FUNC
1594 * @tc.require: IC0GWV
1595 */
1596 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_MergePackageStats_001,
1597 Function | MediumTest | Level0)
1598 {
1599 std::vector<BundleActivePackageStats> bundleActivePackageStatsVector;
1600 BundleActivePackageStats bundleActivePackageStats;
1601 bundleActivePackageStats.bundleName_ = "test";
1602 bundleActivePackageStats.uid_ = 1;
1603 bundleActivePackageStatsVector.push_back(bundleActivePackageStats);
1604 BundleActivePackageStats bundleActivePackageStats2;
1605 bundleActivePackageStats2.bundleName_ = "test";
1606 bundleActivePackageStats2.uid_ = 1;
1607 bundleActivePackageStatsVector.push_back(bundleActivePackageStats2);
1608 BundleActivePackageStats bundleActivePackageStats3;
1609 bundleActivePackageStats3.bundleName_ = "test";
1610 bundleActivePackageStats3.uid_ = 2;
1611 bundleActivePackageStatsVector.push_back(bundleActivePackageStats3);
1612 auto bundleActiveService = std::make_shared<BundleActiveService>();
1613 auto MergeResult = bundleActiveService->MergePackageStats(bundleActivePackageStatsVector);
1614 EXPECT_EQ(MergeResult.size(), 2);
1615 }
1616
1617 } // namespace DeviceUsageStats
1618 } // namespace OHOS