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