1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #define private public
17 #define protected public
18
19 #include <string>
20
21 #include <gtest/gtest.h>
22 #include "system_ability_definition.h"
23
24 #include "bundle_active_module_record.h"
25 #include "bundle_active_event_tracker.h"
26 #include "bundle_active_package_stats.h"
27 #include "bundle_active_event.h"
28 #include "bundle_active_form_record.h"
29 #include "bundle_active_event_stats.h"
30 #include "bundle_active_user_service.h"
31 #include "bundle_active_core.h"
32 #include "bundle_active_stats_combiner.h"
33
34 using namespace testing::ext;
35
36 namespace OHOS {
37 namespace DeviceUsageStats {
38 class PackageUsageTest : public testing::Test {
39 public:
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44 };
45
SetUpTestCase(void)46 void PackageUsageTest::SetUpTestCase(void)
47 {
48 }
49
TearDownTestCase(void)50 void PackageUsageTest::TearDownTestCase(void)
51 {
52 }
53
SetUp(void)54 void PackageUsageTest::SetUp(void)
55 {
56 }
57
TearDown(void)58 void PackageUsageTest::TearDown(void)
59 {
60 }
61
62 /*
63 * @tc.name: PackageUsageTest_Update_001
64 * @tc.desc: Update
65 * @tc.type: FUNC
66 * @tc.require: issuesI5SOZY
67 */
68 HWTEST_F(PackageUsageTest, PackageUsageTest_Update_001, Function | MediumTest | Level0)
69 {
70 auto packageStats = std::make_shared<BundleActivePackageStats>();
71 std::string longTimeTaskName = "defaultLongTimeTaskName";
72 int64_t timeStamp = 20000000000000;
73 int32_t eventId = BundleActiveEvent::ABILITY_FOREGROUND;
74 std::string abilityId = "defaultAbilityId";
75 packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId);
76
77 eventId = BundleActiveEvent::ABILITY_BACKGROUND;
78 packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId);
79
80 eventId = BundleActiveEvent::ABILITY_STOP;
81 packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId);
82
83 eventId = BundleActiveEvent::END_OF_THE_DAY;
84 packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId);
85
86 eventId = BundleActiveEvent::LONG_TIME_TASK_STARTTED;
87 packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId);
88
89 eventId = BundleActiveEvent::LONG_TIME_TASK_ENDED;
90 packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId);
91
92 eventId = BundleActiveEvent::SHUTDOWN;
93 packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId);
94
95 eventId = BundleActiveEvent::FLUSH;
96 packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId);
97
98 eventId = BundleActiveEvent::SYSTEM_LOCK;
99 packageStats->Update(longTimeTaskName, timeStamp, eventId, abilityId);
100 }
101
102 /*
103 * @tc.name: PackageUsageTest_UpdateLongTimeTask_001
104 * @tc.desc: UpdateLongTimeTask
105 * @tc.type: FUNC
106 * @tc.require: issuesI5SOZY
107 */
108 HWTEST_F(PackageUsageTest, PackageUsageTest_UpdateLongTimeTask_001, Function | MediumTest | Level0)
109 {
110 auto packageStats = std::make_shared<BundleActivePackageStats>();
111 std::string longTimeTaskName = "defaultLongTimeTaskName";
112 int64_t timeStamp = 20000000000000;
113 int32_t eventId = BundleActiveEvent::ABILITY_FOREGROUND;
114 packageStats->UpdateLongTimeTask(longTimeTaskName, timeStamp, eventId);
115
116 eventId = BundleActiveEvent::LONG_TIME_TASK_ENDED;
117 packageStats->UpdateLongTimeTask(longTimeTaskName, timeStamp, eventId);
118 packageStats->UpdateLongTimeTask(longTimeTaskName, timeStamp, eventId);
119
120 eventId = BundleActiveEvent::LONG_TIME_TASK_STARTTED;
121 packageStats->UpdateLongTimeTask(longTimeTaskName, timeStamp, eventId);
122 }
123
124 /*
125 * @tc.name: PackageUsageTest_UpdateAbility_001
126 * @tc.desc: UpdateAbility
127 * @tc.type: FUNC
128 * @tc.require: issuesI5SOZY
129 */
130 HWTEST_F(PackageUsageTest, PackageUsageTest_UpdateAbility_001, Function | MediumTest | Level0)
131 {
132 auto packageStats = std::make_shared<BundleActivePackageStats>();
133 std::string abilityId = "defaultAbilityId";
134 int64_t timeStamp = 20000000000000;
135 int32_t eventId = BundleActiveEvent::LONG_TIME_TASK_ENDED;
136 packageStats->UpdateAbility(timeStamp, eventId, abilityId);
137
138 eventId = BundleActiveEvent::ABILITY_FOREGROUND;
139 packageStats->UpdateAbility(timeStamp, eventId, abilityId);
140
141 eventId = BundleActiveEvent::ABILITY_BACKGROUND;
142 packageStats->UpdateAbility(timeStamp, eventId, abilityId);
143 packageStats->HasFrontAbility();
144
145 eventId = BundleActiveEvent::ABILITY_STOP;
146 packageStats->UpdateAbility(timeStamp, eventId, abilityId);
147 }
148
149 /*
150 * @tc.name: PackageUsageTest_Increment_001
151 * @tc.desc: IncrementServiceTimeUsed and IncrementTimeUsed
152 * @tc.type: FUNC
153 * @tc.require: issuesI5SOZY
154 */
155 HWTEST_F(PackageUsageTest, PackageUsageTest_Increment_001, Function | MediumTest | Level0)
156 {
157 auto packageStats = std::make_shared<BundleActivePackageStats>();
158 int64_t largeNum = 20000000000000;
159 packageStats->lastContiniousTaskUsed_ = largeNum;
160 packageStats->IncrementServiceTimeUsed(largeNum + 1);
161 packageStats->IncrementServiceTimeUsed(largeNum);
162
163 packageStats->lastTimeUsed_ = largeNum;
164 packageStats->IncrementTimeUsed(largeNum + 1);
165 packageStats->IncrementTimeUsed(largeNum);
166 }
167
168 /*
169 * @tc.name: PackageUsageTest_BundleActiveModuleRecord_001
170 * @tc.desc: BundleActiveModuleRecord
171 * @tc.type: FUNC
172 * @tc.require: issuesI5SOZY
173 */
174 HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveModuleRecord_001, Function | MediumTest | Level0)
175 {
176 auto moduleRecord = std::make_shared<BundleActiveModuleRecord>();
177 std::string forName = "defaultformname";
178 int32_t formDimension = 1;
179 int64_t formId = 1;
180 int64_t timeStamp = 20000000000000;
181 moduleRecord->AddOrUpdateOneFormRecord(forName, formDimension, formId, timeStamp);
182 moduleRecord->AddOrUpdateOneFormRecord(forName, formDimension, formId, timeStamp*10);
183 moduleRecord->lastModuleUsedTime_ = timeStamp;
184 moduleRecord->UpdateModuleRecord(timeStamp);
185 moduleRecord->RemoveOneFormRecord(forName, formDimension, formId);
186 }
187
188 /*
189 * @tc.name: PackageUsageTest_BundleActiveEventTracker_001
190 * @tc.desc: BundleActiveEventTracker
191 * @tc.type: FUNC
192 * @tc.require: issuesI5SOZY
193 */
194 HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveEventTracker_001, Function | MediumTest | Level0)
195 {
196 auto eventTracker = std::make_shared<BundleActiveEventTracker>();
197 eventTracker->curStartTime_ = 0;
198 int64_t timeStamp = 20000000000000;
199 eventTracker->Update(timeStamp);
200
201 eventTracker->curStartTime_ = 1;
202 eventTracker->Update(timeStamp);
203
204 eventTracker->count_ = 0;
205 eventTracker->duration_ = 0;
206 std::vector<BundleActiveEventStats> eventStatsList;
207 int32_t eventId = BundleActiveEvent::ABILITY_FOREGROUND;
208 int64_t beginTime = 0;
209 int64_t endTime = timeStamp;
210 eventTracker->AddToEventStats(eventStatsList, eventId, beginTime, endTime);
211
212 eventTracker->count_ = 0;
213 eventTracker->duration_ = 1;
214 eventTracker->AddToEventStats(eventStatsList, eventId, beginTime, endTime);
215
216 eventTracker->count_ = 1;
217 eventTracker->duration_ = 0;
218 eventTracker->AddToEventStats(eventStatsList, eventId, beginTime, endTime);
219 }
220
221 /*
222 * @tc.name: PackageUsageTest_BundleActiveFormRecord_001
223 * @tc.desc: BundleActiveFormRecord
224 * @tc.type: FUNC
225 * @tc.require: issuesI5SOZY
226 */
227 HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveFormRecord_001, Function | MediumTest | Level0)
228 {
229 auto formRecord = std::make_shared<BundleActiveFormRecord>();
230 int64_t timeStamp = 20000000000000;
231 formRecord->UpdateFormRecord(timeStamp);
232 formRecord->UpdateFormRecord(timeStamp);
233 }
234
235 /*
236 * @tc.name: PackageUsageTest_BundleActiveEventStats_001
237 * @tc.desc: BundleActiveEventStats
238 * @tc.type: FUNC
239 * @tc.require: issuesI5SOZY
240 */
241 HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveEventStats_001, Function | MediumTest | Level0)
242 {
243 auto eventStats = std::make_shared<BundleActiveEventStats>();
244 BundleActiveEventStats stat;
245 stat.eventId_ = 1;
246 eventStats->add(stat);
247
248 stat.eventId_ = 0;
249 stat.beginTimeStamp_ = 1;
250 eventStats->add(stat);
251
252 stat.beginTimeStamp_ = -1;
253 eventStats->add(stat);
254 }
255
256 /*
257 * @tc.name: PackageUsageTest_ReportForShutdown_001
258 * @tc.desc: ReportForShutdown
259 * @tc.type: FUNC
260 * @tc.require: issuesI5SOZY
261 */
262 HWTEST_F(PackageUsageTest, PackageUsageTest_ReportForShutdown_001, Function | MediumTest | Level0)
263 {
264 int32_t userId = 100;
265 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
266 bundleActiveCore->Init();
267 bundleActiveCore->InitBundleGroupController();
268 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), false);
269 BundleActiveEvent event;
270 event.eventId_ = BundleActiveEvent::ABILITY_FOREGROUND;
271 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
272 bundleUserService->ReportForShutdown(event);
273
274 event.eventId_ = BundleActiveEvent::SHUTDOWN;
275 bundleUserService->ReportForShutdown(event);
276
277 event.timeStamp_ = -1;
278 bundleUserService->ReportForShutdown(event);
279 EXPECT_NE(bundleUserService, nullptr);
280 }
281
282 /*
283 * @tc.name: PackageUsageTest_ReportFormEvent_001
284 * @tc.desc: ReportFormEvent
285 * @tc.type: FUNC
286 * @tc.require: issuesI5SOZY
287 */
288 HWTEST_F(PackageUsageTest, PackageUsageTest_ReportFormEvent_001, Function | MediumTest | Level0)
289 {
290 int32_t userId = 100;
291 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
292 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
293 BundleActiveEvent event;
294 event.bundleName_ = "defaultBundleName";
295 event.moduleName_ = "defaultModuleName";
296 event.eventId_ = BundleActiveEvent::FORM_IS_CLICKED;
297 bundleUserService->ReportFormEvent(event);
298
299 event.eventId_ = BundleActiveEvent::FORM_IS_REMOVED;
300 bundleUserService->ReportFormEvent(event);
301 EXPECT_NE(bundleUserService, nullptr);
302 }
303
304 /*
305 * @tc.name: PackageUsageTest_PrintInMemFormStats_001
306 * @tc.desc: PrintInMemFormStats
307 * @tc.type: FUNC
308 * @tc.require: issuesI5SOZY
309 */
310 HWTEST_F(PackageUsageTest, PackageUsageTest_PrintInMemFormStats_001, Function | MediumTest | Level0)
311 {
312 int32_t userId = 100;
313 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
314 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
315 BundleActiveEvent event;
316 event.bundleName_ = "defaultBundleName";
317 event.moduleName_ = "defaultModuleName";
318 bundleUserService->GetOrCreateModuleRecord(event);
319
320 bundleUserService->PrintInMemFormStats(true, true);
321 bundleUserService->PrintInMemFormStats(true, false);
322 EXPECT_NE(bundleUserService, nullptr);
323 }
324
325 /*
326 * @tc.name: PackageUsageTest_QueryDeviceEventStats_001
327 * @tc.desc: QueryDeviceEventStats
328 * @tc.type: FUNC
329 * @tc.require: issuesI5SOZY
330 */
331 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryDeviceEventStats_001, Function | MediumTest | Level0)
332 {
333 int32_t userId = 100;
334 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
335 bundleActiveCore->Init();
336 bundleActiveCore->InitBundleGroupController();
337 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
338 int64_t timeStamp = 20000000000000;
339 bundleUserService->Init(timeStamp);
340
341 int64_t beginTime = 0;
342 int64_t endTime = 0;
343 std::vector<BundleActiveEventStats> eventStats;
344 bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
345
346 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
347 bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
348
349 beginTime = -1;
350 bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
351
352 bundleUserService->currentStats_[0]->endTime_ = 1;
353 beginTime = 0;
354 bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
355 EXPECT_NE(bundleUserService, nullptr);
356 }
357
358 /*
359 * @tc.name: PackageUsageTest_QueryNotificationEventStats_001
360 * @tc.desc: QueryNotificationEventStats
361 * @tc.type: FUNC
362 * @tc.require: issuesI5SOZY
363 */
364 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryNotificationEventStats_001, Function | MediumTest | Level0)
365 {
366 int32_t userId = 100;
367 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
368 bundleActiveCore->Init();
369 bundleActiveCore->InitBundleGroupController();
370 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
371 int64_t timeStamp = 20000000000000;
372 bundleUserService->Init(timeStamp);
373
374 int64_t beginTime = 0;
375 int64_t endTime = 0;
376 std::vector<BundleActiveEventStats> eventStats;
377 bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
378
379 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
380 bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
381
382 beginTime = -1;
383 bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
384
385 bundleUserService->currentStats_[0]->endTime_ = 1;
386 beginTime = 0;
387 bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
388
389 bundleUserService->currentStats_[0]->endTime_ = 1;
390 beginTime = 0;
391 endTime = 20000000000000;
392 bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
393 EXPECT_NE(bundleUserService, nullptr);
394 }
395
396 /*
397 * @tc.name: PackageUsageTest_QueryBundleEvents_001
398 * @tc.desc: QueryBundleEvents
399 * @tc.type: FUNC
400 * @tc.require: issuesI5SOZY
401 */
402 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryBundleEvents_001, Function | MediumTest | Level0)
403 {
404 int32_t userId = 100;
405 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
406 bundleActiveCore->Init();
407 bundleActiveCore->InitBundleGroupController();
408 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
409 int64_t timeStamp = 20000000000000;
410 bundleUserService->Init(timeStamp);
411
412 int64_t beginTime = 0;
413 int64_t endTime = 0;
414 std::vector<BundleActiveEvent> bundleActiveEvent;
415 std::string bundleName = "defaultBundleName";
416 bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
417
418 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
419 EXPECT_NE(
420 bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName), ERR_OK);
421
422 beginTime = -1;
423 bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
424
425 bundleUserService->currentStats_[0]->endTime_ = 1;
426 endTime = 20000000000000;
427 bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
428
429 bundleUserService->currentStats_[0]->endTime_ = 1;
430 beginTime = 0;
431 endTime = 20000000000000;
432 bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
433 EXPECT_NE(bundleUserService, nullptr);
434 }
435
436 /*
437 * @tc.name: PackageUsageTest_PrintInMemPackageStats_001
438 * @tc.desc: PrintInMemPackageStats
439 * @tc.type: FUNC
440 * @tc.require: issuesI5SOZY
441 */
442 HWTEST_F(PackageUsageTest, PackageUsageTest_PrintInMemPackageStats_001, Function | MediumTest | Level0)
443 {
444 int32_t userId = 100;
445 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
446 bundleActiveCore->Init();
447 bundleActiveCore->InitBundleGroupController();
448 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
449 int64_t timeStamp = 20000000000000;
450 bundleUserService->Init(timeStamp);
451
452 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
453 bundleUserService->currentStats_[0]->bundleStats_.emplace(
454 "defaultBundleStat", std::make_shared<BundleActivePackageStats>());
455 bundleUserService->PrintInMemPackageStats(0, true);
456 EXPECT_NE(bundleUserService, nullptr);
457 }
458
459 /*
460 * @tc.name: PackageUsageTest_QueryBundleStatsInfos_001
461 * @tc.desc: QueryBundleStatsInfos
462 * @tc.type: FUNC
463 * @tc.require: issuesI5SOZY
464 */
465 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryBundleStatsInfos_001, Function | MediumTest | Level0)
466 {
467 int32_t userId = 100;
468 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
469 bundleActiveCore->Init();
470 bundleActiveCore->InitBundleGroupController();
471 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
472 int64_t timeStamp = 20000000000000;
473 bundleUserService->Init(timeStamp);
474
475 int64_t beginTime = 0;
476 int64_t endTime = 0;
477 std::vector<BundleActivePackageStats> PackageStats;
478 std::string bundleName = "defaultBundleName";
479 int32_t intervalType = -1;
480 EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
481 PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
482
483 intervalType = 5;
484 EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
485 PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
486
487 intervalType = 0;
488 bundleUserService->currentStats_[0] = nullptr;
489 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
490
491 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
492 beginTime = ONE_DAY_TIME + 1;
493 EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
494 PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
495
496 beginTime = ONE_DAY_TIME;
497 EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
498 PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
499
500 bundleUserService->currentStats_[0]->endTime_ = 1;
501 beginTime = 0;
502 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
503
504 endTime = 0;
505 auto packageStatsObject = std::make_shared<BundleActivePackageStats>();
506 bundleUserService->currentStats_[0]->bundleStats_.emplace("defaultBundleStat", packageStatsObject);
507 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
508
509 packageStatsObject->totalInFrontTime_ = 1;
510 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
511
512 packageStatsObject->bundleName_ = "defaultBundleName";
513 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
514
515 packageStatsObject->lastTimeUsed_ = 1;
516 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
517
518 endTime = 1;
519 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
520 packageStatsObject = nullptr;
521
522 endTime = 0;
523 bundleName = "";
524 packageStatsObject = std::make_shared<BundleActivePackageStats>();
525 bundleUserService->currentStats_[0]->bundleStats_.emplace("defaultBundleStat", packageStatsObject);
526 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
527
528 packageStatsObject->totalInFrontTime_ = 1;
529 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
530
531 packageStatsObject->lastTimeUsed_ = 1;
532 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
533
534 endTime = 1;
535 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
536 EXPECT_NE(bundleUserService, nullptr);
537 }
538
539 /*
540 * @tc.name: PackageUsageTest_RestoreStats_001
541 * @tc.desc: RestoreStats
542 * @tc.type: FUNC
543 * @tc.require: issuesI5SOZY
544 */
545 HWTEST_F(PackageUsageTest, PackageUsageTest_RestoreStats_001, Function | MediumTest | Level0)
546 {
547 int32_t userId = 100;
548 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
549 bundleActiveCore->Init();
550 bundleActiveCore->InitBundleGroupController();
551 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
552 int64_t timeStamp = 20000000000000;
553 bundleUserService->Init(timeStamp);
554
555 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
556 auto packageStatsObject = std::make_shared<BundleActivePackageStats>();
557 bundleUserService->currentStats_[0]->bundleStats_.emplace(
558 "defaultBundleStat", packageStatsObject);
559 bundleUserService->moduleRecords_.emplace("defaultModule", std::make_shared<BundleActiveModuleRecord>());
560
561 bool forced = false;
562 bundleUserService->statsChanged_ = false;
563 bundleUserService->RestoreStats(forced);
564
565 forced = true;
566 bundleUserService->currentStats_[3] = nullptr;
567 bundleUserService->RestoreStats(forced);
568 EXPECT_NE(bundleUserService, nullptr);
569 }
570
571 /*
572 * @tc.name: PackageUsageTest_LoadActiveStats_001
573 * @tc.desc: LoadActiveStats
574 * @tc.type: FUNC
575 * @tc.require: issuesI5SOZY
576 */
577 HWTEST_F(PackageUsageTest, PackageUsageTest_LoadActiveStats_001, Function | MediumTest | Level0)
578 {
579 int32_t userId = 100;
580 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
581 bundleActiveCore->Init();
582 bundleActiveCore->InitBundleGroupController();
583 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
584 int64_t timeStamp = 20000000000000;
585 bundleUserService->Init(timeStamp);
586
587 bundleUserService->debugUserService_ = true;
588 bool forced = true;
589 bool timeChanged = true;
590 bundleUserService->LoadActiveStats(timeStamp, forced, timeChanged);
591
592 forced = false;
593 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
594 bundleUserService->currentStats_[3] = nullptr;
595 bundleUserService->LoadActiveStats(timeStamp, forced, timeChanged);
596
597 EXPECT_NE(bundleUserService, nullptr);
598 }
599
600 /*
601 * @tc.name: PackageUsageTest_IsBundleEvent_001
602 * @tc.desc: IsBundleEvent
603 * @tc.type: FUNC
604 * @tc.require: issuesI5SOZY
605 */
606 HWTEST_F(PackageUsageTest, PackageUsageTest_IsBundleEvent_001, Function | MediumTest | Level0)
607 {
608 auto bundleEvent = std::make_shared<BundleActiveEvent>();
609 EXPECT_EQ(bundleEvent->IsBundleEvent(BundleActiveEvent::END_OF_THE_DAY), true);
610 EXPECT_NE(bundleEvent->IsBundleEvent(BundleActiveEvent::SHUTDOWN), true);
611 }
612
613 /*
614 * @tc.name: PackageUsageTest_combine_001
615 * @tc.desc: combine
616 * @tc.type: FUNC
617 * @tc.require: issuesI5SOZY
618 */
619 HWTEST_F(PackageUsageTest, PackageUsageTest_combine_001, Function | MediumTest | Level0)
620 {
621 auto combiner = std::make_shared<BundleActiveStatsCombiner<BundleActivePackageStats>>();
622 auto stats = std::make_shared<BundleActivePeriodStats>();
623 auto packageStat = std::make_shared<BundleActivePackageStats>();
624 stats->bundleStats_.emplace("normal", packageStat);
625 packageStat = nullptr;
626 stats->bundleStats_.emplace("default", packageStat);
627 int64_t beginTime = 0;
628 std::vector<BundleActivePackageStats> accumulatedResult;
629 combiner->combine(stats, accumulatedResult, beginTime);
630
631 auto eventCombiner = std::make_shared<BundleActiveStatsCombiner<BundleActiveEvent>>();
632 std::vector<BundleActiveEvent> activeEventResult;
633 eventCombiner->combine(stats, activeEventResult, beginTime);
634 }
635
636 /*
637 * @tc.name: PackageUsageTest_ReportEvent_001
638 * @tc.desc: ReportEvent
639 * @tc.type: FUNC
640 * @tc.require: issuesI5SOZY
641 */
642 HWTEST_F(PackageUsageTest, PackageUsageTest_ReportEvent_001, Function | MediumTest | Level0)
643 {
644 int32_t userId = 100;
645 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
646 bundleActiveCore->Init();
647 bundleActiveCore->InitBundleGroupController();
648 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
649 int64_t timeStamp = 20000000000;
650 bundleUserService->Init(timeStamp);
651
652 BundleActiveEvent event;
653 event.timeStamp_ = 20000000000000000;
654 bundleUserService->Init(timeStamp);
655 event.eventId_ = BundleActiveEvent::SYSTEM_INTERACTIVE;
656 bundleUserService->ReportEvent(event);
657
658 event.eventId_ = BundleActiveEvent::FLUSH;
659 bundleUserService->ReportEvent(event);
660
661 event.eventId_ = BundleActiveEvent::SCREEN_INTERACTIVE;
662 bundleUserService->ReportEvent(event);
663
664 event.eventId_ = BundleActiveEvent::SCREEN_NON_INTERACTIVE;
665 bundleUserService->ReportEvent(event);
666
667 event.eventId_ = BundleActiveEvent::KEYGUARD_SHOWN;
668 bundleUserService->ReportEvent(event);
669
670 event.eventId_ = BundleActiveEvent::KEYGUARD_HIDDEN;
671 bundleUserService->ReportEvent(event);
672 EXPECT_NE(bundleUserService, nullptr);
673 }
674
675 /*
676 * @tc.name: PackageUsageTest_RenewStatsInMemory_001
677 * @tc.desc: RenewStatsInMemory
678 * @tc.type: FUNC
679 * @tc.require: issuesI5SOZY
680 */
681 HWTEST_F(PackageUsageTest, PackageUsageTest_RenewStatsInMemory_001, Function | MediumTest | Level0)
682 {
683 int32_t userId = 100;
684 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
685 bundleActiveCore->Init();
686 bundleActiveCore->InitBundleGroupController();
687 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
688 int64_t timeStamp = 20000000000;
689 bundleUserService->Init(timeStamp);
690
691 auto packageStat = std::make_shared<BundleActivePackageStats>();
692 bundleUserService->currentStats_[0]->bundleStats_.emplace("normal", packageStat);
693
694 packageStat->abilities_.emplace("normal", 123);
695 packageStat->longTimeTasks_.emplace("normal", 123);
696 bundleUserService->currentStats_[0]->bundleStats_.emplace("normal", packageStat);
697 packageStat = nullptr;
698 bundleUserService->currentStats_[0]->bundleStats_.emplace("default", packageStat);
699 bundleUserService->RenewStatsInMemory(timeStamp);
700 EXPECT_NE(bundleUserService, nullptr);
701 }
702 } // namespace DeviceUsageStats
703 } // namespace OHOS