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 #include "bundle_active_test_util.h"
36 #include "bundle_active_util.h"
37
38 using namespace testing::ext;
39
40 namespace OHOS {
41 namespace DeviceUsageStats {
42 class PackageUsageTest : public testing::Test {
43 public:
44 static void SetUpTestCase(void);
45 static void TearDownTestCase(void);
46 void SetUp();
47 void TearDown();
48 static std::shared_ptr<BundleActiveCore> bundleActiveCore_;
49 };
50
51 std::shared_ptr<BundleActiveCore> PackageUsageTest::bundleActiveCore_ = nullptr;
52
SetUpTestCase(void)53 void PackageUsageTest::SetUpTestCase(void)
54 {
55 bundleActiveCore_ = BundleActiveTestUtil::TestInit();
56 }
57
TearDownTestCase(void)58 void PackageUsageTest::TearDownTestCase(void)
59 {
60 BundleActiveTestUtil::TestDeInit();
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 | TestSize.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 | TestSize.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 | TestSize.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 | TestSize.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 | TestSize.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 | TestSize.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 | TestSize.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 | TestSize.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 | TestSize.Level0)
286 {
287 int32_t userId = 100;
288 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore_.get()), false);
289 BundleActiveEvent event;
290 event.eventId_ = BundleActiveEvent::ABILITY_FOREGROUND;
291 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
292 bundleUserService->ReportForShutdown(event);
293
294 event.eventId_ = BundleActiveEvent::SHUTDOWN;
295 bundleUserService->ReportForShutdown(event);
296
297 event.timeStamp_ = -1;
298 bundleUserService->ReportForShutdown(event);
299 EXPECT_NE(bundleUserService, nullptr);
300 }
301
302 /*
303 * @tc.name: PackageUsageTest_ReportFormEvent_001
304 * @tc.desc: ReportFormEvent
305 * @tc.type: FUNC
306 * @tc.require: issuesI5SOZY
307 */
308 HWTEST_F(PackageUsageTest, PackageUsageTest_ReportFormEvent_001, Function | MediumTest | TestSize.Level0)
309 {
310 int32_t userId = 100;
311 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore_.get()), true);
312 BundleActiveEvent event;
313 event.bundleName_ = "defaultBundleName";
314 event.moduleName_ = "defaultModuleName";
315 event.eventId_ = BundleActiveEvent::FORM_IS_CLICKED;
316 bundleUserService->ReportFormEvent(event);
317
318 event.eventId_ = BundleActiveEvent::FORM_IS_REMOVED;
319 bundleUserService->ReportFormEvent(event);
320 EXPECT_NE(bundleUserService, nullptr);
321 }
322
323 /*
324 * @tc.name: PackageUsageTest_PrintInMemFormStats_001
325 * @tc.desc: PrintInMemFormStats
326 * @tc.type: FUNC
327 * @tc.require: issuesI5SOZY
328 */
329 HWTEST_F(PackageUsageTest, PackageUsageTest_PrintInMemFormStats_001, Function | MediumTest | TestSize.Level0)
330 {
331 int32_t userId = 100;
332 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore_.get()), true);
333 BundleActiveEvent event;
334 event.bundleName_ = "defaultBundleName";
335 event.moduleName_ = "defaultModuleName";
336 bundleUserService->GetOrCreateModuleRecord(event);
337
338 bundleUserService->PrintInMemFormStats(true, true);
339 bundleUserService->PrintInMemFormStats(true, false);
340 EXPECT_NE(bundleUserService, nullptr);
341 }
342
343 /*
344 * @tc.name: PackageUsageTest_QueryDeviceEventStats_001
345 * @tc.desc: QueryDeviceEventStats
346 * @tc.type: FUNC
347 * @tc.require: issuesI5SOZY
348 */
349 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryDeviceEventStats_001, Function | MediumTest | TestSize.Level0)
350 {
351 int32_t userId = 100;
352 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore_.get()), true);
353 int64_t timeStamp = 20000000000000;
354 bundleUserService->Init(timeStamp);
355
356 int64_t beginTime = 0;
357 int64_t endTime = 0;
358 std::vector<BundleActiveEventStats> eventStats;
359 bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
360
361 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
362 bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
363
364 beginTime = -1;
365 bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
366
367 bundleUserService->currentStats_[0]->endTime_ = 1;
368 beginTime = 0;
369 bundleUserService->QueryDeviceEventStats(beginTime, endTime, eventStats, userId);
370 EXPECT_NE(bundleUserService, nullptr);
371 }
372
373 /*
374 * @tc.name: PackageUsageTest_QueryNotificationEventStats_001
375 * @tc.desc: QueryNotificationEventStats
376 * @tc.type: FUNC
377 * @tc.require: issuesI5SOZY
378 */
379 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryNotificationEventStats_001, Function | MediumTest | TestSize.Level0)
380 {
381 int32_t userId = 100;
382 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore_.get()), true);
383 int64_t timeStamp = 20000000000000;
384 bundleUserService->Init(timeStamp);
385
386 int64_t beginTime = 0;
387 int64_t endTime = 0;
388 std::vector<BundleActiveEventStats> eventStats;
389 bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
390
391 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
392 bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
393
394 beginTime = -1;
395 bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
396
397 bundleUserService->currentStats_[0]->endTime_ = 1;
398 beginTime = 0;
399 bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
400
401 bundleUserService->currentStats_[0]->endTime_ = 1;
402 beginTime = 0;
403 endTime = 20000000000000;
404 bundleUserService->QueryNotificationEventStats(beginTime, endTime, eventStats, userId);
405 EXPECT_NE(bundleUserService, nullptr);
406 }
407
408 /*
409 * @tc.name: PackageUsageTest_QueryBundleEvents_001
410 * @tc.desc: QueryBundleEvents
411 * @tc.type: FUNC
412 * @tc.require: issuesI5SOZY
413 */
414 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryBundleEvents_001, Function | MediumTest | TestSize.Level0)
415 {
416 int32_t userId = 100;
417 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore_.get()), true);
418 int64_t timeStamp = 20000000000000;
419 bundleUserService->Init(timeStamp);
420
421 int64_t beginTime = 0;
422 int64_t endTime = 0;
423 std::vector<BundleActiveEvent> bundleActiveEvent;
424 std::string bundleName = "defaultBundleName";
425 bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
426
427 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
428 EXPECT_NE(
429 bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName), ERR_OK);
430
431 beginTime = -1;
432 bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
433
434 bundleUserService->currentStats_[0]->endTime_ = 1;
435 endTime = 20000000000000;
436 bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
437
438 bundleUserService->currentStats_[0]->endTime_ = 1;
439 beginTime = 0;
440 endTime = 20000000000000;
441 bundleUserService->QueryBundleEvents(bundleActiveEvent, beginTime, endTime, userId, bundleName);
442 EXPECT_NE(bundleUserService, nullptr);
443 }
444
445 /*
446 * @tc.name: PackageUsageTest_PrintInMemPackageStats_001
447 * @tc.desc: PrintInMemPackageStats
448 * @tc.type: FUNC
449 * @tc.require: issuesI5SOZY
450 */
451 HWTEST_F(PackageUsageTest, PackageUsageTest_PrintInMemPackageStats_001, Function | MediumTest | TestSize.Level0)
452 {
453 int32_t userId = 100;
454 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore_.get()), true);
455 int64_t timeStamp = 20000000000000;
456 bundleUserService->Init(timeStamp);
457
458 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
459 bundleUserService->currentStats_[0]->bundleStats_.emplace(
460 "defaultBundleStat", std::make_shared<BundleActivePackageStats>());
461 bundleUserService->PrintInMemPackageStats(0, true);
462 EXPECT_NE(bundleUserService, nullptr);
463 }
464
465 /*
466 * @tc.name: PackageUsageTest_QueryBundleStatsInfos_001
467 * @tc.desc: QueryBundleStatsInfos
468 * @tc.type: FUNC
469 * @tc.require: issuesI5SOZY
470 */
471 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryBundleStatsInfos_001, Function | MediumTest | TestSize.Level0)
472 {
473 int32_t userId = 100;
474 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore_.get()), true);
475 int64_t timeStamp = 20000000000000;
476 bundleUserService->Init(timeStamp);
477
478 int64_t beginTime = 0;
479 int64_t endTime = 0;
480 std::vector<BundleActivePackageStats> PackageStats;
481 std::string bundleName = "defaultBundleName";
482 int32_t intervalType = -1;
483 EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
484 PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
485
486 intervalType = 5;
487 EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
488 PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
489
490 intervalType = 0;
491 bundleUserService->currentStats_[0] = nullptr;
492 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
493
494 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
495 beginTime = ONE_DAY_TIME + 1;
496 EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
497 PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
498
499 beginTime = ONE_DAY_TIME;
500 EXPECT_NE(bundleUserService->QueryBundleStatsInfos(
501 PackageStats, intervalType, beginTime, endTime, userId, bundleName), ERR_OK);
502
503 bundleUserService->currentStats_[0]->endTime_ = 1;
504 beginTime = 0;
505 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
506 EXPECT_NE(bundleUserService, nullptr);
507 }
508
509 /*
510 * @tc.name: PackageUsageTest_QueryBundleStatsInfos_002
511 * @tc.desc: QueryBundleStatsInfos
512 * @tc.type: FUNC
513 * @tc.require: issuesI5SOZY
514 */
515 HWTEST_F(PackageUsageTest, PackageUsageTest_QueryBundleStatsInfos_002, Function | MediumTest | TestSize.Level0)
516 {
517 int32_t userId = 100;
518 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore_.get()), true);
519 int64_t timeStamp = 20000000000000;
520 bundleUserService->Init(timeStamp);
521 int64_t beginTime = 0;
522 int64_t endTime = 0;
523 std::vector<BundleActivePackageStats> PackageStats;
524 std::string bundleName = "defaultBundleName";
525 int32_t intervalType = 0;
526 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
527 bundleUserService->currentStats_[0]->endTime_ = 1;
528 auto packageStatsObject = std::make_shared<BundleActivePackageStats>();
529 bundleUserService->currentStats_[0]->bundleStats_.emplace("defaultBundleStat", packageStatsObject);
530 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
531
532 packageStatsObject->totalInFrontTime_ = 1;
533 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
534
535 packageStatsObject->bundleName_ = "defaultBundleName";
536 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
537
538 packageStatsObject->lastTimeUsed_ = 1;
539 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
540
541 endTime = 1;
542 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
543 packageStatsObject = nullptr;
544
545 endTime = 0;
546 bundleName = "";
547 packageStatsObject = std::make_shared<BundleActivePackageStats>();
548 bundleUserService->currentStats_[0]->bundleStats_.emplace("defaultBundleStat", packageStatsObject);
549 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
550
551 packageStatsObject->totalInFrontTime_ = 1;
552 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
553
554 packageStatsObject->lastTimeUsed_ = 1;
555 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
556
557 endTime = 1;
558 bundleUserService->QueryBundleStatsInfos(PackageStats, intervalType, beginTime, endTime, userId, bundleName);
559 EXPECT_NE(bundleUserService, nullptr);
560 }
561
562 /*
563 * @tc.name: PackageUsageTest_RestoreStats_001
564 * @tc.desc: RestoreStats
565 * @tc.type: FUNC
566 * @tc.require: issuesI5SOZY
567 */
568 HWTEST_F(PackageUsageTest, PackageUsageTest_RestoreStats_001, Function | MediumTest | TestSize.Level0)
569 {
570 int32_t userId = 100;
571 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore_.get()), true);
572 int64_t timeStamp = 20000000000000;
573 bundleUserService->Init(timeStamp);
574
575 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
576 auto packageStatsObject = std::make_shared<BundleActivePackageStats>();
577 bundleUserService->currentStats_[0]->bundleStats_.emplace(
578 "defaultBundleStat", packageStatsObject);
579 bundleUserService->moduleRecords_.emplace("defaultModule", std::make_shared<BundleActiveModuleRecord>());
580
581 bool forced = false;
582 bundleUserService->statsChanged_ = false;
583 bundleUserService->RestoreStats(forced);
584
585 forced = true;
586 bundleUserService->currentStats_[3] = nullptr;
587 bundleUserService->RestoreStats(forced);
588 EXPECT_NE(bundleUserService, nullptr);
589 }
590
591 /*
592 * @tc.name: PackageUsageTest_LoadActiveStats_001
593 * @tc.desc: LoadActiveStats
594 * @tc.type: FUNC
595 * @tc.require: issuesI5SOZY
596 */
597 HWTEST_F(PackageUsageTest, PackageUsageTest_LoadActiveStats_001, Function | MediumTest | TestSize.Level0)
598 {
599 int32_t userId = 100;
600 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore_.get()), true);
601 int64_t timeStamp = 20000000000000;
602 bundleUserService->Init(timeStamp);
603
604 bundleUserService->debugUserService_ = true;
605 bool forced = true;
606 bool timeChanged = true;
607 bundleUserService->LoadActiveStats(timeStamp, forced, timeChanged);
608
609 forced = false;
610 bundleUserService->currentStats_[0] = std::make_shared<BundleActivePeriodStats>();
611 bundleUserService->currentStats_[3] = nullptr;
612 bundleUserService->LoadActiveStats(timeStamp, forced, timeChanged);
613
614 EXPECT_NE(bundleUserService, nullptr);
615 }
616
617 /*
618 * @tc.name: PackageUsageTest_IsBundleEvent_001
619 * @tc.desc: IsBundleEvent
620 * @tc.type: FUNC
621 * @tc.require: issuesI5SOZY
622 */
623 HWTEST_F(PackageUsageTest, PackageUsageTest_IsBundleEvent_001, Function | MediumTest | TestSize.Level0)
624 {
625 auto bundleEvent = std::make_shared<BundleActiveEvent>();
626 EXPECT_EQ(bundleEvent->IsBundleEvent(BundleActiveEvent::END_OF_THE_DAY), true);
627 EXPECT_NE(bundleEvent->IsBundleEvent(BundleActiveEvent::SHUTDOWN), true);
628 }
629
630 /*
631 * @tc.name: PackageUsageTest_combine_001
632 * @tc.desc: combine
633 * @tc.type: FUNC
634 * @tc.require: issuesI5SOZY
635 */
636 HWTEST_F(PackageUsageTest, PackageUsageTest_combine_001, Function | MediumTest | TestSize.Level0)
637 {
638 auto combiner = std::make_shared<BundleActiveStatsCombiner<BundleActivePackageStats>>();
639 auto stats = std::make_shared<BundleActivePeriodStats>();
640 auto packageStat = std::make_shared<BundleActivePackageStats>();
641 stats->bundleStats_.emplace("normal", packageStat);
642 packageStat = nullptr;
643 stats->bundleStats_.emplace("default", packageStat);
644 int64_t beginTime = 0;
645 std::vector<BundleActivePackageStats> accumulatedResult;
646 combiner->combine(stats, accumulatedResult, beginTime);
647
648 auto eventCombiner = std::make_shared<BundleActiveStatsCombiner<BundleActiveEvent>>();
649 std::vector<BundleActiveEvent> activeEventResult;
650 eventCombiner->combine(stats, activeEventResult, beginTime);
651 EXPECT_NE(combiner, nullptr);
652 }
653
654 /*
655 * @tc.name: PackageUsageTest_ReportEvent_001
656 * @tc.desc: ReportEvent
657 * @tc.type: FUNC
658 * @tc.require: issuesI5SOZY
659 */
660 HWTEST_F(PackageUsageTest, PackageUsageTest_ReportEvent_001, Function | MediumTest | TestSize.Level0)
661 {
662 int32_t userId = 100;
663 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore_.get()), true);
664 int64_t timeStamp = 20000000000;
665 bundleUserService->Init(timeStamp);
666
667 BundleActiveEvent event;
668 event.timeStamp_ = 20000000000000000;
669 bundleUserService->Init(timeStamp);
670 event.eventId_ = BundleActiveEvent::SYSTEM_INTERACTIVE;
671 bundleUserService->ReportEvent(event);
672
673 event.eventId_ = BundleActiveEvent::FLUSH;
674 bundleUserService->ReportEvent(event);
675
676 event.eventId_ = BundleActiveEvent::SCREEN_INTERACTIVE;
677 bundleUserService->ReportEvent(event);
678
679 event.eventId_ = BundleActiveEvent::SCREEN_NON_INTERACTIVE;
680 bundleUserService->ReportEvent(event);
681
682 event.eventId_ = BundleActiveEvent::KEYGUARD_SHOWN;
683 bundleUserService->ReportEvent(event);
684
685 event.eventId_ = BundleActiveEvent::KEYGUARD_HIDDEN;
686 bundleUserService->ReportEvent(event);
687 EXPECT_NE(bundleUserService, nullptr);
688 }
689
690 /*
691 * @tc.name: PackageUsageTest_RenewStatsInMemory_001
692 * @tc.desc: RenewStatsInMemory
693 * @tc.type: FUNC
694 * @tc.require: issuesI5SOZY
695 */
696 HWTEST_F(PackageUsageTest, PackageUsageTest_RenewStatsInMemory_001, Function | MediumTest | TestSize.Level0)
697 {
698 int32_t userId = 100;
699 auto bundleUserService = std::make_shared<BundleActiveUserService>(userId, *(bundleActiveCore_.get()), true);
700 int64_t timeStamp = 20000000000;
701 bundleUserService->Init(timeStamp);
702
703 auto packageStat = std::make_shared<BundleActivePackageStats>();
704 packageStat->uid_ = 0;
705 packageStat->bundleName_ = "normal";
706 std::string bundleStatsKey = packageStat->bundleName_ + std::to_string(packageStat->uid_);
707 bundleUserService->currentStats_[0]->bundleStats_.emplace(bundleStatsKey, packageStat);
708
709 packageStat->abilities_.emplace("normal", 123);
710 packageStat->longTimeTasks_.emplace("normal", 123);
711 bundleUserService->currentStats_[0]->bundleStats_.emplace(bundleStatsKey, packageStat);
712 bundleUserService->RenewStatsInMemory(timeStamp);
713 packageStat = nullptr;
714 bundleUserService->currentStats_[0]->bundleStats_.emplace("default", packageStat);
715 bundleUserService->RenewStatsInMemory(timeStamp);
716 EXPECT_NE(bundleUserService, nullptr);
717 }
718
719 /*
720 * @tc.name: BundleActiveGroupController_001
721 * @tc.desc: DeleteMemoryUsageGroup
722 * @tc.type: FUNC
723 * @tc.require: IA4GZ0
724 */
725 HWTEST_F(PackageUsageTest, BundleActiveGroupController_001, Function | MediumTest | TestSize.Level0)
726 {
727 BundleActiveGroupController::GetInstance().Init(false);
728 auto userHistory = std::make_shared<std::map<std::string, std::shared_ptr<BundleActivePackageHistory>>>();
729 int32_t uid = 0;
730 int32_t appIndex = 1;
731 std::string bundleName = "test";
732 userHistory->emplace(bundleName + std::to_string(uid), std::make_shared<BundleActivePackageHistory>());
733 uid = 100;
734 userHistory->emplace(bundleName + std::to_string(uid), std::make_shared<BundleActivePackageHistory>());
735 uid = 200;
736 userHistory->emplace(bundleName + std::to_string(uid), std::make_shared<BundleActivePackageHistory>());
737 BundleActiveGroupController::GetInstance().DeleteUsageGroupCache(userHistory, bundleName, uid, appIndex);
738 auto it = userHistory->find(bundleName + std::to_string(uid));
739 EXPECT_EQ(it, userHistory->end());
740 appIndex = 0;
741 BundleActiveGroupController::GetInstance().DeleteUsageGroupCache(userHistory, bundleName, uid, appIndex);
742 uid = 0;
743 it = userHistory->find(bundleName + std::to_string(uid));
744 EXPECT_EQ(it, userHistory->end());
745 }
746
747 /*
748 * @tc.name: BundleActiveGroupController_002
749 * @tc.desc: ReportEvent
750 * @tc.type: FUNC
751 * @tc.require: IA4GZ0
752 */
753 HWTEST_F(PackageUsageTest, BundleActiveGroupController_002, Function | MediumTest | TestSize.Level0)
754 {
755 BundleActiveGroupController::GetInstance().Init(false);
756 int userId = 100;
757 BundleActiveEvent event;
758 event.eventId_ = BundleActiveEvent::SYSTEM_INTERACTIVE;
759 int64_t timeStamp = 20000000000000;
760 BundleActiveGroupController::GetInstance().ReportEvent(event, timeStamp, userId);
761 EXPECT_TRUE(BundleActiveGroupController::GetInstance().GetBundleGroupHandler() != nullptr);
762 }
763
764 /*
765 * @tc.name: BundleActiveProcessRmoveUserEventTest_001
766 * @tc.desc: ProcessRmoveUserEvent
767 * @tc.type: FUNC
768 * @tc.require: issuesIAF8RF
769 */
770 HWTEST_F(PackageUsageTest, BundleActiveProcessRmoveUserEventTest_001, Function | MediumTest | TestSize.Level0)
771 {
772 BundleActiveReportHandlerObject tmpObject;
773 auto handlerObject = std::make_shared<BundleActiveReportHandlerObject>(tmpObject);
774 auto bundleActiveReportHandler = std::make_shared<BundleActiveReportHandler>();
775 bundleActiveReportHandler->Init(bundleActiveCore_);
776 EXPECT_TRUE(bundleActiveReportHandler->isInited_);
777 bundleActiveReportHandler->ProcessRmoveUserEvent(*handlerObject);
778 bundleActiveReportHandler->ProcessUserSwitchEvent(*handlerObject);
779 }
780
781 /*
782 * @tc.name: BundleActiveEventListTest_001
783 * @tc.desc: BundleActiveEventList
784 * @tc.type: FUNC
785 * @tc.require: issuesIAF8RF
786 */
787 HWTEST_F(PackageUsageTest, BundleActiveEventListTest_001, Function | MediumTest | TestSize.Level0)
788 {
789 BundleActiveEventList right;
790 auto combiner = std::make_shared<BundleActiveEventList>();
791 combiner->Merge(right);
792 EXPECT_TRUE(combiner->events_.size() == 0);
793 }
794
795 /*
796 * @tc.name: BundleActiveReportHandlerTest_001
797 * @tc.desc: ProcessEvent
798 * @tc.type: FUNC
799 * @tc.require: issuesIAF8RF
800 */
801 HWTEST_F(PackageUsageTest, BundleActiveReportHandlerTest_001, Function | MediumTest | TestSize.Level0)
802 {
803 BundleActiveReportHandlerObject tmpObject;
804 auto handlerObject = std::make_shared<BundleActiveReportHandlerObject>(tmpObject);
805 auto bundleActiveReportHandler = std::make_shared<BundleActiveReportHandler>();
806 bundleActiveReportHandler->Init(bundleActiveCore_);
807 EXPECT_TRUE(bundleActiveReportHandler->isInited_);
808 bundleActiveReportHandler->ProcessEvent(0, handlerObject);
809 bundleActiveReportHandler->ProcessEvent(0, handlerObject);
810 bundleActiveReportHandler->ProcessEvent(0, nullptr);
811 }
812
813 /*
814 * @tc.name: BundleActiveReportHandlerTest_002
815 * @tc.desc: SendEvent and removeEvent
816 * @tc.type: FUNC
817 * @tc.require: issuesIAF8RF
818 */
819 HWTEST_F(PackageUsageTest, BundleActiveReportHandlerTest_002, Function | MediumTest | TestSize.Level0)
820 {
821 BundleActiveReportHandlerObject tmpObject;
822 auto handlerObject = std::make_shared<BundleActiveReportHandlerObject>(tmpObject);
823 auto bundleActiveReportHandler = std::make_shared<BundleActiveReportHandler>();
824 bundleActiveReportHandler->SendEvent(0, handlerObject);
825 bundleActiveReportHandler->RemoveEvent(0);
826 EXPECT_EQ(bundleActiveReportHandler->taskHandlerMap_.size(), 0);
827 bundleActiveReportHandler->Init(bundleActiveCore_);
828 bundleActiveReportHandler->SendEvent(0, handlerObject);
829 bundleActiveReportHandler->SendEvent(0, handlerObject, 10);
830 EXPECT_NE(bundleActiveReportHandler->taskHandlerMap_.size(), 0);
831 bundleActiveReportHandler->RemoveEvent(0);
832 bundleActiveReportHandler->RemoveEvent(0);
833 EXPECT_EQ(bundleActiveReportHandler->taskHandlerMap_.size(), 0);
834 }
835
836
837 /*
838 * @tc.name: BundleActiveReportHandlerTest_003
839 * @tc.desc: HasEvent
840 * @tc.type: FUNC
841 * @tc.require: issuesIAF8RF
842 */
843 HWTEST_F(PackageUsageTest, BundleActiveReportHandlerTest_003, Function | MediumTest | TestSize.Level0)
844 {
845 BundleActiveReportHandlerObject tmpObject;
846 auto handlerObject = std::make_shared<BundleActiveReportHandlerObject>(tmpObject);
847 auto bundleActiveReportHandler = std::make_shared<BundleActiveReportHandler>();
848 bundleActiveReportHandler->HasEvent(0);
849 bundleActiveReportHandler->Init(bundleActiveCore_);
850 bundleActiveReportHandler->SendEvent(0, handlerObject, 10);
851 EXPECT_EQ(bundleActiveReportHandler->HasEvent(0), true);
852 }
853
854 /*
855 * @tc.name: BundleActiveReportHandlerTest_004
856 * @tc.desc: Send Uninstalled APP Event
857 * @tc.type: FUNC
858 * @tc.require: IAHDJW
859 */
860 HWTEST_F(PackageUsageTest, BundleActiveReportHandlerTest_004, Function | MediumTest | TestSize.Level0)
861 {
862 auto bundleActiveReportHandler = std::make_shared<BundleActiveReportHandler>();
863 bundleActiveReportHandler->Init(bundleActiveCore_);
864 int32_t userId = 100;
865 std::string bundleName = "test";
866 int32_t uid = 100010;
867 int32_t appIndex = 1;
868 int64_t timeNow = bundleActiveCore_->CheckTimeChangeAndGetWallTime(userId);
869 BundleActiveReportHandlerObject tmpObject;
870 tmpObject.event_.eventId_ = tmpObject.event_.ABILITY_STOP;
871 tmpObject.event_.uid_ = uid;
872 tmpObject.event_.timeStamp_ = timeNow;
873 auto handlerObject = std::make_shared<BundleActiveReportHandlerObject>(tmpObject);
874 bundleActiveReportHandler->SendEvent(0, handlerObject);
875 auto service = bundleActiveCore_->GetUserDataAndInitializeIfNeeded(userId, timeNow, false);
876 EXPECT_EQ(service->currentStats_[0]->endTime_, timeNow);
877 bundleActiveCore_->OnBundleUninstalled(userId, bundleName, uid, appIndex);
878 EXPECT_TRUE(bundleActiveCore_->isUninstalledApp(uid));
879 timeNow = timeNow + 100;
880 tmpObject.event_.timeStamp_ = timeNow;
881 bundleActiveReportHandler->SendEvent(0, handlerObject);
882 EXPECT_NE(service->currentStats_[0]->endTime_, timeNow);
883 bundleActiveCore_->OnBundleInstalled(userId, bundleName, uid, appIndex);
884 EXPECT_FALSE(bundleActiveCore_->isUninstalledApp(uid));
885 bundleActiveCore_->UnRegisterSubscriber();
886 SUCCEED();
887 }
888
889 /*
890 * @tc.name: BundleActiveGroupHandler_001
891 * @tc.desc: SendEvent
892 * @tc.type: FUNC
893 * @tc.require: IA4GZ0
894 */
895 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_001, Function | MediumTest | TestSize.Level0)
896 {
897 BundleActiveGroupHandlerObject tmpObject;
898 auto handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
899 auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
900 bundleActiveGroupHandler->SendEvent(0, handlerObject);
901 EXPECT_EQ(bundleActiveGroupHandler->taskHandlerMap_.size(), 0);
902 bundleActiveGroupHandler->SendCheckBundleMsg(0, handlerObject);
903 EXPECT_EQ(bundleActiveGroupHandler->checkBundleTaskMap_.size(), 0);
904 }
905
906 /*
907 * @tc.name: BundleActiveGroupHandler_002
908 * @tc.desc: SendEvent
909 * @tc.type: FUNC
910 * @tc.require: IA4GZ0
911 */
912 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_002, Function | MediumTest | TestSize.Level0)
913 {
914 BundleActiveGroupHandlerObject tmpObject;
915 auto handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
916 auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
917 bundleActiveGroupHandler->Init();
918 bundleActiveGroupHandler->SendEvent(0, handlerObject);
919 bundleActiveGroupHandler->SendEvent(0, handlerObject, 10);
920 EXPECT_NE(bundleActiveGroupHandler->taskHandlerMap_.size(), 0);
921 bundleActiveGroupHandler->RemoveEvent(0);
922 bundleActiveGroupHandler->RemoveEvent(0);
923 EXPECT_EQ(bundleActiveGroupHandler->taskHandlerMap_.size(), 0);
924 }
925
926 /*
927 * @tc.name: BundleActiveGroupHandler_003
928 * @tc.desc: SendCheckBundleMsg
929 * @tc.type: FUNC
930 * @tc.require: IA4GZ0
931 */
932 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_003, Function | MediumTest | TestSize.Level0)
933 {
934 BundleActiveGroupHandlerObject tmpObject;
935 tmpObject.bundleName_ = "test";
936 tmpObject.uid_ = 10000;
937 tmpObject.userId_ = 100;
938 auto handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
939 auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
940 bundleActiveGroupHandler->Init();
941 bundleActiveGroupHandler->SendCheckBundleMsg(0, handlerObject);
942 bundleActiveGroupHandler->SendCheckBundleMsg(0, handlerObject, 10);
943 auto msgKey = bundleActiveGroupHandler->GetMsgKey(0, handlerObject, 10);
944 EXPECT_NE(bundleActiveGroupHandler->checkBundleTaskMap_.size(), 0);
945 bundleActiveGroupHandler->RemoveCheckBundleMsg(msgKey);
946 bundleActiveGroupHandler->RemoveCheckBundleMsg(msgKey);
947 msgKey = bundleActiveGroupHandler->GetMsgKey(0, handlerObject, 0);
948 bundleActiveGroupHandler->RemoveCheckBundleMsg(msgKey);
949 EXPECT_EQ(bundleActiveGroupHandler->checkBundleTaskMap_.size(), 0);
950 }
951
952 /*
953 * @tc.name: BundleActiveGroupHandler_004
954 * @tc.desc: GetMsgKey
955 * @tc.type: FUNC
956 * @tc.require: IA4GZ0
957 */
958 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_004, Function | MediumTest | TestSize.Level0)
959 {
960 BundleActiveGroupHandlerObject tmpObject;
961 tmpObject.bundleName_ = "test";
962 tmpObject.uid_ = 10000;
963 tmpObject.userId_ = 100;
964 auto handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
965 auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
966 auto msgkey = bundleActiveGroupHandler->GetMsgKey(0, nullptr, 10);
967 EXPECT_EQ(msgkey, "");
968 msgkey = bundleActiveGroupHandler->GetMsgKey(0, handlerObject, 10);
969 EXPECT_NE(msgkey, "");
970 }
971
972 /*
973 * @tc.name: BundleActiveGroupHandler_005
974 * @tc.desc: PostTask
975 * @tc.type: FUNC
976 * @tc.require: IA4GZ0
977 */
978 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_005, Function | MediumTest | TestSize.Level0)
979 {
980 BundleActiveGroupHandlerObject tmpObject;
981 auto handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
982 auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
__anon7bc572400102() 983 bundleActiveGroupHandler->PostTask([]() {
984 SUCCEED();
985 });
__anon7bc572400202() 986 bundleActiveGroupHandler->PostSyncTask([]() {
987 SUCCEED();
988 });
989 bundleActiveGroupHandler->Init();
990 EXPECT_TRUE(bundleActiveGroupHandler->isInited_);
__anon7bc572400302() 991 bundleActiveGroupHandler->PostTask([]() {
992 SUCCEED();
993 });
__anon7bc572400402() 994 bundleActiveGroupHandler->PostSyncTask([]() {
995 SUCCEED();
996 });
997 }
998
999 /*
1000 * @tc.name: BundleActiveGroupHandler_006
1001 * @tc.desc: PostTask
1002 * @tc.type: FUNC
1003 * @tc.require: IA4GZ0
1004 */
1005 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_006, Function | MediumTest | TestSize.Level0)
1006 {
1007 auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
1008
1009 bundleActiveGroupHandler->Init();
1010 int32_t eventId = 0;
1011 std::shared_ptr<BundleActiveGroupHandlerObject> tmpObject = nullptr;
1012 bundleActiveGroupHandler->SendCheckBundleMsg(eventId, tmpObject, 0);
1013 EXPECT_TRUE(bundleActiveGroupHandler->isInited_);
1014 }
1015
1016 /*
1017 * @tc.name: BundleActiveGroupHandler_007
1018 * @tc.desc: PostTask
1019 * @tc.type: FUNC
1020 * @tc.require: IA4GZ0
1021 */
1022 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_007, Function | MediumTest | TestSize.Level0)
1023 {
1024 auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
1025 bundleActiveGroupHandler->DeInit();
1026 EXPECT_FALSE(bundleActiveGroupHandler->isInited_);
1027 }
1028
1029 /*
1030 * @tc.name: BundleActiveGroupHandler_008
1031 * @tc.desc: PostTask
1032 * @tc.type: FUNC
1033 * @tc.require: IA4GZ0
1034 */
1035 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_008, Function | MediumTest | TestSize.Level0)
1036 {
1037 auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
1038 int32_t eventId = 0;
1039 bundleActiveGroupHandler->RemoveEvent(eventId);
1040 EXPECT_FALSE(bundleActiveGroupHandler->isInited_);
1041 }
1042
1043 /*
1044 * @tc.name: BundleActiveGroupHandler_009
1045 * @tc.desc: PostTask
1046 * @tc.type: FUNC
1047 * @tc.require: IA4GZ0
1048 */
1049 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_009, Function | MediumTest | TestSize.Level0)
1050 {
1051 auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
1052 bundleActiveGroupHandler->Init();
1053 int32_t eventId = 0;
1054 std::shared_ptr<BundleActiveGroupHandlerObject> tmpObject = nullptr;
1055 bundleActiveGroupHandler->ProcessEvent(eventId, tmpObject);
1056 EXPECT_TRUE(bundleActiveGroupHandler->isInited_);
1057 }
1058
1059 /*
1060 * @tc.name: BundleActiveGroupHandler_010
1061 * @tc.desc: PostTask
1062 * @tc.type: FUNC
1063 * @tc.require: IA4GZ0
1064 */
1065 HWTEST_F(PackageUsageTest, BundleActiveGroupHandler_010, Function | MediumTest | TestSize.Level0)
1066 {
1067 auto bundleActiveGroupHandler = std::make_shared<BundleActiveGroupHandler>(true);
1068 bundleActiveGroupHandler->Init();
1069 int32_t eventId = 2;
1070 std::shared_ptr<BundleActiveGroupHandlerObject> handlerObject = nullptr;
1071 bundleActiveGroupHandler->ProcessEvent(eventId, handlerObject);
1072 BundleActiveGroupHandlerObject tmpObject;
1073 handlerObject = std::make_shared<BundleActiveGroupHandlerObject>(tmpObject);
1074 bundleActiveGroupHandler->ProcessEvent(eventId, handlerObject);
1075 eventId = 100;
1076 bundleActiveGroupHandler->ProcessEvent(eventId, handlerObject);
1077 EXPECT_TRUE(bundleActiveGroupHandler->isInited_);
1078 }
1079
1080 /*
1081 * @tc.name: BundleActivePackageStats_001
1082 * @tc.desc: END_OF_THE_DAY
1083 * @tc.type: FUNC
1084 * @tc.require: IA4GZ0
1085 */
1086 HWTEST_F(PackageUsageTest, BundleActivePackageStats_001, Function | MediumTest | TestSize.Level0)
1087 {
1088 auto packageStats = std::make_shared<BundleActivePackageStats>();
1089 std::string taskName = "test";
1090 int64_t timeStamp = 0;
1091 int32_t eventId = BundleActiveEvent::END_OF_THE_DAY;
1092 std::string abilityId = "1";
1093 int32_t uid = 0;
1094 packageStats->Update("test", timeStamp, eventId, abilityId, uid);
1095 packageStats->lastTimeUsed_ = 0;
1096 packageStats->totalInFrontTime_ = 0;
1097 timeStamp = 1000;
1098 packageStats->abilities_["test"] = BundleActiveEvent::ABILITY_FOREGROUND;
1099 packageStats->longTimeTasks_["test"] = BundleActiveEvent::ABILITY_FOREGROUND;
1100 packageStats->Update("test", timeStamp, eventId, abilityId, uid);
1101 EXPECT_EQ(packageStats->totalInFrontTime_, timeStamp);
1102 }
1103
1104 /*
1105 * @tc.name: BundleActivePackageStats_002
1106 * @tc.desc: FLUSH
1107 * @tc.type: FUNC
1108 * @tc.require: IA4GZ0
1109 */
1110 HWTEST_F(PackageUsageTest, BundleActivePackageStats_002, Function | MediumTest | TestSize.Level0)
1111 {
1112 auto packageStats = std::make_shared<BundleActivePackageStats>();
1113 std::string taskName = "test";
1114 int64_t timeStamp = 0;
1115 int32_t eventId = BundleActiveEvent::FLUSH;
1116 std::string abilityId = "1";
1117 int32_t uid = 0;
1118 packageStats->Update("test", timeStamp, eventId, abilityId, uid);
1119 packageStats->lastTimeUsed_ = 0;
1120 packageStats->totalInFrontTime_ = 0;
1121 timeStamp = 1000;
1122 packageStats->abilities_["test"] = BundleActiveEvent::ABILITY_FOREGROUND;
1123 packageStats->longTimeTasks_["test"] = BundleActiveEvent::ABILITY_FOREGROUND;
1124 packageStats->Update("test", timeStamp, eventId, abilityId, uid);
1125 EXPECT_EQ(packageStats->totalInFrontTime_, timeStamp);
1126 }
1127
1128 /*
1129 * @tc.name: BundleActivePackageStats_003
1130 * @tc.desc: Marshalling
1131 * @tc.type: FUNC
1132 * @tc.require: IA4GZ0
1133 */
1134 HWTEST_F(PackageUsageTest, BundleActivePackageStats_003, Function | MediumTest | TestSize.Level0)
1135 {
1136 MessageParcel reply;
1137 auto packageStats = std::make_shared<BundleActivePackageStats>();
1138 bool result = packageStats->Marshalling(reply);
1139 EXPECT_TRUE(result);
1140 }
1141
1142 /*
1143 * @tc.name: BundleActivePackageStats_004
1144 * @tc.desc: UpdateAbility
1145 * @tc.type: FUNC
1146 * @tc.require: IA4GZ0
1147 */
1148 HWTEST_F(PackageUsageTest, BundleActivePackageStats_004, Function | MediumTest | TestSize.Level0)
1149 {
1150 MessageParcel reply;
1151 auto packageStats = std::make_shared<BundleActivePackageStats>();
1152 int64_t timeStamp = 0;
1153 int32_t eventId = BundleActiveEvent::ABILITY_FOREGROUND;
1154 std::string abilityId = "1";
1155 packageStats->abilities_[abilityId] = BundleActiveEvent::ABILITY_STOP;
1156 packageStats->UpdateAbility(timeStamp, eventId, abilityId);
1157 packageStats->abilities_[abilityId] = BundleActiveEvent::ABILITY_BACKGROUND;
1158 packageStats->UpdateAbility(timeStamp, eventId, abilityId);
1159 int32_t startCount = packageStats->startCount_;
1160 EXPECT_TRUE(startCount > 0);
1161 }
1162
1163 /*
1164 * @tc.name: BundleActivePackageStats_005
1165 * @tc.desc: UpdateLongTimeTask
1166 * @tc.type: FUNC
1167 * @tc.require: IA4GZ0
1168 */
1169 HWTEST_F(PackageUsageTest, BundleActivePackageStats_005, Function | MediumTest | TestSize.Level0)
1170 {
1171 auto packageStats = std::make_shared<BundleActivePackageStats>();
1172 std::string taskName = "test";
1173 int64_t timeStamp = 100;
1174 int32_t eventId = BundleActiveEvent::LONG_TIME_TASK_ENDED;
1175 packageStats->totalContiniousTaskUsedTime_ = 0;
1176 packageStats->longTimeTasks_[taskName] = BundleActiveEvent::LONG_TIME_TASK_STARTTED;
1177 packageStats->UpdateLongTimeTask(taskName, timeStamp, eventId);
1178 EXPECT_NE(packageStats->totalContiniousTaskUsedTime_, 0);
1179 }
1180
1181 /*
1182 * @tc.name: BundleActiveCalendar_001
1183 * @tc.desc: BundleActiveCalendar
1184 * @tc.type: FUNC
1185 * @tc.require: IAHDJW
1186 */
1187 HWTEST_F(PackageUsageTest, BundleActiveCalendar_001, Function | MediumTest | TestSize.Level0)
1188 {
1189 int64_t nowTime = BundleActiveUtil::GetSystemTimeMs();
1190 BundleActiveCalendar testCalendar(nowTime);
1191 testCalendar.TruncateToDay();
1192 EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1193 BundleActiveCalendar testCalendar2(nowTime);
1194 testCalendar.TruncateToWeek();
1195 EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1196 BundleActiveCalendar testCalendar3(nowTime);
1197 testCalendar.TruncateToMonth();
1198 EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1199 BundleActiveCalendar testCalendar4(nowTime);
1200 testCalendar.TruncateToYear();
1201 EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1202 }
1203
1204 /*
1205 * @tc.name: BundleActiveCalendar_002
1206 * @tc.desc: BundleActiveCalendar debug
1207 * @tc.type: FUNC
1208 * @tc.require: IAHDJW
1209 */
1210 HWTEST_F(PackageUsageTest, BundleActiveCalendar_002, Function | MediumTest | TestSize.Level0)
1211 {
1212 int64_t nowTime = BundleActiveUtil::GetSystemTimeMs();
1213 BundleActiveCalendar testCalendar(nowTime);
1214 testCalendar.ChangeToDebug();
1215 testCalendar.TruncateToDay();
1216 EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1217 BundleActiveCalendar testCalendar2(nowTime);
1218 testCalendar.ChangeToDebug();
1219 testCalendar.TruncateToWeek();
1220 EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1221 BundleActiveCalendar testCalendar3(nowTime);
1222 testCalendar.ChangeToDebug();
1223 testCalendar.TruncateToMonth();
1224 EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1225 BundleActiveCalendar testCalendar4(nowTime);
1226 testCalendar.ChangeToDebug();
1227 testCalendar.TruncateToYear();
1228 EXPECT_TRUE(nowTime - testCalendar.GetMilliseconds() >= 0);
1229 }
1230
1231 } // namespace DeviceUsageStats
1232 } // namespace OHOS