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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_Update_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_UpdateLongTimeTask_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_UpdateAbility_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_Increment_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveModuleRecord_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveEventTracker_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveFormRecord_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveEventStats_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_ReportForShutdown_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_ReportFormEvent_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_PrintInMemFormStats_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_QueryDeviceEventStats_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_QueryNotificationEventStats_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_QueryBundleEvents_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_PrintInMemPackageStats_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_QueryBundleStatsInfos_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_QueryBundleStatsInfos_002, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_RestoreStats_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_LoadActiveStats_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_IsBundleEvent_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_combine_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_ReportEvent_001, Function | MediumTest | Level0)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  */
HWTEST_F(PackageUsageTest, PackageUsageTest_RenewStatsInMemory_001, Function | MediumTest | Level0)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     bundleUserService->currentStats_[0]->packageContainUid_[packageStat->bundleName_].insert(packageStat->uid_);
726     packageStat = nullptr;
727     bundleUserService->currentStats_[0]->bundleStats_.emplace("default", packageStat);
728     bundleUserService->RenewStatsInMemory(timeStamp);
729     EXPECT_NE(bundleUserService, nullptr);
730 }
731 
732 /*
733  * @tc.name: BundleActiveGroupController_001
734  * @tc.desc: DeleteMemoryUsageGroup
735  * @tc.type: FUNC
736  * @tc.require: IA4GZ0
737  */
HWTEST_F(PackageUsageTest, BundleActiveGroupController_001, Function | MediumTest | Level0)738 HWTEST_F(PackageUsageTest, BundleActiveGroupController_001, Function | MediumTest | Level0)
739 {
740     auto groupController = std::make_shared<BundleActiveGroupController>(false);
741     auto userHistory = std::make_shared<std::map<std::string, std::shared_ptr<BundleActivePackageHistory>>>();
742     int32_t uid = 0;
743     int32_t appIndex = 1;
744     std::string bundleName = "test";
745     userHistory->emplace(bundleName + std::to_string(uid), std::make_shared<BundleActivePackageHistory>());
746     uid = 100;
747     userHistory->emplace(bundleName + std::to_string(uid), std::make_shared<BundleActivePackageHistory>());
748     uid = 200;
749     userHistory->emplace(bundleName + std::to_string(uid), std::make_shared<BundleActivePackageHistory>());
750     groupController->DeleteUsageGroupCache(userHistory, bundleName, uid, appIndex);
751     auto it = userHistory->find(bundleName + std::to_string(uid));
752     EXPECT_EQ(it, userHistory->end());
753     appIndex = 0;
754     groupController->DeleteUsageGroupCache(userHistory, bundleName, uid, appIndex);
755     uid = 0;
756     it = userHistory->find(bundleName + std::to_string(uid));
757     EXPECT_EQ(it, userHistory->end());
758 }
759 
760 /*
761  * @tc.name: BundleActiveGroupController_002
762  * @tc.desc: ReportEvent
763  * @tc.type: FUNC
764  * @tc.require: IA4GZ0
765  */
HWTEST_F(PackageUsageTest, BundleActiveGroupController_002, Function | MediumTest | Level0)766 HWTEST_F(PackageUsageTest, BundleActiveGroupController_002, Function | MediumTest | Level0)
767 {
768     auto groupController = std::make_shared<BundleActiveGroupController>(false);
769     auto coreObject = bundleActiveCore_;
770     int userId = 100;
771     BundleActiveEvent event;
772     event.eventId_ = BundleActiveEvent::SYSTEM_INTERACTIVE;
773     int64_t timeStamp = 20000000000000;
774     coreObject->bundleGroupController_->ReportEvent(event, timeStamp, userId);
775     SUCCEED();
776 }
777 
778 /*
779  * @tc.name: BundleActiveReportHandlerTest_001
780  * @tc.desc: ProcessEvent
781  * @tc.type: FUNC
782  * @tc.require: issuesIAF8RF
783  */
HWTEST_F(PackageUsageTest, BundleActiveReportHandlerTest_001, Function | MediumTest | Level0)784 HWTEST_F(PackageUsageTest, BundleActiveReportHandlerTest_001, Function | MediumTest | Level0)
785 {
786     BundleActiveReportHandlerObject tmpObject;
787     auto handlerObject = std::make_shared<BundleActiveReportHandlerObject>(tmpObject);
788     auto bundleActiveReportHandler = std::make_shared<BundleActiveReportHandler>();
789     bundleActiveReportHandler->Init(bundleActiveCore_);
790     bundleActiveReportHandler->ProcessEvent(0, handlerObject);
791     bundleActiveReportHandler->ProcessEvent(0, handlerObject);
792 }
793 
794 /*
795  * @tc.name: BundleActiveReportHandlerTest_002
796  * @tc.desc: SendEvent and removeEvent
797  * @tc.type: FUNC
798  * @tc.require: issuesIAF8RF
799  */
HWTEST_F(PackageUsageTest, BundleActiveReportHandlerTest_002, Function | MediumTest | Level0)800 HWTEST_F(PackageUsageTest, BundleActiveReportHandlerTest_002, Function | MediumTest | Level0)
801 {
802     BundleActiveReportHandlerObject tmpObject;
803     auto handlerObject = std::make_shared<BundleActiveReportHandlerObject>(tmpObject);
804     auto bundleActiveReportHandler = std::make_shared<BundleActiveReportHandler>();
805     bundleActiveReportHandler->SendEvent(0, handlerObject);
806     bundleActiveReportHandler->RemoveEvent(0);
807     EXPECT_EQ(bundleActiveReportHandler->taskHandlerMap_.size(), 0);
808     bundleActiveReportHandler->Init(bundleActiveCore_);
809     bundleActiveReportHandler->SendEvent(0, handlerObject);
810     bundleActiveReportHandler->SendEvent(0, handlerObject, 10);
811     EXPECT_NE(bundleActiveReportHandler->taskHandlerMap_.size(), 0);
812     bundleActiveReportHandler->RemoveEvent(0);
813     bundleActiveReportHandler->RemoveEvent(0);
814     EXPECT_EQ(bundleActiveReportHandler->taskHandlerMap_.size(), 0);
815 }
816 
817 
818 /*
819  * @tc.name: BundleActiveReportHandlerTest_003
820  * @tc.desc: HasEvent
821  * @tc.type: FUNC
822  * @tc.require: issuesIAF8RF
823  */
HWTEST_F(PackageUsageTest, BundleActiveReportHandlerTest_003, Function | MediumTest | Level0)824 HWTEST_F(PackageUsageTest, BundleActiveReportHandlerTest_003, Function | MediumTest | Level0)
825 {
826     BundleActiveReportHandlerObject tmpObject;
827     auto handlerObject = std::make_shared<BundleActiveReportHandlerObject>(tmpObject);
828     auto bundleActiveReportHandler = std::make_shared<BundleActiveReportHandler>();
829     bundleActiveReportHandler->HasEvent(0);
830     bundleActiveReportHandler->Init(bundleActiveCore_);
831     bundleActiveReportHandler->SendEvent(0, handlerObject, 10);
832     EXPECT_EQ(bundleActiveReportHandler->HasEvent(0), true);
833 }
834 
835 /*
836  * @tc.name: BundleActiveReportHandlerTest_004
837  * @tc.desc: Send Uninstalled APP Event
838  * @tc.type: FUNC
839  * @tc.require: IAHDJW
840  */
HWTEST_F(PackageUsageTest, BundleActiveReportHandlerTest_004, Function | MediumTest | Level0)841 HWTEST_F(PackageUsageTest, BundleActiveReportHandlerTest_004, Function | MediumTest | Level0)
842 {
843     auto bundleActiveReportHandler = std::make_shared<BundleActiveReportHandler>();
844     bundleActiveReportHandler->Init(bundleActiveCore_);
845     int32_t userId = 100;
846     std::string bundleName = "test";
847     int32_t uid = 100010;
848     int32_t appIndex = 1;
849     int64_t timeNow = bundleActiveCore_->CheckTimeChangeAndGetWallTime(userId);
850     BundleActiveReportHandlerObject tmpObject;
851     tmpObject.event_.eventId_ = tmpObject.event_.ABILITY_STOP;
852     tmpObject.event_.uid_ = uid;
853     tmpObject.event_.timeStamp_ = timeNow;
854     auto handlerObject = std::make_shared<BundleActiveReportHandlerObject>(tmpObject);
855     bundleActiveReportHandler->SendEvent(0, handlerObject);
856     auto service = bundleActiveCore_->GetUserDataAndInitializeIfNeeded(userId, timeNow, false);
857     EXPECT_EQ(service->currentStats_[0]->endTime_, timeNow);
858     bundleActiveCore_->OnBundleUninstalled(userId, bundleName, uid, appIndex);
859     EXPECT_TRUE(bundleActiveCore_->isUninstalledApp(uid));
860     timeNow = timeNow + 100;
861     tmpObject.event_.timeStamp_ = timeNow;
862     bundleActiveReportHandler->SendEvent(0, handlerObject);
863     EXPECT_NE(service->currentStats_[0]->endTime_, timeNow);
864     bundleActiveCore_->OnBundleInstalled(userId, bundleName, uid, appIndex);
865     EXPECT_FALSE(bundleActiveCore_->isUninstalledApp(uid));
866     SUCCEED();
867 }
868 
869 /*
870  * @tc.name: BundleActiveGroupHandler_001
871  * @tc.desc: SendEvent
872  * @tc.type: FUNC
873  * @tc.require: IA4GZ0
874  */
HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_001, Function | MediumTest | Level0)875 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_001, Function | MediumTest | Level0)
876 {
877     BundleActiveGroupHandlerObject tmpObject;
878     auto handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
879     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
880     bundleActiveGroupHandler->SendEvent(0, handlerObject);
881     EXPECT_EQ(bundleActiveGroupHandler->taskHandlerMap_.size(), 0);
882     bundleActiveGroupHandler->SendCheckBundleMsg(0, handlerObject);
883     EXPECT_EQ(bundleActiveGroupHandler->checkBundleTaskMap_.size(), 0);
884 }
885 
886 /*
887  * @tc.name: BundleActiveGroupHandler_002
888  * @tc.desc: SendEvent
889  * @tc.type: FUNC
890  * @tc.require: IA4GZ0
891  */
HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_002, Function | MediumTest | Level0)892 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_002, Function | MediumTest | Level0)
893 {
894     BundleActiveGroupHandlerObject tmpObject;
895     auto handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
896     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
897     bundleActiveGroupHandler->Init(bundleActiveCore_->bundleGroupController_);
898     bundleActiveGroupHandler->SendEvent(0, handlerObject);
899     bundleActiveGroupHandler->SendEvent(0, handlerObject, 10);
900     EXPECT_NE(bundleActiveGroupHandler->taskHandlerMap_.size(), 0);
901     bundleActiveGroupHandler->RemoveEvent(0);
902     bundleActiveGroupHandler->RemoveEvent(0);
903     EXPECT_EQ(bundleActiveGroupHandler->taskHandlerMap_.size(), 0);
904 }
905 
906 /*
907  * @tc.name: BundleActiveGroupHandler_003
908  * @tc.desc: SendCheckBundleMsg
909  * @tc.type: FUNC
910  * @tc.require: IA4GZ0
911  */
HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_003, Function | MediumTest | Level0)912 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_003, Function | MediumTest | Level0)
913 {
914     BundleActiveGroupHandlerObject tmpObject;
915     tmpObject.bundleName_ = "test";
916     tmpObject.uid_ = 10000;
917     tmpObject.userId_ = 100;
918     auto handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
919     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
920     bundleActiveGroupHandler->Init(bundleActiveCore_->bundleGroupController_);
921     bundleActiveGroupHandler->SendCheckBundleMsg(0, handlerObject);
922     bundleActiveGroupHandler->SendCheckBundleMsg(0, handlerObject, 10);
923     auto msgKey = bundleActiveGroupHandler->GetMsgKey(0, handlerObject, 10);
924     EXPECT_NE(bundleActiveGroupHandler->checkBundleTaskMap_.size(), 0);
925     bundleActiveGroupHandler->RemoveCheckBundleMsg(msgKey);
926     bundleActiveGroupHandler->RemoveCheckBundleMsg(msgKey);
927     msgKey = bundleActiveGroupHandler->GetMsgKey(0, handlerObject, 0);
928     bundleActiveGroupHandler->RemoveCheckBundleMsg(msgKey);
929     EXPECT_EQ(bundleActiveGroupHandler->checkBundleTaskMap_.size(), 0);
930 }
931 
932 /*
933  * @tc.name: BundleActiveGroupHandler_004
934  * @tc.desc: GetMsgKey
935  * @tc.type: FUNC
936  * @tc.require: IA4GZ0
937  */
HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_004, Function | MediumTest | Level0)938 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_004, Function | MediumTest | Level0)
939 {
940     BundleActiveGroupHandlerObject tmpObject;
941     tmpObject.bundleName_ = "test";
942     tmpObject.uid_ = 10000;
943     tmpObject.userId_ = 100;
944     auto handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
945     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
946     auto msgkey = bundleActiveGroupHandler->GetMsgKey(0, nullptr, 10);
947     EXPECT_EQ(msgkey, "");
948     msgkey = bundleActiveGroupHandler->GetMsgKey(0, handlerObject, 10);
949     EXPECT_NE(msgkey, "");
950 }
951 
952 /*
953  * @tc.name: BundleActiveGroupHandler_005
954  * @tc.desc: PostTask
955  * @tc.type: FUNC
956  * @tc.require: IA4GZ0
957  */
HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_005, Function | MediumTest | Level0)958 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_005, Function | MediumTest | Level0)
959 {
960     BundleActiveGroupHandlerObject tmpObject;
961     auto handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
962     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
963         bundleActiveGroupHandler->PostTask([]() {
964         SUCCEED();
965     });
966     bundleActiveGroupHandler->PostSyncTask([]() {
967         SUCCEED();
968     });
969     bundleActiveGroupHandler->Init(bundleActiveCore_->bundleGroupController_);
970     bundleActiveGroupHandler->PostTask([]() {
971         SUCCEED();
972     });
973     bundleActiveGroupHandler->PostSyncTask([]() {
974         SUCCEED();
975     });
976 }
977 
978 /*
979  * @tc.name: BundleActiveGroupHandler_006
980  * @tc.desc: PostTask
981  * @tc.type: FUNC
982  * @tc.require: IA4GZ0
983  */
HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_006, Function | MediumTest | Level0)984 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_006, Function | MediumTest | Level0)
985 {
986     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
987 
988     bundleActiveGroupHandler->Init(bundleActiveCore_->bundleGroupController_);
989     int32_t eventId = 0;
990     std::shared_ptr<BundleActiveGroupHandlerObject> tmpObject = nullptr;
991     bundleActiveGroupHandler->SendCheckBundleMsg(eventId, tmpObject, 0);
992     SUCCEED();
993 }
994 
995 /*
996  * @tc.name: BundleActiveGroupHandler_007
997  * @tc.desc: PostTask
998  * @tc.type: FUNC
999  * @tc.require: IA4GZ0
1000  */
HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_007, Function | MediumTest | Level0)1001 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_007, Function | MediumTest | Level0)
1002 {
1003     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
1004     bundleActiveGroupHandler->Init(nullptr);
1005     SUCCEED();
1006 }
1007 
1008 /*
1009  * @tc.name: BundleActiveGroupHandler_008
1010  * @tc.desc: PostTask
1011  * @tc.type: FUNC
1012  * @tc.require: IA4GZ0
1013  */
HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_008, Function | MediumTest | Level0)1014 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_008, Function | MediumTest | Level0)
1015 {
1016     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
1017     int32_t eventId = 0;
1018     bundleActiveGroupHandler->RemoveEvent(eventId);
1019     SUCCEED();
1020 }
1021 
1022 /*
1023  * @tc.name: BundleActiveGroupHandler_009
1024  * @tc.desc: PostTask
1025  * @tc.type: FUNC
1026  * @tc.require: IA4GZ0
1027  */
HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_009, Function | MediumTest | Level0)1028 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_009, Function | MediumTest | Level0)
1029 {
1030     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
1031     int32_t eventId = 0;
1032     std::shared_ptr<BundleActiveGroupHandlerObject> tmpObject = nullptr;
1033     bundleActiveGroupHandler->ProcessEvent(eventId, tmpObject);
1034     SUCCEED();
1035 }
1036 
1037 /*
1038  * @tc.name: BundleActiveGroupHandler_010
1039  * @tc.desc: PostTask
1040  * @tc.type: FUNC
1041  * @tc.require: IA4GZ0
1042  */
HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_010, Function | MediumTest | Level0)1043 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_010, Function | MediumTest | Level0)
1044 {
1045     auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
1046     bundleActiveGroupHandler->Init(bundleActiveCore_->bundleGroupController_);
1047     int32_t eventId = 2;
1048     std::shared_ptr<BundleActiveGroupHandlerObject> handlerObject = nullptr;
1049     bundleActiveGroupHandler->ProcessEvent(eventId, handlerObject);
1050     BundleActiveGroupHandlerObject tmpObject;
1051     handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
1052     bundleActiveGroupHandler->ProcessEvent(eventId, handlerObject);
1053     eventId = 100;
1054     bundleActiveGroupHandler->ProcessEvent(eventId, handlerObject);
1055     SUCCEED();
1056 }
1057 
1058 /*
1059  * @tc.name: BundleActivePackageStats_001
1060  * @tc.desc: END_OF_THE_DAY
1061  * @tc.type: FUNC
1062  * @tc.require: IA4GZ0
1063  */
HWTEST_F(PackageUsageTest, BundleActivePackageStats_001, Function | MediumTest | Level0)1064 HWTEST_F(PackageUsageTest, BundleActivePackageStats_001, Function | MediumTest | Level0)
1065 {
1066     auto packageStats = std::make_shared<BundleActivePackageStats>();
1067     std::string taskName = "test";
1068     int64_t timeStamp = 0;
1069     int32_t eventId = BundleActiveEvent::END_OF_THE_DAY;
1070     std::string abilityId = "1";
1071     int32_t uid = 0;
1072     packageStats->Update("test", timeStamp, eventId, abilityId, uid);
1073     packageStats->lastTimeUsed_ = 0;
1074     packageStats->totalInFrontTime_ = 0;
1075     timeStamp = 1000;
1076     packageStats->abilities_["test"] = BundleActiveEvent::ABILITY_FOREGROUND;
1077     packageStats->longTimeTasks_["test"] = BundleActiveEvent::ABILITY_FOREGROUND;
1078     packageStats->Update("test", timeStamp, eventId, abilityId, uid);
1079     EXPECT_EQ(packageStats->totalInFrontTime_, timeStamp);
1080 }
1081 
1082 /*
1083  * @tc.name: BundleActivePackageStats_002
1084  * @tc.desc: FLUSH
1085  * @tc.type: FUNC
1086  * @tc.require: IA4GZ0
1087  */
HWTEST_F(PackageUsageTest, BundleActivePackageStats_002, Function | MediumTest | Level0)1088 HWTEST_F(PackageUsageTest, BundleActivePackageStats_002, Function | MediumTest | Level0)
1089 {
1090     auto packageStats = std::make_shared<BundleActivePackageStats>();
1091     std::string taskName = "test";
1092     int64_t timeStamp = 0;
1093     int32_t eventId = BundleActiveEvent::FLUSH;
1094     std::string abilityId = "1";
1095     int32_t uid = 0;
1096     packageStats->Update("test", timeStamp, eventId, abilityId, uid);
1097     packageStats->lastTimeUsed_ = 0;
1098     packageStats->totalInFrontTime_ = 0;
1099     timeStamp = 1000;
1100     packageStats->abilities_["test"] = BundleActiveEvent::ABILITY_FOREGROUND;
1101     packageStats->longTimeTasks_["test"] = BundleActiveEvent::ABILITY_FOREGROUND;
1102     packageStats->Update("test", timeStamp, eventId, abilityId, uid);
1103     EXPECT_EQ(packageStats->totalInFrontTime_, timeStamp);
1104 }
1105 
1106 /*
1107  * @tc.name: BundleActivePackageStats_003
1108  * @tc.desc: Marshalling
1109  * @tc.type: FUNC
1110  * @tc.require: IA4GZ0
1111  */
HWTEST_F(PackageUsageTest, BundleActivePackageStats_003, Function | MediumTest | Level0)1112 HWTEST_F(PackageUsageTest, BundleActivePackageStats_003, Function | MediumTest | Level0)
1113 {
1114     MessageParcel reply;
1115     auto packageStats = std::make_shared<BundleActivePackageStats>();
1116     bool result = packageStats->Marshalling(reply);
1117     EXPECT_TRUE(result);
1118 }
1119 
1120 /*
1121  * @tc.name: BundleActivePackageStats_004
1122  * @tc.desc: UpdateAbility
1123  * @tc.type: FUNC
1124  * @tc.require: IA4GZ0
1125  */
HWTEST_F(PackageUsageTest, BundleActivePackageStats_004, Function | MediumTest | Level0)1126 HWTEST_F(PackageUsageTest, BundleActivePackageStats_004, Function | MediumTest | Level0)
1127 {
1128     MessageParcel reply;
1129     auto packageStats = std::make_shared<BundleActivePackageStats>();
1130     int64_t timeStamp = 0;
1131     int32_t eventId = BundleActiveEvent::ABILITY_FOREGROUND;
1132     std::string abilityId = "1";
1133     packageStats->abilities_[abilityId] = BundleActiveEvent::ABILITY_STOP;
1134     packageStats->UpdateAbility(timeStamp, eventId, abilityId);
1135     packageStats->abilities_[abilityId] = BundleActiveEvent::ABILITY_BACKGROUND;
1136     packageStats->UpdateAbility(timeStamp, eventId, abilityId);
1137     int32_t startCount = packageStats->startCount_;
1138     EXPECT_TRUE(startCount > 0);
1139 }
1140 
1141 /*
1142  * @tc.name: BundleActivePackageStats_005
1143  * @tc.desc: UpdateLongTimeTask
1144  * @tc.type: FUNC
1145  * @tc.require: IA4GZ0
1146  */
HWTEST_F(PackageUsageTest, BundleActivePackageStats_005, Function | MediumTest | Level0)1147 HWTEST_F(PackageUsageTest, BundleActivePackageStats_005, Function | MediumTest | Level0)
1148 {
1149     auto packageStats = std::make_shared<BundleActivePackageStats>();
1150     std::string taskName = "test";
1151     int64_t timeStamp = 0;
1152     std::string abilityId = "1";
1153     int32_t eventId = BundleActiveEvent::LONG_TIME_TASK_ENDED;
1154     packageStats->totalContiniousTaskUsedTime_ = 0;
1155     packageStats->longTimeTasks_[taskName] = BundleActiveEvent::LONG_TIME_TASK_ENDED;
1156     packageStats->UpdateAbility(timeStamp, eventId, abilityId);
1157     EXPECT_EQ(packageStats->totalContiniousTaskUsedTime_, 0);
1158 }
1159 
1160 /*
1161  * @tc.name: BundleActiveCalendar_001
1162  * @tc.desc: BundleActiveCalendar
1163  * @tc.type: FUNC
1164  * @tc.require: IAHDJW
1165  */
HWTEST_F(PackageUsageTest, BundleActiveCalendar_001, Function | MediumTest | Level0)1166 HWTEST_F(PackageUsageTest, BundleActiveCalendar_001, Function | MediumTest | Level0)
1167 {
1168     int64_t nowTime = bundleActiveCore_->GetSystemTimeMs();
1169     BundleActiveCalendar testCalendar(nowTime);
1170     testCalendar.TruncateToDay();
1171     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1172     BundleActiveCalendar testCalendar2(nowTime);
1173     testCalendar.TruncateToWeek();
1174     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1175     BundleActiveCalendar testCalendar3(nowTime);
1176     testCalendar.TruncateToMonth();
1177     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1178     BundleActiveCalendar testCalendar4(nowTime);
1179     testCalendar.TruncateToYear();
1180     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1181 }
1182 
1183 /*
1184  * @tc.name: BundleActiveCalendar_002
1185  * @tc.desc: BundleActiveCalendar debug
1186  * @tc.type: FUNC
1187  * @tc.require: IAHDJW
1188  */
HWTEST_F(PackageUsageTest, BundleActiveCalendar_002, Function | MediumTest | Level0)1189 HWTEST_F(PackageUsageTest, BundleActiveCalendar_002, Function | MediumTest | Level0)
1190 {
1191     int64_t nowTime = bundleActiveCore_->GetSystemTimeMs();
1192     BundleActiveCalendar testCalendar(nowTime);
1193     testCalendar.ChangeToDebug();
1194     testCalendar.TruncateToDay();
1195     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1196     BundleActiveCalendar testCalendar2(nowTime);
1197     testCalendar.ChangeToDebug();
1198     testCalendar.TruncateToWeek();
1199     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1200     BundleActiveCalendar testCalendar3(nowTime);
1201     testCalendar.ChangeToDebug();
1202     testCalendar.TruncateToMonth();
1203     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1204     BundleActiveCalendar testCalendar4(nowTime);
1205     testCalendar.ChangeToDebug();
1206     testCalendar.TruncateToYear();
1207     EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1208 }
1209 
1210 }  // namespace DeviceUsageStats
1211 }  // namespace OHOS