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 EXPECT_NE(packageStats, nullptr);
101 }
102
103 /*
104 * @tc.name: PackageUsageTest_UpdateLongTimeTask_001
105 * @tc.desc: UpdateLongTimeTask
106 * @tc.type: FUNC
107 * @tc.require: issuesI5SOZY
108 */
109 HWTEST_F(PackageUsageTest, PackageUsageTest_UpdateLongTimeTask_001, Function | MediumTest | Level0)
110 {
111 auto packageStats = std::make_shared<BundleActivePackageStats>();
112 std::string longTimeTaskName = "defaultLongTimeTaskName";
113 int64_t timeStamp = 20000000000000;
114 int32_t eventId = BundleActiveEvent::ABILITY_FOREGROUND;
115 packageStats->UpdateLongTimeTask(longTimeTaskName, timeStamp, eventId);
116
117 eventId = BundleActiveEvent::LONG_TIME_TASK_ENDED;
118 packageStats->UpdateLongTimeTask(longTimeTaskName, timeStamp, eventId);
119 packageStats->UpdateLongTimeTask(longTimeTaskName, timeStamp, eventId);
120
121 eventId = BundleActiveEvent::LONG_TIME_TASK_STARTTED;
122 packageStats->UpdateLongTimeTask(longTimeTaskName, timeStamp, eventId);
123 EXPECT_NE(packageStats, nullptr);
124 }
125
126 /*
127 * @tc.name: PackageUsageTest_UpdateAbility_001
128 * @tc.desc: UpdateAbility
129 * @tc.type: FUNC
130 * @tc.require: issuesI5SOZY
131 */
132 HWTEST_F(PackageUsageTest, PackageUsageTest_UpdateAbility_001, Function | MediumTest | Level0)
133 {
134 auto packageStats = std::make_shared<BundleActivePackageStats>();
135 std::string abilityId = "defaultAbilityId";
136 int64_t timeStamp = 20000000000000;
137 int32_t eventId = BundleActiveEvent::LONG_TIME_TASK_ENDED;
138 packageStats->UpdateAbility(timeStamp, eventId, abilityId);
139
140 eventId = BundleActiveEvent::ABILITY_FOREGROUND;
141 packageStats->UpdateAbility(timeStamp, eventId, abilityId);
142
143 eventId = BundleActiveEvent::ABILITY_BACKGROUND;
144 packageStats->UpdateAbility(timeStamp, eventId, abilityId);
145 packageStats->HasFrontAbility();
146
147 eventId = BundleActiveEvent::ABILITY_STOP;
148 packageStats->UpdateAbility(timeStamp, eventId, abilityId);
149 EXPECT_NE(packageStats, nullptr);
150 }
151
152 /*
153 * @tc.name: PackageUsageTest_Increment_001
154 * @tc.desc: IncrementServiceTimeUsed and IncrementTimeUsed
155 * @tc.type: FUNC
156 * @tc.require: issuesI5SOZY
157 */
158 HWTEST_F(PackageUsageTest, PackageUsageTest_Increment_001, Function | MediumTest | Level0)
159 {
160 auto packageStats = std::make_shared<BundleActivePackageStats>();
161 int64_t largeNum = 20000000000000;
162 packageStats->lastContiniousTaskUsed_ = largeNum;
163 packageStats->IncrementServiceTimeUsed(largeNum + 1);
164 packageStats->IncrementServiceTimeUsed(largeNum);
165
166 packageStats->lastTimeUsed_ = largeNum;
167 packageStats->IncrementTimeUsed(largeNum + 1);
168 packageStats->IncrementTimeUsed(largeNum);
169 EXPECT_NE(packageStats, nullptr);
170 }
171
172 /*
173 * @tc.name: PackageUsageTest_BundleActiveModuleRecord_001
174 * @tc.desc: BundleActiveModuleRecord
175 * @tc.type: FUNC
176 * @tc.require: issuesI5SOZY
177 */
178 HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveModuleRecord_001, Function | MediumTest | Level0)
179 {
180 auto moduleRecord = std::make_shared<BundleActiveModuleRecord>();
181 std::string forName = "defaultformname";
182 int32_t formDimension = 1;
183 int64_t formId = 1;
184 int64_t timeStamp = 20000000000000;
185 moduleRecord->AddOrUpdateOneFormRecord(forName, formDimension, formId, timeStamp);
186 moduleRecord->AddOrUpdateOneFormRecord(forName, formDimension, formId, timeStamp*10);
187 moduleRecord->lastModuleUsedTime_ = timeStamp;
188 moduleRecord->UpdateModuleRecord(timeStamp);
189 moduleRecord->RemoveOneFormRecord(forName, formDimension, formId);
190 EXPECT_NE(moduleRecord, nullptr);
191 }
192
193 /*
194 * @tc.name: PackageUsageTest_BundleActiveEventTracker_001
195 * @tc.desc: BundleActiveEventTracker
196 * @tc.type: FUNC
197 * @tc.require: issuesI5SOZY
198 */
199 HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveEventTracker_001, Function | MediumTest | Level0)
200 {
201 auto eventTracker = std::make_shared<BundleActiveEventTracker>();
202 eventTracker->curStartTime_ = 0;
203 int64_t timeStamp = 20000000000000;
204 eventTracker->Update(timeStamp);
205
206 eventTracker->curStartTime_ = 1;
207 eventTracker->Update(timeStamp);
208
209 eventTracker->count_ = 0;
210 eventTracker->duration_ = 0;
211 std::vector<BundleActiveEventStats> eventStatsList;
212 int32_t eventId = BundleActiveEvent::ABILITY_FOREGROUND;
213 int64_t beginTime = 0;
214 int64_t endTime = timeStamp;
215 eventTracker->AddToEventStats(eventStatsList, eventId, beginTime, endTime);
216
217 eventTracker->count_ = 0;
218 eventTracker->duration_ = 1;
219 eventTracker->AddToEventStats(eventStatsList, eventId, beginTime, endTime);
220
221 eventTracker->count_ = 1;
222 eventTracker->duration_ = 0;
223 eventTracker->AddToEventStats(eventStatsList, eventId, beginTime, endTime);
224 EXPECT_NE(eventTracker, nullptr);
225 }
226
227 /*
228 * @tc.name: PackageUsageTest_BundleActiveFormRecord_001
229 * @tc.desc: BundleActiveFormRecord
230 * @tc.type: FUNC
231 * @tc.require: issuesI5SOZY
232 */
233 HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveFormRecord_001, Function | MediumTest | Level0)
234 {
235 auto formRecord = std::make_shared<BundleActiveFormRecord>();
236 int64_t timeStamp = 20000000000000;
237 formRecord->UpdateFormRecord(timeStamp);
238 formRecord->UpdateFormRecord(timeStamp);
239 EXPECT_NE(formRecord, nullptr);
240 }
241
242 /*
243 * @tc.name: PackageUsageTest_BundleActiveEventStats_001
244 * @tc.desc: BundleActiveEventStats
245 * @tc.type: FUNC
246 * @tc.require: issuesI5SOZY
247 */
248 HWTEST_F(PackageUsageTest, PackageUsageTest_BundleActiveEventStats_001, Function | MediumTest | Level0)
249 {
250 auto eventStats = std::make_shared<BundleActiveEventStats>();
251 BundleActiveEventStats stat;
252 stat.eventId_ = 1;
253 eventStats->add(stat);
254
255 stat.eventId_ = 0;
256 stat.beginTimeStamp_ = 1;
257 eventStats->add(stat);
258
259 stat.beginTimeStamp_ = -1;
260 eventStats->add(stat);
261 EXPECT_NE(eventStats, nullptr);
262 }
263
264 /*
265 * @tc.name: PackageUsageTest_ReportForShutdown_001
266 * @tc.desc: ReportForShutdown
267 * @tc.type: FUNC
268 * @tc.require: issuesI5SOZY
269 */
270 HWTEST_F(PackageUsageTest, PackageUsageTest_ReportForShutdown_001, Function | MediumTest | Level0)
271 {
272 int32_t userId = 100;
273 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
274 bundleActiveCore->Init();
275 bundleActiveCore->InitBundleGroupController();
276 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), false);
277 BundleActiveEvent event;
278 event.eventId_ = BundleActiveEvent::ABILITY_FOREGROUND;
279 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
280 bundleUserService->ReportForShutdown(event);
281
282 event.eventId_ = BundleActiveEvent::SHUTDOWN;
283 bundleUserService->ReportForShutdown(event);
284
285 event.timeStamp_ = -1;
286 bundleUserService->ReportForShutdown(event);
287 EXPECT_NE(bundleUserService, nullptr);
288 }
289
290 /*
291 * @tc.name: PackageUsageTest_ReportFormEvent_001
292 * @tc.desc: ReportFormEvent
293 * @tc.type: FUNC
294 * @tc.require: issuesI5SOZY
295 */
296 HWTEST_F(PackageUsageTest, PackageUsageTest_ReportFormEvent_001, Function | MediumTest | Level0)
297 {
298 int32_t userId = 100;
299 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
300 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
301 BundleActiveEvent event;
302 event.bundleName_ = "defaultBundleName";
303 event.moduleName_ = "defaultModuleName";
304 event.eventId_ = BundleActiveEvent::FORM_IS_CLICKED;
305 bundleUserService->ReportFormEvent(event);
306
307 event.eventId_ = BundleActiveEvent::FORM_IS_REMOVED;
308 bundleUserService->ReportFormEvent(event);
309 EXPECT_NE(bundleUserService, nullptr);
310 }
311
312 /*
313 * @tc.name: PackageUsageTest_PrintInMemFormStats_001
314 * @tc.desc: PrintInMemFormStats
315 * @tc.type: FUNC
316 * @tc.require: issuesI5SOZY
317 */
318 HWTEST_F(PackageUsageTest, PackageUsageTest_PrintInMemFormStats_001, Function | MediumTest | Level0)
319 {
320 int32_t userId = 100;
321 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
322 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
323 BundleActiveEvent event;
324 event.bundleName_ = "defaultBundleName";
325 event.moduleName_ = "defaultModuleName";
326 bundleUserService->GetOrCreateModuleRecord(event);
327
328 bundleUserService->PrintInMemFormStats(true, true);
329 bundleUserService->PrintInMemFormStats(true, false);
330 EXPECT_NE(bundleUserService, nullptr);
331 }
332
333 /*
334 * @tc.name: PackageUsageTest_QueryDeviceEventStats_001
335 * @tc.desc: QueryDeviceEventStats
336 * @tc.type: FUNC
337 * @tc.require: issuesI5SOZY
338 */
339 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryDeviceEventStats_001, Function | MediumTest | Level0)
340 {
341 int32_t userId = 100;
342 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
343 bundleActiveCore->Init();
344 bundleActiveCore->InitBundleGroupController();
345 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
346 int64_t timeStamp = 20000000000000;
347 bundleUserService->Init(timeStamp);
348
349 int64_t beginTime = 0;
350 int64_t endTime = 0;
351 std::vector<BundleActiveEventStats> eventStats;
352 bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
353
354 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
355 bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
356
357 beginTime = -1;
358 bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
359
360 bundleUserService->currentStats_[0]->endTime_ = 1;
361 beginTime = 0;
362 bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
363 EXPECT_NE(bundleUserService, nullptr);
364 }
365
366 /*
367 * @tc.name: PackageUsageTest_QueryNotificationEventStats_001
368 * @tc.desc: QueryNotificationEventStats
369 * @tc.type: FUNC
370 * @tc.require: issuesI5SOZY
371 */
372 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryNotificationEventStats_001, Function | MediumTest | Level0)
373 {
374 int32_t userId = 100;
375 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
376 bundleActiveCore->Init();
377 bundleActiveCore->InitBundleGroupController();
378 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
379 int64_t timeStamp = 20000000000000;
380 bundleUserService->Init(timeStamp);
381
382 int64_t beginTime = 0;
383 int64_t endTime = 0;
384 std::vector<BundleActiveEventStats> eventStats;
385 bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
386
387 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
388 bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
389
390 beginTime = -1;
391 bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
392
393 bundleUserService->currentStats_[0]->endTime_ = 1;
394 beginTime = 0;
395 bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
396
397 bundleUserService->currentStats_[0]->endTime_ = 1;
398 beginTime = 0;
399 endTime = 20000000000000;
400 bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
401 EXPECT_NE(bundleUserService, nullptr);
402 }
403
404 /*
405 * @tc.name: PackageUsageTest_QueryBundleEvents_001
406 * @tc.desc: QueryBundleEvents
407 * @tc.type: FUNC
408 * @tc.require: issuesI5SOZY
409 */
410 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryBundleEvents_001, Function | MediumTest | Level0)
411 {
412 int32_t userId = 100;
413 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
414 bundleActiveCore->Init();
415 bundleActiveCore->InitBundleGroupController();
416 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
417 int64_t timeStamp = 20000000000000;
418 bundleUserService->Init(timeStamp);
419
420 int64_t beginTime = 0;
421 int64_t endTime = 0;
422 std::vector<BundleActiveEvent> bundleActiveEvent;
423 std::string bundleName = "defaultBundleName";
424 bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
425
426 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
427 EXPECT_NE(
428 bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName), ERR_OK);
429
430 beginTime = -1;
431 bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
432
433 bundleUserService->currentStats_[0]->endTime_ = 1;
434 endTime = 20000000000000;
435 bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
436
437 bundleUserService->currentStats_[0]->endTime_ = 1;
438 beginTime = 0;
439 endTime = 20000000000000;
440 bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
441 EXPECT_NE(bundleUserService, nullptr);
442 }
443
444 /*
445 * @tc.name: PackageUsageTest_PrintInMemPackageStats_001
446 * @tc.desc: PrintInMemPackageStats
447 * @tc.type: FUNC
448 * @tc.require: issuesI5SOZY
449 */
450 HWTEST_F(PackageUsageTest, PackageUsageTest_PrintInMemPackageStats_001, Function | MediumTest | Level0)
451 {
452 int32_t userId = 100;
453 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
454 bundleActiveCore->Init();
455 bundleActiveCore->InitBundleGroupController();
456 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
457 int64_t timeStamp = 20000000000000;
458 bundleUserService->Init(timeStamp);
459
460 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
461 bundleUserService->currentStats_[0]->bundleStats_.emplace(
462 "defaultBundleStat", std::make_shared<BundleActivePackageStats>());
463 bundleUserService->PrintInMemPackageStats(0, true);
464 EXPECT_NE(bundleUserService, nullptr);
465 }
466
467 /*
468 * @tc.name: PackageUsageTest_QueryBundleStatsInfos_001
469 * @tc.desc: QueryBundleStatsInfos
470 * @tc.type: FUNC
471 * @tc.require: issuesI5SOZY
472 */
473 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryBundleStatsInfos_001, Function | MediumTest | Level0)
474 {
475 int32_t userId = 100;
476 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
477 bundleActiveCore->Init();
478 bundleActiveCore->InitBundleGroupController();
479 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
480 int64_t timeStamp = 20000000000000;
481 bundleUserService->Init(timeStamp);
482
483 int64_t beginTime = 0;
484 int64_t endTime = 0;
485 std::vector<BundleActivePackageStats> PackageStats;
486 std::string bundleName = "defaultBundleName";
487 int32_t intervalType = -1;
488 EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
489 PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
490
491 intervalType = 5;
492 EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
493 PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
494
495 intervalType = 0;
496 bundleUserService->currentStats_[0] = nullptr;
497 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
498
499 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
500 beginTime = ONE_DAY_TIME + 1;
501 EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
502 PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
503
504 beginTime = ONE_DAY_TIME;
505 EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
506 PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
507
508 bundleUserService->currentStats_[0]->endTime_ = 1;
509 beginTime = 0;
510 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
511
512 endTime = 0;
513 auto packageStatsObject = std::make_shared<BundleActivePackageStats>();
514 bundleUserService->currentStats_[0]->bundleStats_.emplace("defaultBundleStat", packageStatsObject);
515 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
516
517 packageStatsObject->totalInFrontTime_ = 1;
518 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
519
520 packageStatsObject->bundleName_ = "defaultBundleName";
521 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
522
523 packageStatsObject->lastTimeUsed_ = 1;
524 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
525
526 endTime = 1;
527 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
528 packageStatsObject = nullptr;
529
530 endTime = 0;
531 bundleName = "";
532 packageStatsObject = std::make_shared<BundleActivePackageStats>();
533 bundleUserService->currentStats_[0]->bundleStats_.emplace("defaultBundleStat", packageStatsObject);
534 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
535
536 packageStatsObject->totalInFrontTime_ = 1;
537 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
538
539 packageStatsObject->lastTimeUsed_ = 1;
540 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
541
542 endTime = 1;
543 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
544 EXPECT_NE(bundleUserService, nullptr);
545 }
546
547 /*
548 * @tc.name: PackageUsageTest_RestoreStats_001
549 * @tc.desc: RestoreStats
550 * @tc.type: FUNC
551 * @tc.require: issuesI5SOZY
552 */
553 HWTEST_F(PackageUsageTest, PackageUsageTest_RestoreStats_001, Function | MediumTest | Level0)
554 {
555 int32_t userId = 100;
556 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
557 bundleActiveCore->Init();
558 bundleActiveCore->InitBundleGroupController();
559 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
560 int64_t timeStamp = 20000000000000;
561 bundleUserService->Init(timeStamp);
562
563 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
564 auto packageStatsObject = std::make_shared<BundleActivePackageStats>();
565 bundleUserService->currentStats_[0]->bundleStats_.emplace(
566 "defaultBundleStat", packageStatsObject);
567 bundleUserService->moduleRecords_.emplace("defaultModule", std::make_shared<BundleActiveModuleRecord>());
568
569 bool forced = false;
570 bundleUserService->statsChanged_ = false;
571 bundleUserService->RestoreStats(forced);
572
573 forced = true;
574 bundleUserService->currentStats_[3] = nullptr;
575 bundleUserService->RestoreStats(forced);
576 EXPECT_NE(bundleUserService, nullptr);
577 }
578
579 /*
580 * @tc.name: PackageUsageTest_LoadActiveStats_001
581 * @tc.desc: LoadActiveStats
582 * @tc.type: FUNC
583 * @tc.require: issuesI5SOZY
584 */
585 HWTEST_F(PackageUsageTest, PackageUsageTest_LoadActiveStats_001, Function | MediumTest | Level0)
586 {
587 int32_t userId = 100;
588 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
589 bundleActiveCore->Init();
590 bundleActiveCore->InitBundleGroupController();
591 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
592 int64_t timeStamp = 20000000000000;
593 bundleUserService->Init(timeStamp);
594
595 bundleUserService->debugUserService_ = true;
596 bool forced = true;
597 bool timeChanged = true;
598 bundleUserService->LoadActiveStats(timeStamp, forced, timeChanged);
599
600 forced = false;
601 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
602 bundleUserService->currentStats_[3] = nullptr;
603 bundleUserService->LoadActiveStats(timeStamp, forced, timeChanged);
604
605 EXPECT_NE(bundleUserService, nullptr);
606 }
607
608 /*
609 * @tc.name: PackageUsageTest_IsBundleEvent_001
610 * @tc.desc: IsBundleEvent
611 * @tc.type: FUNC
612 * @tc.require: issuesI5SOZY
613 */
614 HWTEST_F(PackageUsageTest, PackageUsageTest_IsBundleEvent_001, Function | MediumTest | Level0)
615 {
616 auto bundleEvent = std::make_shared<BundleActiveEvent>();
617 EXPECT_EQ(bundleEvent->IsBundleEvent(BundleActiveEvent::END_OF_THE_DAY), true);
618 EXPECT_NE(bundleEvent->IsBundleEvent(BundleActiveEvent::SHUTDOWN), true);
619 }
620
621 /*
622 * @tc.name: PackageUsageTest_combine_001
623 * @tc.desc: combine
624 * @tc.type: FUNC
625 * @tc.require: issuesI5SOZY
626 */
627 HWTEST_F(PackageUsageTest, PackageUsageTest_combine_001, Function | MediumTest | Level0)
628 {
629 auto combiner = std::make_shared<BundleActiveStatsCombiner<BundleActivePackageStats>>();
630 auto stats = std::make_shared<BundleActivePeriodStats>();
631 auto packageStat = std::make_shared<BundleActivePackageStats>();
632 stats->bundleStats_.emplace("normal", packageStat);
633 packageStat = nullptr;
634 stats->bundleStats_.emplace("default", packageStat);
635 int64_t beginTime = 0;
636 std::vector<BundleActivePackageStats> accumulatedResult;
637 combiner->combine(stats, accumulatedResult, beginTime);
638
639 auto eventCombiner = std::make_shared<BundleActiveStatsCombiner<BundleActiveEvent>>();
640 std::vector<BundleActiveEvent> activeEventResult;
641 eventCombiner->combine(stats, activeEventResult, beginTime);
642 EXPECT_NE(combiner, nullptr);
643 }
644
645 /*
646 * @tc.name: PackageUsageTest_ReportEvent_001
647 * @tc.desc: ReportEvent
648 * @tc.type: FUNC
649 * @tc.require: issuesI5SOZY
650 */
651 HWTEST_F(PackageUsageTest, PackageUsageTest_ReportEvent_001, Function | MediumTest | Level0)
652 {
653 int32_t userId = 100;
654 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
655 bundleActiveCore->Init();
656 bundleActiveCore->InitBundleGroupController();
657 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
658 int64_t timeStamp = 20000000000;
659 bundleUserService->Init(timeStamp);
660
661 BundleActiveEvent event;
662 event.timeStamp_ = 20000000000000000;
663 bundleUserService->Init(timeStamp);
664 event.eventId_ = BundleActiveEvent::SYSTEM_INTERACTIVE;
665 bundleUserService->ReportEvent(event);
666
667 event.eventId_ = BundleActiveEvent::FLUSH;
668 bundleUserService->ReportEvent(event);
669
670 event.eventId_ = BundleActiveEvent::SCREEN_INTERACTIVE;
671 bundleUserService->ReportEvent(event);
672
673 event.eventId_ = BundleActiveEvent::SCREEN_NON_INTERACTIVE;
674 bundleUserService->ReportEvent(event);
675
676 event.eventId_ = BundleActiveEvent::KEYGUARD_SHOWN;
677 bundleUserService->ReportEvent(event);
678
679 event.eventId_ = BundleActiveEvent::KEYGUARD_HIDDEN;
680 bundleUserService->ReportEvent(event);
681 EXPECT_NE(bundleUserService, nullptr);
682 }
683
684 /*
685 * @tc.name: PackageUsageTest_RenewStatsInMemory_001
686 * @tc.desc: RenewStatsInMemory
687 * @tc.type: FUNC
688 * @tc.require: issuesI5SOZY
689 */
690 HWTEST_F(PackageUsageTest, PackageUsageTest_RenewStatsInMemory_001, Function | MediumTest | Level0)
691 {
692 int32_t userId = 100;
693 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
694 bundleActiveCore->Init();
695 bundleActiveCore->InitBundleGroupController();
696 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore.get()), true);
697 int64_t timeStamp = 20000000000;
698 bundleUserService->Init(timeStamp);
699
700 auto packageStat = std::make_shared<BundleActivePackageStats>();
701 bundleUserService->currentStats_[0]->bundleStats_.emplace("normal", packageStat);
702
703 packageStat->abilities_.emplace("normal", 123);
704 packageStat->longTimeTasks_.emplace("normal", 123);
705 bundleUserService->currentStats_[0]->bundleStats_.emplace("normal", packageStat);
706 packageStat = nullptr;
707 bundleUserService->currentStats_[0]->bundleStats_.emplace("default", packageStat);
708 bundleUserService->RenewStatsInMemory(timeStamp);
709 EXPECT_NE(bundleUserService, nullptr);
710 }
711 } // namespace DeviceUsageStats
712 } // namespace OHOS