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 
18 #include <gtest/gtest.h>
19 #include "system_ability_definition.h"
20 
21 #include "bundle_active_calendar.h"
22 #include "bundle_active_module_record.h"
23 #include "bundle_active_event_tracker.h"
24 #include "bundle_active_package_stats.h"
25 #include "bundle_active_event.h"
26 #include "bundle_active_form_record.h"
27 #include "bundle_active_event_stats.h"
28 #include "bundle_active_user_service.h"
29 #include "bundle_active_core.h"
30 #include "bundle_active_stats_combiner.h"
31 #include "bundle_active_report_handler.h"
32 #include "bundle_active_log.h"
33 #include "bundle_active_group_controller.h"
34 
35 using namespace testing::ext;
36 
37 namespace OHOS {
38 namespace DeviceUsageStats {
39 class PackageUsageTest : public testing::Test {
40 public:
41     static void SetUpTestCase(void);
42     static void TearDownTestCase(void);
43     void SetUp();
44     void TearDown();
45     static std::shared_ptr<BundleActiveCore> bundleActiveCore_;
46 };
47 
48 std::shared_ptr<BundleActiveCore> PackageUsageTest::bundleActiveCore_ = nullptr;
49 
SetUpTestCase(void)50 void PackageUsageTest::SetUpTestCase(void)
51 {
52     bundleActiveCore_ = std::make_shared<BundleActiveCore>();
53     bundleActiveCore_->Init();
54     bundleActiveCore_->InitBundleGroupController();
55 }
56 
TearDownTestCase(void)57 void PackageUsageTest::TearDownTestCase(void)
58 {
59     bundleActiveCore_->bundleGroupHandler_->ffrtQueue_.reset();
60     int64_t sleepTime = 3;
61     std::this_thread::sleep_for(std::chrono::seconds(sleepTime));
62 }
63 
SetUp(void)64 void PackageUsageTest::SetUp(void)
65 {
66 }
67 
TearDown(void)68 void PackageUsageTest::TearDown(void)
69 {
70     int64_t sleepTime = 300;
71     std::this_thread::sleep_for(std::chrono::milliseconds(sleepTime));
72 }
73 
74 /*
75  * @tc.name: PackageUsageTest_Update_001
76  * @tc.desc: Update
77  * @tc.type: FUNC
78  * @tc.require: issuesI5SOZY
79  */
80 HWTEST_F(PackageUsageTest, PackageUsageTest_Update_001, Function | MediumTest | Level0)
81 {
82     auto packageStats = std::make_shared<BundleActivePackageStats>();
83     std::string longTimeTaskName = "defaultLongTimeTaskName";
84     int64_t timeStamp = 20000000000000;
85     int32_t eventId = BundleActiveEvent::ABILITY_FOREGROUND;
86     std::string abilityId = "defaultAbilityId";
87     int32_t uid = 0;
88     packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId, uid);
89 
90     eventId = BundleActiveEvent::ABILITY_BACKGROUND;
91     packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId, uid);
92 
93     eventId = BundleActiveEvent::ABILITY_STOP;
94     packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId, uid);
95 
96     eventId = BundleActiveEvent::END_OF_THE_DAY;
97     packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId, uid);
98 
99     eventId = BundleActiveEvent::LONG_TIME_TASK_STARTTED;
100     packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId, uid);
101 
102     eventId = BundleActiveEvent::LONG_TIME_TASK_ENDED;
103     packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId, uid);
104 
105     eventId = BundleActiveEvent::SHUTDOWN;
106     packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId, uid);
107 
108     eventId = BundleActiveEvent::FLUSH;
109     packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId, uid);
110 
111     eventId = BundleActiveEvent::SYSTEM_LOCK;
112     packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId, uid);
113     EXPECT_NE(packageStats, nullptr);
114 }
115 
116 /*
117  * @tc.name: PackageUsageTest_UpdateLongTimeTask_001
118  * @tc.desc: UpdateLongTimeTask
119  * @tc.type: FUNC
120  * @tc.require: issuesI5SOZY
121  */
122 HWTEST_F(PackageUsageTest, PackageUsageTest_UpdateLongTimeTask_001, Function | MediumTest | Level0)
123 {
124     auto packageStats = std::make_shared<BundleActivePackageStats>();
125     std::string longTimeTaskName = "defaultLongTimeTaskName";
126     int64_t timeStamp = 20000000000000;
127     int32_t eventId = BundleActiveEvent::ABILITY_FOREGROUND;
128     packageStats->UpdateLongTimeTask(longTimeTaskName, timeStamp, eventId);
129 
130     eventId = BundleActiveEvent::LONG_TIME_TASK_ENDED;
131     packageStats->UpdateLongTimeTask(longTimeTaskName, timeStamp, eventId);
132     packageStats->UpdateLongTimeTask(longTimeTaskName, timeStamp, eventId);
133 
134     eventId = BundleActiveEvent::LONG_TIME_TASK_STARTTED;
135     packageStats->UpdateLongTimeTask(longTimeTaskName, timeStamp, eventId);
136     EXPECT_NE(packageStats, nullptr);
137 }
138 
139 /*
140  * @tc.name: PackageUsageTest_UpdateAbility_001
141  * @tc.desc: UpdateAbility
142  * @tc.type: FUNC
143  * @tc.require: issuesI5SOZY
144  */
145 HWTEST_F(PackageUsageTest, PackageUsageTest_UpdateAbility_001, Function | MediumTest | Level0)
146 {
147     auto packageStats = std::make_shared<BundleActivePackageStats>();
148     std::string abilityId = "defaultAbilityId";
149     int64_t timeStamp = 20000000000000;
150     int32_t eventId = BundleActiveEvent::LONG_TIME_TASK_ENDED;
151     packageStats->UpdateAbility(timeStamp, eventId, abilityId);
152 
153     eventId = BundleActiveEvent::ABILITY_FOREGROUND;
154     packageStats->UpdateAbility(timeStamp, eventId, abilityId);
155 
156     eventId = BundleActiveEvent::ABILITY_BACKGROUND;
157     packageStats->UpdateAbility(timeStamp, eventId, abilityId);
158     packageStats->HasFrontAbility();
159 
160     eventId = BundleActiveEvent::ABILITY_STOP;
161     packageStats->UpdateAbility(timeStamp, eventId, abilityId);
162     EXPECT_NE(packageStats, nullptr);
163 }
164 
165 /*
166  * @tc.name: PackageUsageTest_Increment_001
167  * @tc.desc: IncrementServiceTimeUsed and IncrementTimeUsed
168  * @tc.type: FUNC
169  * @tc.require: issuesI5SOZY
170  */
171 HWTEST_F(PackageUsageTest, PackageUsageTest_Increment_001, Function | MediumTest | Level0)
172 {
173     auto packageStats = std::make_shared<BundleActivePackageStats>();
174     int64_t largeNum = 20000000000000;
175     packageStats->lastContiniousTaskUsed_ = largeNum;
176     packageStats->IncrementServiceTimeUsed(largeNum + 1);
177     packageStats->IncrementServiceTimeUsed(largeNum);
178 
179     packageStats->lastTimeUsed_ = largeNum;
180     packageStats->IncrementTimeUsed(largeNum + 1);
181     packageStats->IncrementTimeUsed(largeNum);
182     EXPECT_NE(packageStats, nullptr);
183 }
184 
185 /*
186  * @tc.name: PackageUsageTest_BundleActiveModuleRecord_001
187  * @tc.desc: BundleActiveModuleRecord
188  * @tc.type: FUNC
189  * @tc.require: issuesI5SOZY
190  */
191 HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveModuleRecord_001, Function | MediumTest | Level0)
192 {
193     auto moduleRecord = std::make_shared<BundleActiveModuleRecord>();
194     std::string forName = "defaultformname";
195     int32_t formDimension = 1;
196     int64_t formId = 1;
197     int64_t timeStamp = 20000000000000;
198     int32_t uid = 0;
199     moduleRecord->AddOrUpdateOneFormRecord(forName, formDimension, formId, timeStamp, uid);
200     moduleRecord->AddOrUpdateOneFormRecord(forName, formDimension, formId, timeStamp*10, uid);
201     moduleRecord->lastModuleUsedTime_ = timeStamp;
202     moduleRecord->UpdateModuleRecord(timeStamp);
203     moduleRecord->RemoveOneFormRecord(forName, formDimension, formId);
204     EXPECT_NE(moduleRecord, nullptr);
205 }
206 
207 /*
208  * @tc.name: PackageUsageTest_BundleActiveEventTracker_001
209  * @tc.desc: BundleActiveEventTracker
210  * @tc.type: FUNC
211  * @tc.require: issuesI5SOZY
212  */
213 HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveEventTracker_001, Function | MediumTest | Level0)
214 {
215     auto eventTracker = std::make_shared<BundleActiveEventTracker>();
216     eventTracker->curStartTime_ = 0;
217     int64_t timeStamp = 20000000000000;
218     eventTracker->Update(timeStamp);
219 
220     eventTracker->curStartTime_ = 1;
221     eventTracker->Update(timeStamp);
222 
223     eventTracker->count_ = 0;
224     eventTracker->duration_ = 0;
225     std::vector<BundleActiveEventStats> eventStatsList;
226     int32_t eventId = BundleActiveEvent::ABILITY_FOREGROUND;
227     int64_t beginTime = 0;
228     int64_t endTime = timeStamp;
229     eventTracker->AddToEventStats(eventStatsList, eventId, beginTime, endTime);
230 
231     eventTracker->count_ = 0;
232     eventTracker->duration_ = 1;
233     eventTracker->AddToEventStats(eventStatsList, eventId, beginTime, endTime);
234 
235     eventTracker->count_ = 1;
236     eventTracker->duration_ = 0;
237     eventTracker->AddToEventStats(eventStatsList, eventId, beginTime, endTime);
238     EXPECT_NE(eventTracker, nullptr);
239 }
240 
241 /*
242  * @tc.name: PackageUsageTest_BundleActiveFormRecord_001
243  * @tc.desc: BundleActiveFormRecord
244  * @tc.type: FUNC
245  * @tc.require: issuesI5SOZY
246  */
247 HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveFormRecord_001, Function | MediumTest | Level0)
248 {
249     auto formRecord = std::make_shared<BundleActiveFormRecord>();
250     int64_t timeStamp = 20000000000000;
251     formRecord->UpdateFormRecord(timeStamp);
252     formRecord->UpdateFormRecord(timeStamp);
253     EXPECT_NE(formRecord, nullptr);
254 }
255 
256 /*
257  * @tc.name: PackageUsageTest_BundleActiveEventStats_001
258  * @tc.desc: BundleActiveEventStats
259  * @tc.type: FUNC
260  * @tc.require: issuesI5SOZY
261  */
262 HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveEventStats_001, Function | MediumTest | Level0)
263 {
264     auto eventStats = std::make_shared<BundleActiveEventStats>();
265     BundleActiveEventStats stat;
266     stat.eventId_ = 1;
267     eventStats->add(stat);
268 
269     stat.eventId_ = 0;
270     stat.beginTimeStamp_ = 1;
271     eventStats->add(stat);
272 
273     stat.beginTimeStamp_ = -1;
274     eventStats->add(stat);
275     EXPECT_NE(eventStats, nullptr);
276 }
277 
278 /*
279  * @tc.name: PackageUsageTest_ReportForShutdown_001
280  * @tc.desc: ReportForShutdown
281  * @tc.type: FUNC
282  * @tc.require: issuesI5SOZY
283  */
284 HWTEST_F(PackageUsageTest, PackageUsageTest_ReportForShutdown_001, Function | MediumTest | Level0)
285 {
286     int32_t userId = 100;
287     auto bundleActiveCore = bundleActiveCore_;
288     auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), false);
289     BundleActiveEvent event;
290     event.eventId_ = BundleActiveEvent::ABILITY_FOREGROUND;
291     bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
292     bundleUserService->ReportForShutdown(event);
293 
294     event.eventId_ = BundleActiveEvent::SHUTDOWN;
295     bundleUserService->ReportForShutdown(event);
296 
297     event.timeStamp_ = -1;
298     bundleUserService->ReportForShutdown(event);
299     EXPECT_NE(bundleUserService, nullptr);
300 }
301 
302 /*
303  * @tc.name: PackageUsageTest_ReportFormEvent_001
304  * @tc.desc: ReportFormEvent
305  * @tc.type: FUNC
306  * @tc.require: issuesI5SOZY
307  */
308 HWTEST_F(PackageUsageTest, PackageUsageTest_ReportFormEvent_001, Function | MediumTest | Level0)
309 {
310     int32_t userId = 100;
311     auto bundleActiveCore = bundleActiveCore_;
312     auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
313     BundleActiveEvent event;
314     event.bundleName_ = "defaultBundleName";
315     event.moduleName_ = "defaultModuleName";
316     event.eventId_ = BundleActiveEvent::FORM_IS_CLICKED;
317     bundleUserService->ReportFormEvent(event);
318 
319     event.eventId_ = BundleActiveEvent::FORM_IS_REMOVED;
320     bundleUserService->ReportFormEvent(event);
321     EXPECT_NE(bundleUserService, nullptr);
322 }
323 
324 /*
325  * @tc.name: PackageUsageTest_PrintInMemFormStats_001
326  * @tc.desc: PrintInMemFormStats
327  * @tc.type: FUNC
328  * @tc.require: issuesI5SOZY
329  */
330 HWTEST_F(PackageUsageTest, PackageUsageTest_PrintInMemFormStats_001, Function | MediumTest | Level0)
331 {
332     int32_t userId = 100;
333     auto bundleActiveCore = bundleActiveCore_;
334     auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
335     BundleActiveEvent event;
336     event.bundleName_ = "defaultBundleName";
337     event.moduleName_ = "defaultModuleName";
338     bundleUserService->GetOrCreateModuleRecord(event);
339 
340     bundleUserService->PrintInMemFormStats(true, true);
341     bundleUserService->PrintInMemFormStats(true, false);
342     EXPECT_NE(bundleUserService, nullptr);
343 }
344 
345 /*
346  * @tc.name: PackageUsageTest_QueryDeviceEventStats_001
347  * @tc.desc: QueryDeviceEventStats
348  * @tc.type: FUNC
349  * @tc.require: issuesI5SOZY
350  */
351 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryDeviceEventStats_001, Function | MediumTest | Level0)
352 {
353     int32_t userId = 100;
354     auto bundleActiveCore = bundleActiveCore_;
355     auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
356     int64_t timeStamp = 20000000000000;
357     bundleUserService->Init(timeStamp);
358 
359     int64_t beginTime = 0;
360     int64_t endTime = 0;
361     std::vector<BundleActiveEventStats> eventStats;
362     bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
363 
364     bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
365     bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
366 
367     beginTime = -1;
368     bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
369 
370     bundleUserService->currentStats_[0]->endTime_ = 1;
371     beginTime = 0;
372     bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
373     EXPECT_NE(bundleUserService, nullptr);
374 }
375 
376 /*
377  * @tc.name: PackageUsageTest_QueryNotificationEventStats_001
378  * @tc.desc: QueryNotificationEventStats
379  * @tc.type: FUNC
380  * @tc.require: issuesI5SOZY
381  */
382 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryNotificationEventStats_001, Function | MediumTest | Level0)
383 {
384     int32_t userId = 100;
385     auto bundleActiveCore = bundleActiveCore_;
386     auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
387     int64_t timeStamp = 20000000000000;
388     bundleUserService->Init(timeStamp);
389 
390     int64_t beginTime = 0;
391     int64_t endTime = 0;
392     std::vector<BundleActiveEventStats> eventStats;
393     bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
394 
395     bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
396     bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
397 
398     beginTime = -1;
399     bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
400 
401     bundleUserService->currentStats_[0]->endTime_ = 1;
402     beginTime = 0;
403     bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
404 
405     bundleUserService->currentStats_[0]->endTime_ = 1;
406     beginTime = 0;
407     endTime = 20000000000000;
408     bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
409     EXPECT_NE(bundleUserService, nullptr);
410 }
411 
412 /*
413  * @tc.name: PackageUsageTest_QueryBundleEvents_001
414  * @tc.desc: QueryBundleEvents
415  * @tc.type: FUNC
416  * @tc.require: issuesI5SOZY
417  */
418 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryBundleEvents_001, Function | MediumTest | Level0)
419 {
420     int32_t userId = 100;
421     auto bundleActiveCore = bundleActiveCore_;
422     auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
423     int64_t timeStamp = 20000000000000;
424     bundleUserService->Init(timeStamp);
425 
426     int64_t beginTime = 0;
427     int64_t endTime = 0;
428     std::vector<BundleActiveEvent> bundleActiveEvent;
429     std::string bundleName = "defaultBundleName";
430     bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
431 
432     bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
433     EXPECT_NE(
434         bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName), ERR_OK);
435 
436     beginTime = -1;
437     bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
438 
439     bundleUserService->currentStats_[0]->endTime_ = 1;
440     endTime = 20000000000000;
441     bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
442 
443     bundleUserService->currentStats_[0]->endTime_ = 1;
444     beginTime = 0;
445     endTime = 20000000000000;
446     bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
447     EXPECT_NE(bundleUserService, nullptr);
448 }
449 
450 /*
451  * @tc.name: PackageUsageTest_PrintInMemPackageStats_001
452  * @tc.desc: PrintInMemPackageStats
453  * @tc.type: FUNC
454  * @tc.require: issuesI5SOZY
455  */
456 HWTEST_F(PackageUsageTest, PackageUsageTest_PrintInMemPackageStats_001, Function | MediumTest | Level0)
457 {
458     int32_t userId = 100;
459     auto bundleActiveCore = bundleActiveCore_;
460     auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
461     int64_t timeStamp = 20000000000000;
462     bundleUserService->Init(timeStamp);
463 
464     bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
465     bundleUserService->currentStats_[0]->bundleStats_.emplace(
466         "defaultBundleStat", std::make_shared<BundleActivePackageStats>());
467     bundleUserService->PrintInMemPackageStats(0, true);
468     EXPECT_NE(bundleUserService, nullptr);
469 }
470 
471 /*
472  * @tc.name: PackageUsageTest_QueryBundleStatsInfos_001
473  * @tc.desc: QueryBundleStatsInfos
474  * @tc.type: FUNC
475  * @tc.require: issuesI5SOZY
476  */
477 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryBundleStatsInfos_001, Function | MediumTest | Level0)
478 {
479     int32_t userId = 100;
480     auto bundleActiveCore = bundleActiveCore_;
481     auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
482     int64_t timeStamp = 20000000000000;
483     bundleUserService->Init(timeStamp);
484 
485     int64_t beginTime = 0;
486     int64_t endTime = 0;
487     std::vector<BundleActivePackageStats> PackageStats;
488     std::string bundleName = "defaultBundleName";
489     int32_t intervalType = -1;
490     EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
491         PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
492 
493     intervalType = 5;
494     EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
495         PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
496 
497     intervalType = 0;
498     bundleUserService->currentStats_[0] = nullptr;
499     bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
500 
501     bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
502     beginTime = ONE_DAY_TIME + 1;
503     EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
504         PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
505 
506     beginTime = ONE_DAY_TIME;
507     EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
508         PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
509 
510     bundleUserService->currentStats_[0]->endTime_ = 1;
511     beginTime = 0;
512     bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
513     EXPECT_NE(bundleUserService, nullptr);
514 }
515 
516 /*
517  * @tc.name: PackageUsageTest_QueryBundleStatsInfos_002
518  * @tc.desc: QueryBundleStatsInfos
519  * @tc.type: FUNC
520  * @tc.require: issuesI5SOZY
521  */
522 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryBundleStatsInfos_002, Function | MediumTest | Level0)
523 {
524     int32_t userId = 100;
525     auto bundleActiveCore = bundleActiveCore_;
526     auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
527     int64_t timeStamp = 20000000000000;
528     bundleUserService->Init(timeStamp);
529     int64_t beginTime = 0;
530     int64_t endTime = 0;
531     std::vector<BundleActivePackageStats> PackageStats;
532     std::string bundleName = "defaultBundleName";
533     int32_t intervalType = 0;
534     bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
535     bundleUserService->currentStats_[0]->endTime_ = 1;
536     auto packageStatsObject = std::make_shared<BundleActivePackageStats>();
537     bundleUserService->currentStats_[0]->bundleStats_.emplace("defaultBundleStat", packageStatsObject);
538     bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
539 
540     packageStatsObject->totalInFrontTime_ = 1;
541     bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
542 
543     packageStatsObject->bundleName_ = "defaultBundleName";
544     bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
545 
546     packageStatsObject->lastTimeUsed_ = 1;
547     bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
548 
549     endTime = 1;
550     bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
551     packageStatsObject = nullptr;
552 
553     endTime = 0;
554     bundleName = "";
555     packageStatsObject = std::make_shared<BundleActivePackageStats>();
556     bundleUserService->currentStats_[0]->bundleStats_.emplace("defaultBundleStat", packageStatsObject);
557     bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
558 
559     packageStatsObject->totalInFrontTime_ = 1;
560     bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
561 
562     packageStatsObject->lastTimeUsed_ = 1;
563     bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
564 
565     endTime = 1;
566     bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
567     EXPECT_NE(bundleUserService, nullptr);
568 }
569 
570 /*
571  * @tc.name: PackageUsageTest_RestoreStats_001
572  * @tc.desc: RestoreStats
573  * @tc.type: FUNC
574  * @tc.require: issuesI5SOZY
575  */
576 HWTEST_F(PackageUsageTest, PackageUsageTest_RestoreStats_001, Function | MediumTest | Level0)
577 {
578     int32_t userId = 100;
579     auto bundleActiveCore = bundleActiveCore_;
580     auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
581     int64_t timeStamp = 20000000000000;
582     bundleUserService->Init(timeStamp);
583 
584     bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
585     auto packageStatsObject = std::make_shared<BundleActivePackageStats>();
586     bundleUserService->currentStats_[0]->bundleStats_.emplace(
587         "defaultBundleStat", packageStatsObject);
588     bundleUserService->moduleRecords_.emplace("defaultModule", std::make_shared<BundleActiveModuleRecord>());
589 
590     bool forced = false;
591     bundleUserService->statsChanged_ = false;
592     bundleUserService->RestoreStats(forced);
593 
594     forced = true;
595     bundleUserService->currentStats_[3] = nullptr;
596     bundleUserService->RestoreStats(forced);
597     EXPECT_NE(bundleUserService, nullptr);
598 }
599 
600 /*
601  * @tc.name: PackageUsageTest_LoadActiveStats_001
602  * @tc.desc: LoadActiveStats
603  * @tc.type: FUNC
604  * @tc.require: issuesI5SOZY
605  */
606 HWTEST_F(PackageUsageTest, PackageUsageTest_LoadActiveStats_001, Function | MediumTest | Level0)
607 {
608     int32_t userId = 100;
609     auto bundleActiveCore = bundleActiveCore_;
610     auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
611     int64_t timeStamp = 20000000000000;
612     bundleUserService->Init(timeStamp);
613 
614     bundleUserService->debugUserService_ = true;
615     bool forced = true;
616     bool timeChanged = true;
617     bundleUserService->LoadActiveStats(timeStamp, forced, timeChanged);
618 
619     forced = false;
620     bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
621     bundleUserService->currentStats_[3] = nullptr;
622     bundleUserService->LoadActiveStats(timeStamp, forced, timeChanged);
623 
624     EXPECT_NE(bundleUserService, nullptr);
625 }
626 
627 /*
628  * @tc.name: PackageUsageTest_IsBundleEvent_001
629  * @tc.desc: IsBundleEvent
630  * @tc.type: FUNC
631  * @tc.require: issuesI5SOZY
632  */
633 HWTEST_F(PackageUsageTest, PackageUsageTest_IsBundleEvent_001, Function | MediumTest | Level0)
634 {
635     auto bundleEvent = std::make_shared<BundleActiveEvent>();
636     EXPECT_EQ(bundleEvent->IsBundleEvent(BundleActiveEvent::END_OF_THE_DAY), true);
637     EXPECT_NE(bundleEvent->IsBundleEvent(BundleActiveEvent::SHUTDOWN), true);
638 }
639 
640 /*
641  * @tc.name: PackageUsageTest_combine_001
642  * @tc.desc: combine
643  * @tc.type: FUNC
644  * @tc.require: issuesI5SOZY
645  */
646 HWTEST_F(PackageUsageTest, PackageUsageTest_combine_001, Function | MediumTest | Level0)
647 {
648     auto combiner = std::make_shared<BundleActiveStatsCombiner<BundleActivePackageStats>>();
649     auto stats = std::make_shared<BundleActivePeriodStats>();
650     auto packageStat = std::make_shared<BundleActivePackageStats>();
651     stats->bundleStats_.emplace("normal", packageStat);
652     packageStat = nullptr;
653     stats->bundleStats_.emplace("default", packageStat);
654     int64_t beginTime = 0;
655     std::vector<BundleActivePackageStats> accumulatedResult;
656     combiner->combine(stats, accumulatedResult, beginTime);
657 
658     auto eventCombiner = std::make_shared<BundleActiveStatsCombiner<BundleActiveEvent>>();
659     std::vector<BundleActiveEvent> activeEventResult;
660     eventCombiner->combine(stats, activeEventResult, beginTime);
661     EXPECT_NE(combiner, nullptr);
662 }
663 
664 /*
665  * @tc.name: PackageUsageTest_ReportEvent_001
666  * @tc.desc: ReportEvent
667  * @tc.type: FUNC
668  * @tc.require: issuesI5SOZY
669  */
670 HWTEST_F(PackageUsageTest, PackageUsageTest_ReportEvent_001, Function | MediumTest | Level0)
671 {
672     int32_t userId = 100;
673     auto bundleActiveCore = bundleActiveCore_;
674     auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
675     int64_t timeStamp = 20000000000;
676     bundleUserService->Init(timeStamp);
677 
678     BundleActiveEvent event;
679     event.timeStamp_ = 20000000000000000;
680     bundleUserService->Init(timeStamp);
681     event.eventId_ = BundleActiveEvent::SYSTEM_INTERACTIVE;
682     bundleUserService->ReportEvent(event);
683 
684     event.eventId_ = BundleActiveEvent::FLUSH;
685     bundleUserService->ReportEvent(event);
686 
687     event.eventId_ = BundleActiveEvent::SCREEN_INTERACTIVE;
688     bundleUserService->ReportEvent(event);
689 
690     event.eventId_ = BundleActiveEvent::SCREEN_NON_INTERACTIVE;
691     bundleUserService->ReportEvent(event);
692 
693     event.eventId_ = BundleActiveEvent::KEYGUARD_SHOWN;
694     bundleUserService->ReportEvent(event);
695 
696     event.eventId_ = BundleActiveEvent::KEYGUARD_HIDDEN;
697     bundleUserService->ReportEvent(event);
698     EXPECT_NE(bundleUserService, nullptr);
699 }
700 
701 /*
702  * @tc.name: PackageUsageTest_RenewStatsInMemory_001
703  * @tc.desc: RenewStatsInMemory
704  * @tc.type: FUNC
705  * @tc.require: issuesI5SOZY
706  */
707 HWTEST_F(PackageUsageTest, PackageUsageTest_RenewStatsInMemory_001, Function | MediumTest | Level0)
708 {
709     int32_t userId = 100;
710     auto bundleActiveCore = bundleActiveCore_;
711     auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
712     int64_t timeStamp = 20000000000;
713     bundleUserService->Init(timeStamp);
714 
715     auto packageStat = std::make_shared<BundleActivePackageStats>();
716     packageStat->uid_ = 0;
717     packageStat->bundleName_ = "normal";
718     std::string bundleStatsKey = packageStat->bundleName_ + std::to_string(packageStat->uid_);
719     bundleUserService->currentStats_[0]->bundleStats_.emplace(bundleStatsKey, packageStat);
720 
721     packageStat->abilities_.emplace("normal", 123);
722     packageStat->longTimeTasks_.emplace("normal", 123);
723     bundleUserService->currentStats_[0]->bundleStats_.emplace(bundleStatsKey, packageStat);
724     bundleUserService->RenewStatsInMemory(timeStamp);
725     packageStat = nullptr;
726     bundleUserService->currentStats_[0]->bundleStats_.emplace("default", packageStat);
727     bundleUserService->RenewStatsInMemory(timeStamp);
728     EXPECT_NE(bundleUserService, nullptr);
729 }
730 
731 /*
732  * @tc.name: BundleActiveGroupController_001
733  * @tc.desc: DeleteMemoryUsageGroup
734  * @tc.type: FUNC
735  * @tc.require: IA4GZ0
736  */
737 HWTEST_F(PackageUsageTest, BundleActiveGroupController_001, Function | MediumTest | Level0)
738 {
739     auto groupController = std::make_shared<BundleActiveGroupController>(false);
740     auto userHistory = std::make_shared<std::map<std::string, std::shared_ptr<BundleActivePackageHistory>>>();
741     int32_t uid = 0;
742     int32_t appIndex = 1;
743     std::string bundleName = "test";
744     userHistory->emplace(bundleName + std::to_string(uid), std::make_shared<BundleActivePackageHistory>());
745     uid = 100;
746     userHistory->emplace(bundleName + std::to_string(uid), std::make_shared<BundleActivePackageHistory>());
747     uid = 200;
748     userHistory->emplace(bundleName + std::to_string(uid), std::make_shared<BundleActivePackageHistory>());
749     groupController->DeleteUsageGroupCache(userHistory, bundleName, uid, appIndex);
750     auto it = userHistory->find(bundleName + std::to_string(uid));
751     EXPECT_EQ(it, userHistory->end());
752     appIndex = 0;
753     groupController->DeleteUsageGroupCache(userHistory, bundleName, uid, appIndex);
754     uid = 0;
755     it = userHistory->find(bundleName + std::to_string(uid));
756     EXPECT_EQ(it, userHistory->end());
757 }
758 
759 /*
760  * @tc.name: BundleActiveGroupController_002
761  * @tc.desc: ReportEvent
762  * @tc.type: FUNC
763  * @tc.require: IA4GZ0
764  */
765 HWTEST_F(PackageUsageTest, BundleActiveGroupController_002, Function | MediumTest | Level0)
766 {
767     auto groupController = std::make_shared<BundleActiveGroupController>(false);
768     auto coreObject = bundleActiveCore_;
769     int userId = 100;
770     BundleActiveEvent event;
771     event.eventId_ = BundleActiveEvent::SYSTEM_INTERACTIVE;
772     int64_t timeStamp = 20000000000000;
773     coreObject->bundleGroupController_->ReportEvent(event, timeStamp, userId);
774     SUCCEED();
775 }
776 
777 /*
778  * @tc.name: BundleActiveReportHandlerTest_001
779  * @tc.desc: ProcessEvent
780  * @tc.type: FUNC
781  * @tc.require: issuesIAF8RF
782  */
783 HWTEST_F(PackageUsageTest, BundleActiveReportHandlerTest_001, Function | MediumTest | Level0)
784 {
785     BundleActiveReportHandlerObject tmpObject;
786     auto handlerObject = std::make_shared<BundleActiveReportHandlerObject>(tmpObject);
787     auto bundleActiveReportHandler = std::make_shared<BundleActiveReportHandler>();
788     bundleActiveReportHandler->Init(bundleActiveCore_);
789     bundleActiveReportHandler->ProcessEvent(0, handlerObject);
790     bundleActiveReportHandler->ProcessEvent(0, handlerObject);
791 }
792 
793 /*
794  * @tc.name: BundleActiveReportHandlerTest_002
795  * @tc.desc: SendEvent and removeEvent
796  * @tc.type: FUNC
797  * @tc.require: issuesIAF8RF
798  */
799 HWTEST_F(PackageUsageTest, BundleActiveReportHandlerTest_002, Function | MediumTest | Level0)
800 {
801     BundleActiveReportHandlerObject tmpObject;
802     auto handlerObject = std::make_shared<BundleActiveReportHandlerObject>(tmpObject);
803     auto bundleActiveReportHandler = std::make_shared<BundleActiveReportHandler>();
804     bundleActiveReportHandler->SendEvent(0, handlerObject);
805     bundleActiveReportHandler->RemoveEvent(0);
806     EXPECT_EQ(bundleActiveReportHandler->taskHandlerMap_.size(), 0);
807     bundleActiveReportHandler->Init(bundleActiveCore_);
808     bundleActiveReportHandler->SendEvent(0, handlerObject);
809     bundleActiveReportHandler->SendEvent(0, handlerObject, 10);
810     EXPECT_NE(bundleActiveReportHandler->taskHandlerMap_.size(), 0);
811     bundleActiveReportHandler->RemoveEvent(0);
812     bundleActiveReportHandler->RemoveEvent(0);
813     EXPECT_EQ(bundleActiveReportHandler->taskHandlerMap_.size(), 0);
814 }
815 
816 
817 /*
818  * @tc.name: BundleActiveReportHandlerTest_003
819  * @tc.desc: HasEvent
820  * @tc.type: FUNC
821  * @tc.require: issuesIAF8RF
822  */
823 HWTEST_F(PackageUsageTest, BundleActiveReportHandlerTest_003, Function | MediumTest | Level0)
824 {
825     BundleActiveReportHandlerObject tmpObject;
826     auto handlerObject = std::make_shared<BundleActiveReportHandlerObject>(tmpObject);
827     auto bundleActiveReportHandler = std::make_shared<BundleActiveReportHandler>();
828     bundleActiveReportHandler->HasEvent(0);
829     bundleActiveReportHandler->Init(bundleActiveCore_);
830     bundleActiveReportHandler->SendEvent(0, handlerObject, 10);
831     EXPECT_EQ(bundleActiveReportHandler->HasEvent(0), true);
832 }
833 
834 /*
835  * @tc.name: BundleActiveGroupHandler_001
836  * @tc.desc: SendEvent
837  * @tc.type: FUNC
838  * @tc.require: IA4GZ0
839  */
840 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_001, Function | MediumTest | Level0)
841 {
842     BundleActiveGroupHandlerObject tmpObject;
843     auto handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
844     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
845     bundleActiveGroupHandler->SendEvent(0, handlerObject);
846     EXPECT_EQ(bundleActiveGroupHandler->taskHandlerMap_.size(), 0);
847     bundleActiveGroupHandler->SendCheckBundleMsg(0, handlerObject);
848     EXPECT_EQ(bundleActiveGroupHandler->checkBundleTaskMap_.size(), 0);
849 }
850 
851 /*
852  * @tc.name: BundleActiveGroupHandler_002
853  * @tc.desc: SendEvent
854  * @tc.type: FUNC
855  * @tc.require: IA4GZ0
856  */
857 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_002, Function | MediumTest | Level0)
858 {
859     BundleActiveGroupHandlerObject tmpObject;
860     auto handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
861     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
862     bundleActiveGroupHandler->Init(bundleActiveCore_->bundleGroupController_);
863     bundleActiveGroupHandler->SendEvent(0, handlerObject);
864     bundleActiveGroupHandler->SendEvent(0, handlerObject, 10);
865     EXPECT_NE(bundleActiveGroupHandler->taskHandlerMap_.size(), 0);
866     bundleActiveGroupHandler->RemoveEvent(0);
867     bundleActiveGroupHandler->RemoveEvent(0);
868     EXPECT_EQ(bundleActiveGroupHandler->taskHandlerMap_.size(), 0);
869 }
870 
871 /*
872  * @tc.name: BundleActiveGroupHandler_003
873  * @tc.desc: SendCheckBundleMsg
874  * @tc.type: FUNC
875  * @tc.require: IA4GZ0
876  */
877 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_003, Function | MediumTest | Level0)
878 {
879     BundleActiveGroupHandlerObject tmpObject;
880     tmpObject.bundleName_ = "test";
881     tmpObject.uid_ = 10000;
882     tmpObject.userId_ = 100;
883     auto handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
884     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
885     bundleActiveGroupHandler->Init(bundleActiveCore_->bundleGroupController_);
886     bundleActiveGroupHandler->SendCheckBundleMsg(0, handlerObject);
887     bundleActiveGroupHandler->SendCheckBundleMsg(0, handlerObject, 10);
888     auto msgKey = bundleActiveGroupHandler->GetMsgKey(0, handlerObject, 10);
889     EXPECT_NE(bundleActiveGroupHandler->checkBundleTaskMap_.size(), 0);
890     bundleActiveGroupHandler->RemoveCheckBundleMsg(msgKey);
891     bundleActiveGroupHandler->RemoveCheckBundleMsg(msgKey);
892     msgKey = bundleActiveGroupHandler->GetMsgKey(0, handlerObject, 0);
893     bundleActiveGroupHandler->RemoveCheckBundleMsg(msgKey);
894     EXPECT_EQ(bundleActiveGroupHandler->checkBundleTaskMap_.size(), 0);
895 }
896 
897 /*
898  * @tc.name: BundleActiveGroupHandler_004
899  * @tc.desc: GetMsgKey
900  * @tc.type: FUNC
901  * @tc.require: IA4GZ0
902  */
903 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_004, Function | MediumTest | Level0)
904 {
905     BundleActiveGroupHandlerObject tmpObject;
906     tmpObject.bundleName_ = "test";
907     tmpObject.uid_ = 10000;
908     tmpObject.userId_ = 100;
909     auto handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
910     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
911     auto msgkey = bundleActiveGroupHandler->GetMsgKey(0, nullptr, 10);
912     EXPECT_EQ(msgkey, "");
913     msgkey = bundleActiveGroupHandler->GetMsgKey(0, handlerObject, 10);
914     EXPECT_NE(msgkey, "");
915 }
916 
917 /*
918  * @tc.name: BundleActiveGroupHandler_005
919  * @tc.desc: PostTask
920  * @tc.type: FUNC
921  * @tc.require: IA4GZ0
922  */
923 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_005, Function | MediumTest | Level0)
924 {
925     BundleActiveGroupHandlerObject tmpObject;
926     auto handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
927     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
__anonef9117560102() 928         bundleActiveGroupHandler->PostTask([]() {
929         SUCCEED();
930     });
__anonef9117560202() 931     bundleActiveGroupHandler->PostSyncTask([]() {
932         SUCCEED();
933     });
934     bundleActiveGroupHandler->Init(bundleActiveCore_->bundleGroupController_);
__anonef9117560302() 935     bundleActiveGroupHandler->PostTask([]() {
936         SUCCEED();
937     });
__anonef9117560402() 938     bundleActiveGroupHandler->PostSyncTask([]() {
939         SUCCEED();
940     });
941 }
942 
943 /*
944  * @tc.name: BundleActiveGroupHandler_006
945  * @tc.desc: PostTask
946  * @tc.type: FUNC
947  * @tc.require: IA4GZ0
948  */
949 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_006, Function | MediumTest | Level0)
950 {
951     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
952 
953     bundleActiveGroupHandler->Init(bundleActiveCore_->bundleGroupController_);
954     int32_t eventId = 0;
955     std::shared_ptr<BundleActiveGroupHandlerObject> tmpObject = nullptr;
956     bundleActiveGroupHandler->SendCheckBundleMsg(eventId, tmpObject, 0);
957     SUCCEED();
958 }
959 
960 /*
961  * @tc.name: BundleActiveGroupHandler_007
962  * @tc.desc: PostTask
963  * @tc.type: FUNC
964  * @tc.require: IA4GZ0
965  */
966 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_007, Function | MediumTest | Level0)
967 {
968     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
969     bundleActiveGroupHandler->Init(nullptr);
970     SUCCEED();
971 }
972 
973 /*
974  * @tc.name: BundleActiveGroupHandler_008
975  * @tc.desc: PostTask
976  * @tc.type: FUNC
977  * @tc.require: IA4GZ0
978  */
979 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_008, Function | MediumTest | Level0)
980 {
981     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
982     int32_t eventId = 0;
983     bundleActiveGroupHandler->RemoveEvent(eventId);
984     SUCCEED();
985 }
986 
987 /*
988  * @tc.name: BundleActiveGroupHandler_009
989  * @tc.desc: PostTask
990  * @tc.type: FUNC
991  * @tc.require: IA4GZ0
992  */
993 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_009, Function | MediumTest | Level0)
994 {
995     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
996     int32_t eventId = 0;
997     std::shared_ptr<BundleActiveGroupHandlerObject> tmpObject = nullptr;
998     bundleActiveGroupHandler->ProcessEvent(eventId, tmpObject);
999     SUCCEED();
1000 }
1001 
1002 /*
1003  * @tc.name: BundleActiveGroupHandler_010
1004  * @tc.desc: PostTask
1005  * @tc.type: FUNC
1006  * @tc.require: IA4GZ0
1007  */
1008 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_010, Function | MediumTest | Level0)
1009 {
1010     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
1011     bundleActiveGroupHandler->Init(bundleActiveCore_->bundleGroupController_);
1012     int32_t eventId = 2;
1013     std::shared_ptr<BundleActiveGroupHandlerObject> handlerObject = nullptr;
1014     bundleActiveGroupHandler->ProcessEvent(eventId, handlerObject);
1015     BundleActiveGroupHandlerObject tmpObject;
1016     handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
1017     bundleActiveGroupHandler->ProcessEvent(eventId, handlerObject);
1018     eventId = 100;
1019     bundleActiveGroupHandler->ProcessEvent(eventId, handlerObject);
1020     SUCCEED();
1021 }
1022 
1023 /*
1024  * @tc.name: BundleActivePackageStats_001
1025  * @tc.desc: END_OF_THE_DAY
1026  * @tc.type: FUNC
1027  * @tc.require: IA4GZ0
1028  */
1029 HWTEST_F(PackageUsageTest, BundleActivePackageStats_001, Function | MediumTest | Level0)
1030 {
1031     auto packageStats = std::make_shared<BundleActivePackageStats>();
1032     std::string taskName = "test";
1033     int64_t timeStamp = 0;
1034     int32_t eventId = BundleActiveEvent::END_OF_THE_DAY;
1035     std::string abilityId = "1";
1036     int32_t uid = 0;
1037     packageStats->Update("test", timeStamp, eventId, abilityId, uid);
1038     packageStats->lastTimeUsed_ = 0;
1039     packageStats->totalInFrontTime_ = 0;
1040     timeStamp = 1000;
1041     packageStats->abilities_["test"] = BundleActiveEvent::ABILITY_FOREGROUND;
1042     packageStats->longTimeTasks_["test"] = BundleActiveEvent::ABILITY_FOREGROUND;
1043     packageStats->Update("test", timeStamp, eventId, abilityId, uid);
1044     EXPECT_EQ(packageStats->totalInFrontTime_, timeStamp);
1045 }
1046 
1047 /*
1048  * @tc.name: BundleActivePackageStats_002
1049  * @tc.desc: FLUSH
1050  * @tc.type: FUNC
1051  * @tc.require: IA4GZ0
1052  */
1053 HWTEST_F(PackageUsageTest, BundleActivePackageStats_002, Function | MediumTest | Level0)
1054 {
1055     auto packageStats = std::make_shared<BundleActivePackageStats>();
1056     std::string taskName = "test";
1057     int64_t timeStamp = 0;
1058     int32_t eventId = BundleActiveEvent::FLUSH;
1059     std::string abilityId = "1";
1060     int32_t uid = 0;
1061     packageStats->Update("test", timeStamp, eventId, abilityId, uid);
1062     packageStats->lastTimeUsed_ = 0;
1063     packageStats->totalInFrontTime_ = 0;
1064     timeStamp = 1000;
1065     packageStats->abilities_["test"] = BundleActiveEvent::ABILITY_FOREGROUND;
1066     packageStats->longTimeTasks_["test"] = BundleActiveEvent::ABILITY_FOREGROUND;
1067     packageStats->Update("test", timeStamp, eventId, abilityId, uid);
1068     EXPECT_EQ(packageStats->totalInFrontTime_, timeStamp);
1069 }
1070 
1071 /*
1072  * @tc.name: BundleActivePackageStats_003
1073  * @tc.desc: Marshalling
1074  * @tc.type: FUNC
1075  * @tc.require: IA4GZ0
1076  */
1077 HWTEST_F(PackageUsageTest, BundleActivePackageStats_003, Function | MediumTest | Level0)
1078 {
1079     MessageParcel reply;
1080     auto packageStats = std::make_shared<BundleActivePackageStats>();
1081     bool result = packageStats->Marshalling(reply);
1082     EXPECT_TRUE(result);
1083 }
1084 
1085 /*
1086  * @tc.name: BundleActivePackageStats_004
1087  * @tc.desc: UpdateAbility
1088  * @tc.type: FUNC
1089  * @tc.require: IA4GZ0
1090  */
1091 HWTEST_F(PackageUsageTest, BundleActivePackageStats_004, Function | MediumTest | Level0)
1092 {
1093     MessageParcel reply;
1094     auto packageStats = std::make_shared<BundleActivePackageStats>();
1095     int64_t timeStamp = 0;
1096     int32_t eventId = BundleActiveEvent::ABILITY_FOREGROUND;
1097     std::string abilityId = "1";
1098     packageStats->abilities_[abilityId] = BundleActiveEvent::ABILITY_STOP;
1099     packageStats->UpdateAbility(timeStamp, eventId, abilityId);
1100     packageStats->abilities_[abilityId] = BundleActiveEvent::ABILITY_BACKGROUND;
1101     packageStats->UpdateAbility(timeStamp, eventId, abilityId);
1102     int32_t startCount = packageStats->startCount_;
1103     EXPECT_TRUE(startCount > 0);
1104 }
1105 
1106 /*
1107  * @tc.name: BundleActivePackageStats_005
1108  * @tc.desc: UpdateLongTimeTask
1109  * @tc.type: FUNC
1110  * @tc.require: IA4GZ0
1111  */
1112 HWTEST_F(PackageUsageTest, BundleActivePackageStats_005, Function | MediumTest | Level0)
1113 {
1114     auto packageStats = std::make_shared<BundleActivePackageStats>();
1115     std::string taskName = "test";
1116     int64_t timeStamp = 0;
1117     std::string abilityId = "1";
1118     int32_t eventId = BundleActiveEvent::LONG_TIME_TASK_ENDED;
1119     packageStats->totalContiniousTaskUsedTime_ = 0;
1120     packageStats->longTimeTasks_[taskName] = BundleActiveEvent::LONG_TIME_TASK_ENDED;
1121     packageStats->UpdateAbility(timeStamp, eventId, abilityId);
1122     EXPECT_EQ(packageStats->totalContiniousTaskUsedTime_, 0);
1123 }
1124 
1125 /*
1126  * @tc.name: BundleActiveCalendar_001
1127  * @tc.desc: BundleActiveCalendar
1128  * @tc.type: FUNC
1129  * @tc.require: IAHDJW
1130  */
1131 HWTEST_F(PackageUsageTest, BundleActiveCalendar_001, Function | MediumTest | Level0)
1132 {
1133     int64_t nowTime = bundleActiveCore_->GetSystemTimeMs();
1134     BundleActiveCalendar testCalendar(nowTime);
1135     testCalendar.TruncateToDay();
1136     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1137     BundleActiveCalendar testCalendar2(nowTime);
1138     testCalendar.TruncateToWeek();
1139     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1140     BundleActiveCalendar testCalendar3(nowTime);
1141     testCalendar.TruncateToMonth();
1142     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1143     BundleActiveCalendar testCalendar4(nowTime);
1144     testCalendar.TruncateToYear();
1145     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1146 }
1147 
1148 /*
1149  * @tc.name: BundleActiveCalendar_002
1150  * @tc.desc: BundleActiveCalendar debug
1151  * @tc.type: FUNC
1152  * @tc.require: IAHDJW
1153  */
1154 HWTEST_F(PackageUsageTest, BundleActiveCalendar_002, Function | MediumTest | Level0)
1155 {
1156     int64_t nowTime = bundleActiveCore_->GetSystemTimeMs();
1157     BundleActiveCalendar testCalendar(nowTime);
1158     testCalendar.ChangeToDebug();
1159     testCalendar.TruncateToDay();
1160     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1161     BundleActiveCalendar testCalendar2(nowTime);
1162     testCalendar.ChangeToDebug();
1163     testCalendar.TruncateToWeek();
1164     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1165     BundleActiveCalendar testCalendar3(nowTime);
1166     testCalendar.ChangeToDebug();
1167     testCalendar.TruncateToMonth();
1168     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1169     BundleActiveCalendar testCalendar4(nowTime);
1170     testCalendar.ChangeToDebug();
1171     testCalendar.TruncateToYear();
1172     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1173 }
1174 
1175 }  // namespace DeviceUsageStats
1176 }  // namespace OHOS