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