1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #define private public
17 #define protected public
18
19 #include <string>
20
21 #include <gtest/gtest.h>
22 #include "system_ability_definition.h"
23
24 #include "bundle_active_service.h"
25 #include "bundle_active_user_service.h"
26 #include "bundle_active_event.h"
27 #include "app_group_callback_stub.h"
28 #include "app_group_callback_info.h"
29 #include "bundle_active_usage_database.h"
30 #include "bundle_active_user_history.h"
31 #include "bundle_active_group_controller.h"
32
33 using namespace testing::ext;
34
35 namespace OHOS {
36 namespace DeviceUsageStats {
37 class DeviceUsageStatisticsServiceTest : public testing::Test {
38 public:
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43 };
44
SetUpTestCase(void)45 void DeviceUsageStatisticsServiceTest::SetUpTestCase(void)
46 {
47 }
48
TearDownTestCase(void)49 void DeviceUsageStatisticsServiceTest::TearDownTestCase(void)
50 {
51 }
52
SetUp(void)53 void DeviceUsageStatisticsServiceTest::SetUp(void)
54 {
55 }
56
TearDown(void)57 void DeviceUsageStatisticsServiceTest::TearDown(void)
58 {
59 }
60
61 class TestServiceAppGroupChangeCallback : public AppGroupCallbackStub {
62 public:
63 void OnAppGroupChanged(const AppGroupCallbackInfo &appGroupCallbackInfo) override;
64 };
65
OnAppGroupChanged(const AppGroupCallbackInfo & appGroupCallbackInfo)66 void TestServiceAppGroupChangeCallback::OnAppGroupChanged(const AppGroupCallbackInfo &appGroupCallbackInfo)
67 {
68 BUNDLE_ACTIVE_LOGI("TestServiceAppGroupChangeCallback::OnAppGroupChanged!");
69 }
70
71 /*
72 * @tc.name: DeviceUsageStatisticsServiceTest_GetServiceObject_001
73 * @tc.desc: get service object
74 * @tc.type: FUNC
75 * @tc.require: issuesI5SOZY
76 */
77 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetServiceObject_001,
78 Function | MediumTest | Level0)
79 {
80 sptr<ISystemAbilityManager> systemAbilityManager =
81 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
82 EXPECT_NE(systemAbilityManager, nullptr);
83
84 sptr<IRemoteObject> remoteObject =
85 systemAbilityManager->GetSystemAbility(DEVICE_USAGE_STATISTICS_SYS_ABILITY_ID);
86 EXPECT_NE(remoteObject, nullptr);
87 }
88
89 /*
90 * @tc.name: DeviceUsageStatisticsServiceTest_dump_001
91 * @tc.desc: test dump
92 * @tc.type: FUNC
93 * @tc.require: issuesI5SOZY
94 */
95 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_dump_001, Function | MediumTest | Level0)
96 {
97 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_ = std::make_shared<BundleActiveCore>();
98 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_->Init();
99 BUNDLE_ACTIVE_LOGI("DeviceUsageStatisticsServiceTest create BundleActiveService!");
100
101 std::vector<std::string> dumpOption{"-A", "Events"};
102 std::vector<std::string> dumpInfo;
103 DelayedSingleton<BundleActiveService>::GetInstance()->ShellDump(dumpOption, dumpInfo);
104
105 dumpOption.clear();
106 dumpInfo.clear();
107 dumpOption = {"-A", "Events", "0", "20000000000000", "100"};
108 DelayedSingleton<BundleActiveService>::GetInstance()->ShellDump(dumpOption, dumpInfo);
109
110 dumpOption.clear();
111 dumpInfo.clear();
112 dumpOption = {"-A", "PackageUsage"};
113 DelayedSingleton<BundleActiveService>::GetInstance()->ShellDump(dumpOption, dumpInfo);
114
115 dumpOption.clear();
116 dumpInfo.clear();
117 dumpOption = {"-A", "PackageUsage", "1", "0", "20000000000000", "100"};
118 DelayedSingleton<BundleActiveService>::GetInstance()->ShellDump(dumpOption, dumpInfo);
119
120 dumpOption.clear();
121 dumpInfo.clear();
122 dumpOption = {"-A", "ModuleUsage"};
123 DelayedSingleton<BundleActiveService>::GetInstance()->ShellDump(dumpOption, dumpInfo);
124
125 dumpOption.clear();
126 dumpInfo.clear();
127 dumpOption = {"-A", "ModuleUsage", "1", "100"};
128 DelayedSingleton<BundleActiveService>::GetInstance()->ShellDump(dumpOption, dumpInfo);
129
130 std::vector<std::u16string> args;
131 DelayedSingleton<BundleActiveService>::GetInstance()->Dump(-1, args);
132
133 args.clear();
134 args = {to_utf16("-h")};
135 DelayedSingleton<BundleActiveService>::GetInstance()->Dump(-1, args);
136
137 args.clear();
138 args = {to_utf16("-A")};
139 DelayedSingleton<BundleActiveService>::GetInstance()->Dump(-1, args);
140
141 args.clear();
142 args = {to_utf16("-D")};
143 DelayedSingleton<BundleActiveService>::GetInstance()->Dump(-1, args);
144 }
145
146 /*
147 * @tc.name: DeviceUsageStatisticsServiceTest_QueryModuleUsageRecords_001
148 * @tc.desc: QueryModuleUsageRecords
149 * @tc.type: FUNC
150 * @tc.require: issuesI5SOZY
151 */
152 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryModuleUsageRecords_001,
153 Function | MediumTest | Level0)
154 {
155 std::vector<BundleActiveModuleRecord> results;
156 int32_t maxNum = 0;
157 ErrCode code = DelayedSingleton<BundleActiveService>::GetInstance()->QueryModuleUsageRecords(maxNum, results, 100);
158 EXPECT_NE(code, 0);
159
160 maxNum = 1001;
161 code = DelayedSingleton<BundleActiveService>::GetInstance()->QueryModuleUsageRecords(maxNum, results, 100);
162 EXPECT_NE(code, 0);
163 }
164
165 /*
166 * @tc.name: DeviceUsageStatisticsServiceTest_AppGroupCallback_001
167 * @tc.desc: AppGroupCallback
168 * @tc.type: FUNC
169 * @tc.require: issuesI5SOZY
170 */
171 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_AppGroupCallback_001,
172 Function | MediumTest | Level0)
173 {
174 BUNDLE_ACTIVE_LOGI("DeviceUsageStatisticsServiceTest create BundleActiveService!");
175 sptr<TestServiceAppGroupChangeCallback> observer = new (std::nothrow) TestServiceAppGroupChangeCallback();
176 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_ = std::make_shared<BundleActiveCore>();
177 EXPECT_EQ(DelayedSingleton<BundleActiveService>::GetInstance()->RegisterAppGroupCallBack(observer), ERR_OK);
178 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->RegisterAppGroupCallBack(observer), ERR_OK);
179 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_->AddObserverDeathRecipient(observer);
180
181 EXPECT_EQ(DelayedSingleton<BundleActiveService>::GetInstance()->UnRegisterAppGroupCallBack(observer), ERR_OK);
182 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->UnRegisterAppGroupCallBack(observer), ERR_OK);
183
184 observer = nullptr;
185 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->RegisterAppGroupCallBack(observer), ERR_OK);
186
187 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_->AddObserverDeathRecipient(observer);
188 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_->RemoveObserverDeathRecipient(observer);
189
190 wptr<IRemoteObject> remote = nullptr;
191 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_->OnObserverDied(remote);
192 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_->OnObserverDiedInner(remote);
193 }
194
195 /*
196 * @tc.name: DeviceUsageStatisticsServiceTest_OnUserRemoved_001
197 * @tc.desc: OnUserRemoved
198 * @tc.type: FUNC
199 * @tc.require: issuesI5SOZY
200 */
201 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_OnUserRemoved_001,
202 Function | MediumTest | Level0)
203 {
204 int userId = 100;
205 auto coreObject = std::make_shared<BundleActiveCore>();
206 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(coreObject->debugCore_);
207 coreObject->InitBundleGroupController();
208 coreObject->RestoreToDatabase(userId);
209 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
210 coreObject->userStatServices_[userId] = userService;
211
212 BundleActiveEvent event;
213 coreObject->ReportEventToAllUserId(event);
214 coreObject->currentUsedUser_ = userId;
215 coreObject->OnUserRemoved(userId);
216 coreObject->OnUserSwitched(userId);
217 EXPECT_NE(coreObject, nullptr);
218 }
219
220 /*
221 * @tc.name: DeviceUsageStatisticsServiceTest_RestoreAllData_001
222 * @tc.desc: RestoreAllData
223 * @tc.type: FUNC
224 * @tc.require: issuesI5SOZY
225 */
226 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RestoreAllData_001,
227 Function | MediumTest | Level0)
228 {
229 auto coreObject = std::make_shared<BundleActiveCore>();
230 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(coreObject->debugCore_);
231 coreObject->InitBundleGroupController();
232
233 int userId = 100;
234 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
235 int64_t timeStamp = 20000000000000;
236 userService->Init(timeStamp);
237 coreObject->userStatServices_[userId] = userService;
238 userId = 101;
239 coreObject->userStatServices_[userId] = nullptr;
240 coreObject->RestoreAllData();
241
242 BundleActiveEvent event;
243 coreObject->ReportEventToAllUserId(event);
244 EXPECT_NE(coreObject, nullptr);
245 }
246
247 /*
248 * @tc.name: DeviceUsageStatisticsServiceTest_ObtainSystemEventName_001
249 * @tc.desc: ObtainSystemEventName
250 * @tc.type: FUNC
251 * @tc.require: issuesI5SOZY
252 */
253 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ObtainSystemEventName_001,
254 Function | MediumTest | Level0)
255 {
256 auto coreObject = std::make_shared<BundleActiveCore>();
257 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(coreObject->debugCore_);
258 BundleActiveEvent event;
259 event.eventId_ = BundleActiveEvent::SYSTEM_LOCK;
260 coreObject->ObtainSystemEventName(event);
261
262 event.eventId_ = BundleActiveEvent::SYSTEM_UNLOCK;
263 coreObject->ObtainSystemEventName(event);
264
265 event.eventId_ = BundleActiveEvent::SYSTEM_SLEEP;
266 coreObject->ObtainSystemEventName(event);
267
268 event.eventId_ = BundleActiveEvent::SYSTEM_WAKEUP;
269 coreObject->ObtainSystemEventName(event);
270 EXPECT_NE(coreObject, nullptr);
271 }
272
273 /*
274 * @tc.name: DeviceUsageStatisticsServiceTest_JudgeQueryCondition_001
275 * @tc.desc: JudgeQueryCondition
276 * @tc.type: FUNC
277 * @tc.require: issuesI5SOZY
278 */
279 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_JudgeQueryCondition_001,
280 Function | MediumTest | Level0)
281 {
282 auto database = std::make_shared<BundleActiveUsageDatabase>();
283 int64_t beginTime = 0;
284 int64_t endTime = 0;
285 int64_t eventTableTime = 0;
286 database->eventTableName_ = "defaultTableName";
287 EXPECT_EQ(database->JudgeQueryCondition(beginTime, endTime, eventTableTime), QUERY_CONDITION_INVALID);
288
289 endTime = 10;
290 eventTableTime = 11;
291 EXPECT_EQ(database->JudgeQueryCondition(beginTime, endTime, eventTableTime), QUERY_CONDITION_INVALID);
292 }
293
294 /*
295 * @tc.name: DeviceUsageStatisticsServiceTest_GetSystemEventName_001
296 * @tc.desc: GetSystemEventName
297 * @tc.type: FUNC
298 * @tc.require: issuesI5SOZY
299 */
300 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetSystemEventName_001,
301 Function | MediumTest | Level0)
302 {
303 auto database = std::make_shared<BundleActiveUsageDatabase>();
304 int32_t userId = BundleActiveEvent::SYSTEM_LOCK;
305 EXPECT_EQ(database->GetSystemEventName(userId), "SYSTEM_LOCK");
306
307 userId = BundleActiveEvent::SYSTEM_UNLOCK;
308 EXPECT_EQ(database->GetSystemEventName(userId), "SYSTEM_UNLOCK");
309
310 userId = BundleActiveEvent::SYSTEM_SLEEP;
311 EXPECT_EQ(database->GetSystemEventName(userId), "SYSTEM_SLEEP");
312
313 userId = BundleActiveEvent::SYSTEM_WAKEUP;
314 EXPECT_EQ(database->GetSystemEventName(userId), "SYSTEM_WAKEUP");
315
316 userId = BundleActiveEvent::ABILITY_FOREGROUND;
317 EXPECT_EQ(database->GetSystemEventName(userId), "");
318 }
319
320 /*
321 * @tc.name: DeviceUsageStatisticsServiceTest_GetOverdueTableCreateTime_001
322 * @tc.desc: GetOverdueTableCreateTime
323 * @tc.type: FUNC
324 * @tc.require: issuesI5SOZY
325 */
326 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetOverdueTableCreateTime_001,
327 Function | MediumTest | Level0)
328 {
329 auto database = std::make_shared<BundleActiveUsageDatabase>();
330 uint32_t databaseType = 4;
331 int64_t currentTimeMillis = 20000000000000;
332 database->GetOverdueTableCreateTime(databaseType, currentTimeMillis);
333
334 databaseType = 0;
335 database->GetOverdueTableCreateTime(databaseType, currentTimeMillis);
336 EXPECT_NE(database, nullptr);
337 }
338
339 /*
340 * @tc.name: DeviceUsageStatisticsServiceTest_DeleteInvalidTable_001
341 * @tc.desc: DeleteInvalidTable
342 * @tc.type: FUNC
343 * @tc.require: issuesI5SOZY
344 */
345 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_DeleteInvalidTable_001,
346 Function | MediumTest | Level0)
347 {
348 auto database = std::make_shared<BundleActiveUsageDatabase>();
349 uint32_t databaseType = 4;
350 int64_t currentTimeMillis = 20000000000000;
351 database->DeleteInvalidTable(databaseType, currentTimeMillis);
352
353 databaseType = 0;
354 database->DeleteInvalidTable(databaseType, currentTimeMillis);
355 EXPECT_NE(database, nullptr);
356 }
357
358 /*
359 * @tc.name: DeviceUsageStatisticsServiceTest_CreatePackageLogTable_001
360 * @tc.desc: CreatePackageLogTable
361 * @tc.type: FUNC
362 * @tc.require: issuesI5SOZY
363 */
364 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CreatePackageLogTable_001,
365 Function | MediumTest | Level0)
366 {
367 auto database = std::make_shared<BundleActiveUsageDatabase>();
368 uint32_t databaseType = 0;
369 int64_t currentTimeMillis = 20000000000000;
370 database->CreatePackageLogTable(databaseType, currentTimeMillis);
371 EXPECT_NE(database, nullptr);
372 }
373
374 /*
375 * @tc.name: DeviceUsageStatisticsServiceTest_CreateModuleRecordTable_001
376 * @tc.desc: CreateModuleRecordTable
377 * @tc.type: FUNC
378 * @tc.require: issuesI5SOZY
379 */
380 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CreateModuleRecordTable_001,
381 Function | MediumTest | Level0)
382 {
383 auto database = std::make_shared<BundleActiveUsageDatabase>();
384 uint32_t databaseType = 0;
385 int64_t currentTimeMillis = 20000000000000;
386 database->CreateModuleRecordTable(databaseType, currentTimeMillis);
387 EXPECT_NE(database, nullptr);
388 }
389
390 /*
391 * @tc.name: DeviceUsageStatisticsServiceTest_CreateFormRecordTable_001
392 * @tc.desc: CreateFormRecordTable
393 * @tc.type: FUNC
394 * @tc.require: issuesI5SOZY
395 */
396 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CreateFormRecordTable_001,
397 Function | MediumTest | Level0)
398 {
399 auto database = std::make_shared<BundleActiveUsageDatabase>();
400 uint32_t databaseType = 0;
401 int64_t currentTimeMillis = 20000000000000;
402 database->CreateFormRecordTable(databaseType, currentTimeMillis);
403 EXPECT_NE(database, nullptr);
404 }
405
406 /*
407 * @tc.name: DeviceUsageStatisticsServiceTest_CreateDurationTable_001
408 * @tc.desc: CreateDurationTable
409 * @tc.type: FUNC
410 * @tc.require: issuesI5SOZY
411 */
412 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CreateDurationTable_001,
413 Function | MediumTest | Level0)
414 {
415 auto database = std::make_shared<BundleActiveUsageDatabase>();
416 int32_t databaseType = DAILY_DATABASE_INDEX;
417 bool forModuleRecords = true;
418 database->InitUsageGroupDatabase(databaseType, forModuleRecords);
419 EXPECT_NE(database, nullptr);
420 }
421
422 /*
423 * @tc.name: DeviceUsageStatisticsServiceTest_CreateBundleHistoryTable_001
424 * @tc.desc: CreateBundleHistoryTable
425 * @tc.type: FUNC
426 * @tc.require: issuesI5SOZY
427 */
428 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CreateBundleHistoryTable_001,
429 Function | MediumTest | Level0)
430 {
431 auto database = std::make_shared<BundleActiveUsageDatabase>();
432 uint32_t databaseType = 0;
433 database->CreateBundleHistoryTable(databaseType);
434 EXPECT_NE(database, nullptr);
435 }
436
437 /*
438 * @tc.name: DeviceUsageStatisticsServiceTest_PutBundleHistoryData_001
439 * @tc.desc: PutBundleHistoryData
440 * @tc.type: FUNC
441 * @tc.require: issuesI5SOZY
442 */
443 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_PutBundleHistoryData_001,
444 Function | MediumTest | Level0)
445 {
446 auto database = std::make_shared<BundleActiveUsageDatabase>();
447 int32_t userId = 100;
448 std::shared_ptr<std::map<std::string, std::shared_ptr<BundleActivePackageHistory>>> userHistory = nullptr;
449 database->PutBundleHistoryData(userId, userHistory);
450
451 userHistory = std::make_shared<std::map<string, std::shared_ptr<BundleActivePackageHistory>>>();
452 userHistory->emplace("defaultTest", std::make_shared<BundleActivePackageHistory>());
453 database->PutBundleHistoryData(userId, userHistory);
454 database->PutBundleHistoryData(userId, userHistory);
455 EXPECT_NE(database, nullptr);
456 }
457
458 /*
459 * @tc.name: DeviceUsageStatisticsServiceTest_GetBundleHistoryData_001
460 * @tc.desc: GetBundleHistoryData
461 * @tc.type: FUNC
462 * @tc.require: issuesI5SOZY
463 */
464 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetBundleHistoryData_001,
465 Function | MediumTest | Level0)
466 {
467 auto database = std::make_shared<BundleActiveUsageDatabase>();
468 int32_t userId = 100;
469 database->GetBundleHistoryData(userId);
470 EXPECT_NE(database, nullptr);
471 }
472
473 /*
474 * @tc.name: DeviceUsageStatisticsServiceTest_FlushPackageInfo_001
475 * @tc.desc: FlushPackageInfo
476 * @tc.type: FUNC
477 * @tc.require: issuesI5SOZY
478 */
479 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_FlushPackageInfo_001,
480 Function | MediumTest | Level0)
481 {
482 auto database = std::make_shared<BundleActiveUsageDatabase>();
483 uint32_t databaseType = 0;
484 BundleActivePeriodStats stats;
485 stats.bundleStats_.emplace("defaultTest", std::make_shared<BundleActivePackageStats>());
486 database->FlushPackageInfo(databaseType, stats);
487 EXPECT_NE(database, nullptr);
488 }
489
490 /*
491 * @tc.name: DeviceUsageStatisticsServiceTest_GetCurrentUsageData_001
492 * @tc.desc: GetCurrentUsageData
493 * @tc.type: FUNC
494 * @tc.require: issuesI5SOZY
495 */
496 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetCurrentUsageData_001,
497 Function | MediumTest | Level0)
498 {
499 auto database = std::make_shared<BundleActiveUsageDatabase>();
500 int32_t databaseType = -1;
501 int32_t userId = 100;
502 database->GetCurrentUsageData(databaseType, userId);
503
504 databaseType = 4;
505 database->GetCurrentUsageData(databaseType, userId);
506
507 databaseType = 0;
508 database->GetCurrentUsageData(databaseType, userId);
509 EXPECT_NE(database, nullptr);
510 }
511
512 /*
513 * @tc.name: DeviceUsageStatisticsServiceTest_GetTableIndexSql_001
514 * @tc.desc: GetTableIndexSql
515 * @tc.type: FUNC
516 * @tc.require: issuesI5SOZY
517 */
518 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetTableIndexSql_001,
519 Function | MediumTest | Level0)
520 {
521 auto database = std::make_shared<BundleActiveUsageDatabase>();
522 uint32_t databaseType = 0;
523 int64_t tableTime = 20000000000000;
524 bool createFlag = false;
525 int32_t indexFlag = 0;
526 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
527
528 createFlag = true;
529 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
530
531 databaseType = 4;
532 createFlag = false;
533 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
534
535 databaseType = 5;
536 createFlag = false;
537 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
538 indexFlag = BUNDLE_ACTIVE_DB_INDEX_MODULE;
539 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
540
541 createFlag = true;
542 indexFlag = BUNDLE_ACTIVE_DB_INDEX_NORMAL;
543 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
544
545 indexFlag = BUNDLE_ACTIVE_DB_INDEX_MODULE;
546 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
547 EXPECT_NE(database, nullptr);
548 }
549
550 /*
551 * @tc.name: DeviceUsageStatisticsServiceTest_RenameTableName_001
552 * @tc.desc: RenameTableName
553 * @tc.type: FUNC
554 * @tc.require: issuesI5SOZY
555 */
556 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RenameTableName_001,
557 Function | MediumTest | Level0)
558 {
559 auto database = std::make_shared<BundleActiveUsageDatabase>();
560 uint32_t databaseType = 0;
561 int64_t tableOldTime = 0;
562 int64_t tableNewTime = 20000000000000;
563 database->RenameTableName(databaseType, tableOldTime, tableNewTime);
564
565 databaseType = 4;
566 database->RenameTableName(databaseType, tableOldTime, tableNewTime);
567
568 databaseType = 5;
569 database->RenameTableName(databaseType, tableOldTime, tableNewTime);
570 EXPECT_NE(database, nullptr);
571 }
572
573 /*
574 * @tc.name: DeviceUsageStatisticsServiceTest_RemoveOldData_001
575 * @tc.desc: RemoveOldData
576 * @tc.type: FUNC
577 * @tc.require: issuesI5SOZY
578 */
579 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RemoveOldData_001,
580 Function | MediumTest | Level0)
581 {
582 auto database = std::make_shared<BundleActiveUsageDatabase>();
583 int64_t currentTime = 20000000000000;
584 database->RemoveOldData(currentTime);
585 EXPECT_NE(database, nullptr);
586 }
587
588 /*
589 * @tc.name: DeviceUsageStatisticsServiceTest_QueryDatabaseUsageStats_001
590 * @tc.desc: QueryDatabaseUsageStats
591 * @tc.type: FUNC
592 * @tc.require: issuesI5SOZY
593 */
594 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryDatabaseUsageStats_001,
595 Function | MediumTest | Level0)
596 {
597 auto database = std::make_shared<BundleActiveUsageDatabase>();
598 int32_t databaseType = -1;
599 int64_t beginTime = 0;
600 int64_t endTime = 0;
601 int32_t userId = 100;
602 EXPECT_EQ(database->QueryDatabaseUsageStats(databaseType, beginTime, endTime, userId).size(), 0);
603
604 databaseType = 4;
605 EXPECT_EQ(database->QueryDatabaseUsageStats(databaseType, beginTime, endTime, userId).size(), 0);
606
607 databaseType = 0;
608 EXPECT_EQ(database->QueryDatabaseUsageStats(databaseType, beginTime, endTime, userId).size(), 0);
609
610 databaseType = 0;
611 endTime = 20000000000000;
612 database->QueryDatabaseUsageStats(databaseType, beginTime, endTime, userId);
613 EXPECT_NE(database, nullptr);
614 }
615
616 /*
617 * @tc.name: DeviceUsageStatisticsServiceTest_GetSystemTimeMs_001
618 * @tc.desc: GetSystemTimeMs
619 * @tc.type: FUNC
620 * @tc.require: issuesI5SOZY
621 */
622 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetSystemTimeMs_001,
623 Function | MediumTest | Level0)
624 {
625 auto database = std::make_shared<BundleActiveUsageDatabase>();
626 database->GetSystemTimeMs();
627 EXPECT_NE(database, nullptr);
628 }
629
630 /*
631 * @tc.name: DeviceUsageStatisticsServiceTest_ReportEvent_001
632 * @tc.desc: ReportEvent
633 * @tc.type: FUNC
634 * @tc.require: issuesI5SOZY
635 */
636 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ReportEvent_001,
637 Function | MediumTest | Level0)
638 {
639 auto coreObject = std::make_shared<BundleActiveCore>();
640 coreObject->Init();
641 coreObject->InitBundleGroupController();
642
643 BundleActiveEvent event;
644 int32_t userId = 0;
645 EXPECT_NE(coreObject->ReportEvent(event, userId), ERR_OK);
646
647 userId = 101;
648 event.bundleName_ = "com.ohos.launcher";
649 EXPECT_EQ(coreObject->ReportEvent(event, userId), ERR_OK);
650
651 event.bundleName_ = "com.ohos.settings";
652 event.eventId_ = 15;
653 EXPECT_EQ(coreObject->ReportEvent(event, userId), ERR_OK);
654
655 event.eventId_ = 16;
656 EXPECT_EQ(coreObject->ReportEvent(event, userId), ERR_OK);
657 }
658
659 /*
660 * @tc.name: DeviceUsageStatisticsServiceTest_InitBundleGroupController_001
661 * @tc.desc: InitBundleGroupController
662 * @tc.type: FUNC
663 * @tc.require: issuesI5SOZY
664 */
665 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_InitBundleGroupController_001,
666 Function | MediumTest | Level0)
667 {
668 auto coreObject = std::make_shared<BundleActiveCore>();
669 coreObject->InitBundleGroupController();
670 }
671
672 /*
673 * @tc.name: DeviceUsageStatisticsServiceTest_ReportEventToAllUserId_001
674 * @tc.desc: ReportEventToAllUserId
675 * @tc.type: FUNC
676 * @tc.require: issuesI5SOZY
677 */
678 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ReportEventToAllUserId_001,
679 Function | MediumTest | Level0)
680 {
681 auto coreObject = std::make_shared<BundleActiveCore>();
682 int userId = 100;
683 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
684 coreObject->userStatServices_[userId] = userService;
685 userId = 101;
686 coreObject->userStatServices_[userId] = nullptr;
687 BundleActiveEvent event;
688 coreObject->ReportEventToAllUserId(event);
689
690 coreObject->Init();
691 coreObject->InitBundleGroupController();
692 coreObject->ReportEventToAllUserId(event);
693 EXPECT_NE(coreObject, nullptr);
694 }
695
696 /*
697 * @tc.name: DeviceUsageStatisticsServiceTest_RestoreToDatabase_001
698 * @tc.desc: RestoreToDatabase
699 * @tc.type: FUNC
700 * @tc.require: issuesI5SOZY
701 */
702 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RestoreToDatabase_001,
703 Function | MediumTest | Level0)
704 {
705 auto coreObject = std::make_shared<BundleActiveCore>();
706 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(coreObject->debugCore_);
707 coreObject->InitBundleGroupController();
708
709 int userId = 100;
710 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
711 int64_t timeStamp = 20000000000000;
712 userService->Init(timeStamp);
713 coreObject->userStatServices_[userId] = userService;
714 coreObject->RestoreToDatabase(userId);
715
716 userId = 101;
717 coreObject->RestoreToDatabase(userId);
718 EXPECT_NE(coreObject, nullptr);
719 }
720
721 /*
722 * @tc.name: BundleActiveGroupControllerTest_001
723 * @tc.desc: test the interface
724 * @tc.type: FUNC
725 * @tc.require: DTS2023121404861
726 */
727 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_001,
728 Function | MediumTest | Level0)
729 {
730 auto coreObject = std::make_shared<BundleActiveCore>();
731 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(coreObject->debugCore_);
732 coreObject->InitBundleGroupController();
733
734 int userId = 100;
735 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
736 int64_t timeStamp = 20000000000000;
737 userService->Init(timeStamp);
738 coreObject->userStatServices_[userId] = userService;
739 coreObject->OnUserRemoved(userId);
740 }
741
742 /*
743 * @tc.name: BundleActiveGroupControllerTest_002
744 * @tc.desc: test the interface
745 * @tc.type: FUNC
746 * @tc.require: DTS2023121404861
747 */
748 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_002,
749 Function | MediumTest | Level0)
750 {
751 auto coreObject = std::make_shared<BundleActiveCore>();
752 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(coreObject->debugCore_);
753 coreObject->InitBundleGroupController();
754
755 int userId = 100;
756 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
757 int64_t timeStamp = 20000000000000;
758 userService->Init(timeStamp);
759 coreObject->userStatServices_[userId] = userService;
760 coreObject->bundleGroupController_->OnUserSwitched(userId, userId);
761 }
762
763 /*
764 * @tc.name: BundleActiveGroupControllerTest_003
765 * @tc.desc: test the interface
766 * @tc.type: FUNC
767 * @tc.require: DTS2023121404861
768 */
769 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_003,
770 Function | MediumTest | Level0)
771 {
772 auto coreObject = std::make_shared<BundleActiveCore>();
773 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(true);
774 coreObject->InitBundleGroupController();
775
776 int userId = 100;
777 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
778 int64_t timeStamp = 20000000000000;
779 userService->Init(timeStamp);
780 coreObject->userStatServices_[userId] = userService;
781 coreObject->bundleGroupController_->GetNewGroup("test", userId, timeStamp);
782 }
783
784 /*
785 * @tc.name: BundleActiveGroupControllerTest_004
786 * @tc.desc: test the interface
787 * @tc.type: FUNC
788 * @tc.require: DTS2023121404861
789 */
790 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_004,
791 Function | MediumTest | Level0)
792 {
793 auto coreObject = std::make_shared<BundleActiveCore>();
794 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(true);
795 coreObject->InitBundleGroupController();
796 int userId = 100;
797 BundleActiveEvent event;
798 int64_t timeStamp = 20000000000000;
799 coreObject->bundleGroupController_->ReportEvent(event, timeStamp, userId);
800 coreObject->bundleGroupController_->ReportEvent(event, timeStamp, 19);
801 coreObject->bundleGroupController_->ReportEvent(event, timeStamp, 7);
802 coreObject->bundleGroupController_->bundleGroupEnable_ = false;
803 coreObject->bundleGroupController_->ReportEvent(event, timeStamp, userId);
804 }
805
806 /*
807 * @tc.name: BundleActiveGroupControllerTest_005
808 * @tc.desc: test the interface
809 * @tc.type: FUNC
810 * @tc.require: DTS2023121404861
811 */
812 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_005,
813 Function | MediumTest | Level0)
814 {
815 auto coreObject = std::make_shared<BundleActiveCore>();
816 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(true);
817 coreObject->InitBundleGroupController();
818 int userId = 100;
819 int64_t timeStamp = 20000000000000;
820 coreObject->bundleGroupController_->CheckAndUpdateGroup("test", userId, timeStamp);
821 }
822
823 /*
824 * @tc.name: BundleActiveGroupControllerTest_006
825 * @tc.desc: test the interface
826 * @tc.type: FUNC
827 * @tc.require: DTS2023121404861
828 */
829 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_006,
830 Function | MediumTest | Level0)
831 {
832 auto coreObject = std::make_shared<BundleActiveCore>();
833 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(true);
834 coreObject->InitBundleGroupController();
835 int userId = 100;
836 int64_t timeStamp = 20000000000000;
837 coreObject->bundleGroupController_->SetAppGroup("test", userId, 0, 0, timeStamp, true);
838 coreObject->bundleGroupController_->SetAppGroup("test", userId, 0, 0, timeStamp, false);
839 }
840
841 /*
842 * @tc.name: BundleActiveGroupControllerTest_007
843 * @tc.desc: test the interface
844 * @tc.type: FUNC
845 * @tc.require: DTS2023121404861
846 */
847 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_007,
848 Function | MediumTest | Level0)
849 {
850 auto coreObject = std::make_shared<BundleActiveCore>();
851 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(true);
852 coreObject->InitBundleGroupController();
853 int userId = 100;
854 coreObject->bundleGroupController_->IsBundleIdle("test", userId);
855 }
856
857 /*
858 * @tc.name: BundleActiveGroupControllerTest_009
859 * @tc.desc: test the interface
860 * @tc.type: FUNC
861 * @tc.require: DTS2023121404861
862 */
863 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_009,
864 Function | MediumTest | Level0)
865 {
866 auto coreObject = std::make_shared<BundleActiveCore>();
867 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(true);
868 coreObject->InitBundleGroupController();
869 int userId = 100;
870 coreObject->bundleGroupController_->IsBundleInstalled("test", userId);
871 coreObject->bundleGroupController_->sptrBundleMgr_ = nullptr;
872 coreObject->bundleGroupController_->IsBundleInstalled("test", userId);
873 }
874
875 /*
876 * @tc.name: BundleActiveGroupControllerTest_010
877 * @tc.desc: test the interface
878 * @tc.type: FUNC
879 * @tc.require: DTS2023121404861
880 */
881 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveGroupControllerTest_010,
882 Function | MediumTest | Level0)
883 {
884 auto coreObject = std::make_shared<BundleActiveCore>();
885 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(true);
886 coreObject->InitBundleGroupController();
887 int userId = 100;
888 int64_t timeStamp = 20000000000000;
889 coreObject->bundleGroupController_->ShutDown(timeStamp, userId);
890 }
891
892 /*
893 * @tc.name: BundleActiveUserHistoryTest_001
894 * @tc.desc: test the interface
895 * @tc.type: FUNC
896 * @tc.require: DTS2023121404861
897 */
898 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_001,
899 Function | MediumTest | Level0)
900 {
901 int64_t bootBasedTimeStamp = 2000;
902 std::shared_ptr<BundleActiveCore> bundleActiveCore;
903 std::vector<int64_t> screenTimeLevel;
904 std::vector<int64_t> bootFromTimeLevel;
905 auto bundleUserHistory_ = std::make_shared<BundleActiveUserHistory>(bootBasedTimeStamp, bundleActiveCore);
906 bundleUserHistory_->GetLevelIndex("test", 0, 20000, screenTimeLevel, bootFromTimeLevel);
907 }
908
909 /*
910 * @tc.name: BundleActiveUserHistoryTest_002
911 * @tc.desc: test the interface
912 * @tc.type: FUNC
913 * @tc.require: DTS2023121404861
914 */
915 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_002,
916 Function | MediumTest | Level0)
917 {
918 int64_t bootBasedTimeStamp = 2000;
919 std::shared_ptr<BundleActiveCore> bundleActiveCore;
920 auto bundleUserHistory_ = std::make_shared<BundleActiveUserHistory>(bootBasedTimeStamp, bundleActiveCore);
921 bundleUserHistory_->WriteDeviceDuration();
922 bundleUserHistory_->OnBundleUninstalled(0, "test");
923 }
924
925 /*
926 * @tc.name: BundleActiveUserHistoryTest_003
927 * @tc.desc: test the interface
928 * @tc.type: FUNC
929 * @tc.require: DTS2023121404861
930 */
931 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_003,
932 Function | MediumTest | Level0)
933 {
934 int64_t bootBasedTimeStamp = 2000;
935 std::shared_ptr<BundleActiveCore> bundleActiveCore;
936 auto oneBundleUsageHistory = std::make_shared<BundleActivePackageHistory>();
937 auto bundleUserHistory_ = std::make_shared<BundleActiveUserHistory>(bootBasedTimeStamp, bundleActiveCore);
938 bundleUserHistory_->ReportUsage(oneBundleUsageHistory, "test", 0, 0, 1000, 2000, 100);
939 SUCCEED();
940 bundleUserHistory_->ReportUsage(oneBundleUsageHistory, "test", 0, 0, 2000, 1000, 100);
941 SUCCEED();
942 bundleUserHistory_->ReportUsage(oneBundleUsageHistory, "test", 10, 0, 1000, 2000, 100);
943 SUCCEED();
944 bundleUserHistory_->ReportUsage(oneBundleUsageHistory, "test", 20, 0, 1000, 2000, 100);
945 SUCCEED();
946 bundleUserHistory_->ReportUsage(oneBundleUsageHistory, "test", 20, 0, 0, 2000, 100);
947 SUCCEED();
948 }
949
950 /*
951 * @tc.name: BundleActiveUserHistoryTest_004
952 * @tc.desc: test the interface
953 * @tc.type: FUNC
954 * @tc.require: DTS2023121404861
955 */
956 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_004,
957 Function | MediumTest | Level0)
958 {
959 std::shared_ptr<BundleActiveCore> bundleActiveCore;
960 int32_t userId = 100;
961 int64_t bootBasedTimeStamp = 2000;
962 int32_t newgroup = 0;
963 uint32_t groupReason = 0;
964 auto bundleUserHistory_ = std::make_shared<BundleActiveUserHistory>(bootBasedTimeStamp, bundleActiveCore);
965 bundleUserHistory_->SetAppGroup("test", userId, bootBasedTimeStamp, newgroup, groupReason, true);
966 bundleUserHistory_->SetAppGroup("test", userId, bootBasedTimeStamp, newgroup, groupReason, false);
967 }
968
969 /*
970 * @tc.name: BundleActiveUserHistoryTest_005
971 * @tc.desc: test the interface
972 * @tc.type: FUNC
973 * @tc.require: DTS2023121404861
974 */
975 HWTEST_F(DeviceUsageStatisticsServiceTest, BundleActiveUserHistoryTest_005,
976 Function | MediumTest | Level0)
977 {
978 std::shared_ptr<BundleActiveCore> bundleActiveCore;
979 int64_t bootBasedTimeStamp = 2000;
980 auto bundleUserHistory_ = std::make_shared<BundleActiveUserHistory>(bootBasedTimeStamp, bundleActiveCore);
981 bundleUserHistory_->PrintData(0);
982 }
983
984 /*
985 * @tc.name: DeviceUsageStatisticsServiceTest_ShutDown_001
986 * @tc.desc: ShutDown
987 * @tc.type: FUNC
988 * @tc.require: issuesI5SOZY
989 */
990 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ShutDown_001,
991 Function | MediumTest | Level0)
992 {
993 auto coreObject = std::make_shared<BundleActiveCore>();
994 coreObject->Init();
995 coreObject->InitBundleGroupController();
996 coreObject->ShutDown();
997 EXPECT_NE(coreObject, nullptr);
998 }
999
1000 /*
1001 * @tc.name: DeviceUsageStatisticsServiceTest_CheckTimeChangeAndGetWallTime_001
1002 * @tc.desc: CheckTimeChangeAndGetWallTime
1003 * @tc.type: FUNC
1004 * @tc.require: issuesI5SOZY
1005 */
1006 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CheckTimeChangeAndGetWallTime_001,
1007 Function | MediumTest | Level0)
1008 {
1009 int userId = 100;
1010 auto coreObject = std::make_shared<BundleActiveCore>();
1011 coreObject->OnUserRemoved(100);
1012 coreObject->Init();
1013 coreObject->InitBundleGroupController();
1014 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
1015 coreObject->userStatServices_[userId] = userService;
1016
1017 coreObject->CheckTimeChangeAndGetWallTime(userId);
1018 coreObject->OnUserSwitched(userId);
1019 EXPECT_NE(coreObject, nullptr);
1020 }
1021
1022 /*
1023 * @tc.name: DeviceUsageStatisticsServiceTest_QueryAppGroup_001
1024 * @tc.desc: QueryAppGroup
1025 * @tc.type: FUNC
1026 * @tc.require: issuesI5SOZY
1027 */
1028 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryAppGroup_001,
1029 Function | MediumTest | Level0)
1030 {
1031 auto groupController = std::make_shared<BundleActiveGroupController>(false);
1032 int32_t appGroup = 10;
1033 std::string bundleName = "";
1034 int32_t userId = 100;
1035 EXPECT_NE(groupController->QueryAppGroup(appGroup, bundleName, userId), ERR_OK);
1036
1037 groupController->sptrBundleMgr_ = nullptr;
1038 bundleName = "defaultBundleName";
1039 EXPECT_NE(groupController->QueryAppGroup(appGroup, bundleName, userId), ERR_OK);
1040 }
1041
1042 /*
1043 * @tc.name: DeviceUsageStatisticsServiceTest_ControllerReportEvent_001
1044 * @tc.desc: ControllerReportEvent
1045 * @tc.type: FUNC
1046 * @tc.require: issuesI5SOZY
1047 */
1048 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ControllerReportEvent_001,
1049 Function | MediumTest | Level0)
1050 {
1051 auto coreObject = std::make_shared<BundleActiveCore>();
1052 coreObject->Init();
1053 coreObject->InitBundleGroupController();
1054
1055 int64_t bootBasedTimeStamp = 20000000000000;
1056 BundleActiveEvent event;
1057 int32_t userId = 100;
1058 coreObject->bundleGroupController_->bundleGroupEnable_ = false;
1059 coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId);
1060
1061 coreObject->bundleGroupController_->bundleGroupEnable_ = true;
1062 event.bundleName_ = "com.ohos.camera";
1063 coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId);
1064
1065 event.eventId_ = BundleActiveEvent::NOTIFICATION_SEEN;
1066 coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId);
1067
1068 event.eventId_ = BundleActiveEvent::SYSTEM_INTERACTIVE;
1069 coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId);
1070 EXPECT_NE(coreObject, nullptr);
1071 }
1072
1073 /*
1074 * @tc.name: DeviceUsageStatisticsServiceTest_CheckAndUpdateGroup_001
1075 * @tc.desc: CheckAndUpdateGroup
1076 * @tc.type: FUNC
1077 * @tc.require: issuesI5SOZY
1078 */
1079 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CheckAndUpdateGroup_001,
1080 Function | MediumTest | Level0)
1081 {
1082 auto coreObject = std::make_shared<BundleActiveCore>();
1083 coreObject->Init();
1084 coreObject->InitBundleGroupController();
1085
1086 std::string bundleName = "com.ohos.camera";
1087 int32_t userId = 100;
1088 int64_t bootBasedTimeStamp = 20000000000000;
1089 int32_t newGroup = 30;
1090 uint32_t reason = GROUP_CONTROL_REASON_TIMEOUT;
1091 bool isFlush = false;
1092
1093 int32_t appGroup = 0;
1094 coreObject->bundleGroupController_->QueryAppGroup(appGroup, bundleName, userId);
1095
1096 coreObject->bundleGroupController_->SetAppGroup(bundleName, userId, newGroup, reason, bootBasedTimeStamp, isFlush);
1097 coreObject->bundleGroupController_->CheckAndUpdateGroup(bundleName, userId, bootBasedTimeStamp);
1098
1099 newGroup = 20;
1100 reason = GROUP_CONTROL_REASON_CALCULATED;
1101 coreObject->bundleGroupController_->SetAppGroup(bundleName, userId, newGroup, reason, bootBasedTimeStamp, isFlush);
1102 coreObject->bundleGroupController_->CheckAndUpdateGroup(bundleName, userId, bootBasedTimeStamp);
1103 EXPECT_NE(coreObject, nullptr);
1104 }
1105
1106 /*
1107 * @tc.name: DeviceUsageStatisticsServiceTest_PreservePowerStateInfo_001
1108 * @tc.desc: PreservePowerStateInfo
1109 * @tc.type: FUNC
1110 * @tc.require: issuesI5SOZY
1111 */
1112 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_PreservePowerStateInfo_001,
1113 Function | MediumTest | Level0)
1114 {
1115 auto coreObject = std::make_shared<BundleActiveCore>();
1116 coreObject->Init();
1117 coreObject->InitBundleGroupController();
1118
1119 int32_t eventId = BundleActiveEvent::ABILITY_FOREGROUND;
1120 coreObject->PreservePowerStateInfo(eventId);
1121 EXPECT_NE(coreObject, nullptr);
1122 }
1123
1124 /*
1125 * @tc.name: DeviceUsageStatisticsServiceTest_UpdateModuleData_001
1126 * @tc.desc: UpdateModuleData
1127 * @tc.type: FUNC
1128 * @tc.require: issuesI5SOZY
1129 */
1130 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_UpdateModuleData_001,
1131 Function | MediumTest | Level0)
1132 {
1133 auto database = std::make_shared<BundleActiveUsageDatabase>();
1134 auto moduleRecords = std::map<std::string, std::shared_ptr<BundleActiveModuleRecord>>();
1135 int64_t timeStamp = 20000000000;
1136 int32_t userId = 100;
1137 database->UpdateModuleData(userId, moduleRecords, timeStamp);
1138 EXPECT_NE(database, nullptr);
1139 }
1140
1141 /*
1142 * @tc.name: DeviceUsageStatisticsServiceTest_QueryNotificationEventStats_001
1143 * @tc.desc: QueryNotificationEventStats
1144 * @tc.type: FUNC
1145 * @tc.require: issuesI5SOZY
1146 */
1147 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryNotificationEventStats_001,
1148 Function | MediumTest | Level0)
1149 {
1150 auto database = std::make_shared<BundleActiveUsageDatabase>();
1151
1152 int32_t eventId = 2;
1153 int64_t beginTime = 0;
1154 int64_t endTime = 0;
1155 auto notificationEventStats = std::map<std::string, BundleActiveEventStats>();
1156 int32_t userId = 100;
1157 BUNDLE_ACTIVE_LOGI("database->QueryNotificationEventStats");
1158 database->QueryNotificationEventStats(eventId, beginTime, endTime, notificationEventStats, userId);
1159 EXPECT_NE(database, nullptr);
1160 }
1161
1162 /*
1163 * @tc.name: DeviceUsageStatisticsServiceTest_QueryDeviceEventStats_001
1164 * @tc.desc: QueryDeviceEventStats
1165 * @tc.type: FUNC
1166 * @tc.require: issuesI5SOZY
1167 */
1168 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryDeviceEventStats_001,
1169 Function | MediumTest | Level0)
1170 {
1171 auto database = std::make_shared<BundleActiveUsageDatabase>();
1172
1173 int32_t eventId = 2;
1174 int64_t beginTime = 0;
1175 int64_t endTime = 0;
1176 auto eventStats = std::map<std::string, BundleActiveEventStats>();
1177 int32_t userId = 100;
1178 BUNDLE_ACTIVE_LOGI("database->QueryDeviceEventStats");
1179 database->QueryDeviceEventStats(eventId, beginTime, endTime, eventStats, userId);
1180 EXPECT_NE(database, nullptr);
1181 }
1182
1183 /*
1184 * @tc.name: DeviceUsageStatisticsServiceTest_QueryDatabaseEvents_001
1185 * @tc.desc: QueryDatabaseEvents
1186 * @tc.type: FUNC
1187 * @tc.require: issuesI5SOZY
1188 */
1189 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryDatabaseEvents_001,
1190 Function | MediumTest | Level0)
1191 {
1192 auto database = std::make_shared<BundleActiveUsageDatabase>();
1193
1194 int64_t beginTime = 0;
1195 int64_t endTime = 0;
1196 std::string bundleName;
1197 int32_t userId = 100;
1198 BUNDLE_ACTIVE_LOGI("database->QueryDatabaseEvents");
1199 database->QueryDatabaseEvents(beginTime, endTime, userId, bundleName);
1200
1201 bundleName = "com.ohos.camera";
1202 database->QueryDatabaseEvents(beginTime, endTime, userId, bundleName);
1203 EXPECT_NE(database, nullptr);
1204 }
1205
1206 /*
1207 * @tc.name: DeviceUsageStatisticsServiceTest_UpdateEventData_001
1208 * @tc.desc: UpdateEventData
1209 * @tc.type: FUNC
1210 * @tc.require: issuesI5SOZY
1211 */
1212 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_UpdateEventData_001,
1213 Function | MediumTest | Level0)
1214 {
1215 auto database = std::make_shared<BundleActiveUsageDatabase>();
1216
1217 int32_t databaseType = WEEKLY_DATABASE_INDEX;
1218 BundleActivePeriodStats stats;
1219 database->UpdateEventData(databaseType, stats);
1220
1221 databaseType = DAILY_DATABASE_INDEX;
1222 database->UpdateEventData(databaseType, stats);
1223 EXPECT_NE(database, nullptr);
1224 }
1225
1226 /*
1227 * @tc.name: DeviceUsageStatisticsServiceTest_UpdateBundleUsageData_001
1228 * @tc.desc: UpdateBundleUsageData
1229 * @tc.type: FUNC
1230 * @tc.require: issuesI5SOZY
1231 */
1232 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_UpdateBundleUsageData_001,
1233 Function | MediumTest | Level0)
1234 {
1235 auto database = std::make_shared<BundleActiveUsageDatabase>();
1236
1237 int32_t databaseType = -1;
1238 BundleActivePeriodStats stats;
1239 database->UpdateBundleUsageData(databaseType, stats);
1240
1241 databaseType = EVENT_DATABASE_INDEX;
1242 database->UpdateBundleUsageData(databaseType, stats);
1243
1244 databaseType = DAILY_DATABASE_INDEX;
1245 database->UpdateBundleUsageData(databaseType, stats);
1246 EXPECT_NE(database, nullptr);
1247 }
1248
1249 /*
1250 * @tc.name: DeviceUsageStatisticsServiceTest_RenewTableTime_001
1251 * @tc.desc: RenewTableTime
1252 * @tc.type: FUNC
1253 * @tc.require: issuesI5SOZY
1254 */
1255 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RenewTableTime_001,
1256 Function | MediumTest | Level0)
1257 {
1258 auto database = std::make_shared<BundleActiveUsageDatabase>();
1259
1260 int64_t timeDiffMillis = 0;
1261 database->sortedTableArray_[0] = {-1, 0};
1262 database->RenewTableTime(timeDiffMillis);
1263
1264 database->eventTableName_ = "";
1265 database->RenewTableTime(timeDiffMillis);
1266
1267 database->eventTableName_ = "defaultTableName";
1268 database->RenewTableTime(timeDiffMillis);
1269
1270 database->formRecordsTableName_ = "defaultFormRecordsTableName";
1271 database->RenewTableTime(timeDiffMillis);
1272
1273 database->moduleRecordsTableName_ = "defaultModuleRecordsTableName_";
1274 database->RenewTableTime(timeDiffMillis);
1275 EXPECT_NE(database, nullptr);
1276 }
1277
1278 /*
1279 * @tc.name: DeviceUsageStatisticsServiceTest_SetNewIndexWhenTimeChanged_001
1280 * @tc.desc: SetNewIndexWhenTimeChanged
1281 * @tc.type: FUNC
1282 * @tc.require: issuesI5SOZY
1283 */
1284 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_SetNewIndexWhenTimeChanged_001,
1285 Function | MediumTest | Level0)
1286 {
1287 auto database = std::make_shared<BundleActiveUsageDatabase>();
1288
1289 uint32_t databaseType = APP_GROUP_DATABASE_INDEX;
1290 int64_t tableOldTime = 0;
1291 int64_t tableNewTime = 20000000000000;
1292 std::shared_ptr<NativeRdb::RdbStore> rdbStore = nullptr;
1293 EXPECT_NE(database->SetNewIndexWhenTimeChanged(databaseType, tableOldTime, tableNewTime, rdbStore), ERR_OK);
1294
1295 rdbStore = database->GetBundleActiveRdbStore(databaseType);
1296 database->SetNewIndexWhenTimeChanged(databaseType, tableOldTime, tableNewTime, rdbStore);
1297 EXPECT_NE(database, nullptr);
1298 }
1299
1300 /*
1301 * @tc.name: DeviceUsageStatisticsServiceTest_ReportContinuousTaskEvent_001
1302 * @tc.desc: ReportContinuousTaskEvent
1303 * @tc.type: FUNC
1304 * @tc.require: issuesI5SOZY
1305 */
1306 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ReportContinuousTaskEvent_001,
1307 Function | MediumTest | Level0)
1308 {
1309 #ifdef BGTASKMGR_ENABLE
1310 auto bgtaskObserver = std::make_shared<BundleActiveContinuousTaskObserver>();
1311 auto continuousTaskCallbackInfo = std::shared_ptr<OHOS::BackgroundTaskMgr::ContinuousTaskCallbackInfo>();
1312 continuousTaskCallbackInfo->creatorUid_ = 20000000;
1313 bool isStart = false;
1314 bgtaskObserver->ReportContinuousTaskEvent(continuousTaskCallbackInfo, isStart);
1315
1316 isStart = true;
1317 bgtaskObserver->ReportContinuousTaskEvent(continuousTaskCallbackInfo, isStart);
1318 EXPECT_NE(bgtaskObserver, nullptr);
1319 #endif
1320 }
1321
1322 /*
1323 * @tc.name: DeviceUsageStatisticsServiceTest_RemoveFormData_001
1324 * @tc.desc: RemoveFormData
1325 * @tc.type: FUNC
1326 * @tc.require: issuesI5SOZY
1327 */
1328 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RemoveFormData_001,
1329 Function | MediumTest | Level0)
1330 {
1331 auto database = std::make_shared<BundleActiveUsageDatabase>();
1332 int32_t userId = 100;
1333 std::string bundleName = "defaultBundleName";
1334 std::string moduleName = "defaultModuleName";
1335 std::string formName = "defaultFormName";
1336 database->InitUsageGroupDatabase(0, true);
1337 database->RemoveFormData(userId, bundleName, moduleName, formName, 0, 0);
1338 EXPECT_NE(database, nullptr);
1339 }
1340
1341 /*
1342 * @tc.name: DeviceUsageStatisticsServiceTest_UpdateFormData_001
1343 * @tc.desc: UpdateFormData
1344 * @tc.type: FUNC
1345 * @tc.require: issuesI5SOZY
1346 */
1347 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_UpdateFormData_001,
1348 Function | MediumTest | Level0)
1349 {
1350 auto database = std::make_shared<BundleActiveUsageDatabase>();
1351 int32_t userId = 100;
1352 std::string bundleName = "defaultBundleName";
1353 std::string moduleName = "defaultModuleName";
1354 std::string formName = "defaultFormName";
1355 database->InitUsageGroupDatabase(0, true);
1356 BundleActiveFormRecord formRecord;
1357 auto rdbStore = database->GetBundleActiveRdbStore(0);
1358 database->UpdateFormData(userId, bundleName, moduleName, formRecord, rdbStore);
1359 EXPECT_NE(database, nullptr);
1360 }
1361
1362 /*
1363 * @tc.name: DeviceUsageStatisticsServiceTest_onStart_001
1364 * @tc.desc: onstart
1365 * @tc.type: FUNC
1366 * @tc.require: issuesI5SOZY
1367 */
1368 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_onStart_001,
1369 Function | MediumTest | Level0)
1370 {
1371 DelayedSingleton<BundleActiveService>::GetInstance()->ready_ = true;
1372 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance(), nullptr);
1373 }
1374
1375 /*
1376 * @tc.name: DeviceUsageStatisticsServiceTest_onStart_002
1377 * @tc.desc: onstart
1378 * @tc.type: FUNC
1379 * @tc.require: issuesI5SOZY
1380 */
1381 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_onStart_002,
1382 Function | MediumTest | Level0)
1383 {
1384 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->SubscribeAppState(), true);
1385 }
1386 } // namespace DeviceUsageStats
1387 } // namespace OHOS