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
32 using namespace testing::ext;
33
34 namespace OHOS {
35 namespace DeviceUsageStats {
36 class DeviceUsageStatisticsServiceTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42 };
43
SetUpTestCase(void)44 void DeviceUsageStatisticsServiceTest::SetUpTestCase(void)
45 {
46 }
47
TearDownTestCase(void)48 void DeviceUsageStatisticsServiceTest::TearDownTestCase(void)
49 {
50 }
51
SetUp(void)52 void DeviceUsageStatisticsServiceTest::SetUp(void)
53 {
54 }
55
TearDown(void)56 void DeviceUsageStatisticsServiceTest::TearDown(void)
57 {
58 }
59
60 class TestServiceAppGroupChangeCallback : public AppGroupCallbackStub {
61 public:
62 void OnAppGroupChanged(const AppGroupCallbackInfo &appGroupCallbackInfo) override;
63 };
64
OnAppGroupChanged(const AppGroupCallbackInfo & appGroupCallbackInfo)65 void TestServiceAppGroupChangeCallback::OnAppGroupChanged(const AppGroupCallbackInfo &appGroupCallbackInfo)
66 {
67 BUNDLE_ACTIVE_LOGI("TestServiceAppGroupChangeCallback::OnAppGroupChanged!");
68 }
69
70 /*
71 * @tc.name: DeviceUsageStatisticsServiceTest_GetServiceObject_001
72 * @tc.desc: get service object
73 * @tc.type: FUNC
74 * @tc.require: issuesI5SOZY
75 */
76 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetServiceObject_001,
77 Function | MediumTest | Level0)
78 {
79 sptr<ISystemAbilityManager> systemAbilityManager =
80 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
81 EXPECT_NE(systemAbilityManager, nullptr);
82
83 sptr<IRemoteObject> remoteObject =
84 systemAbilityManager->GetSystemAbility(DEVICE_USAGE_STATISTICS_SYS_ABILITY_ID);
85 EXPECT_NE(remoteObject, nullptr);
86 }
87
88 /*
89 * @tc.name: DeviceUsageStatisticsServiceTest_dump_001
90 * @tc.desc: test dump
91 * @tc.type: FUNC
92 * @tc.require: issuesI5SOZY
93 */
94 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_dump_001, Function | MediumTest | Level0)
95 {
96 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_ = std::make_shared<BundleActiveCore>();
97 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_->Init();
98 BUNDLE_ACTIVE_LOGI("DeviceUsageStatisticsServiceTest create BundleActiveService!");
99
100 std::vector<std::string> dumpOption{"-A", "Events"};
101 std::vector<std::string> dumpInfo;
102 DelayedSingleton<BundleActiveService>::GetInstance()->ShellDump(dumpOption, dumpInfo);
103
104 dumpOption.clear();
105 dumpInfo.clear();
106 dumpOption = {"-A", "Events", "0", "20000000000000", "100"};
107 DelayedSingleton<BundleActiveService>::GetInstance()->ShellDump(dumpOption, dumpInfo);
108
109 dumpOption.clear();
110 dumpInfo.clear();
111 dumpOption = {"-A", "PackageUsage"};
112 DelayedSingleton<BundleActiveService>::GetInstance()->ShellDump(dumpOption, dumpInfo);
113
114 dumpOption.clear();
115 dumpInfo.clear();
116 dumpOption = {"-A", "PackageUsage", "1", "0", "20000000000000", "100"};
117 DelayedSingleton<BundleActiveService>::GetInstance()->ShellDump(dumpOption, dumpInfo);
118
119 dumpOption.clear();
120 dumpInfo.clear();
121 dumpOption = {"-A", "ModuleUsage"};
122 DelayedSingleton<BundleActiveService>::GetInstance()->ShellDump(dumpOption, dumpInfo);
123
124 dumpOption.clear();
125 dumpInfo.clear();
126 dumpOption = {"-A", "ModuleUsage", "1", "100"};
127 DelayedSingleton<BundleActiveService>::GetInstance()->ShellDump(dumpOption, dumpInfo);
128
129 std::vector<std::u16string> args;
130 DelayedSingleton<BundleActiveService>::GetInstance()->Dump(-1, args);
131
132 args.clear();
133 args = {to_utf16("-h")};
134 DelayedSingleton<BundleActiveService>::GetInstance()->Dump(-1, args);
135
136 args.clear();
137 args = {to_utf16("-A")};
138 DelayedSingleton<BundleActiveService>::GetInstance()->Dump(-1, args);
139
140 args.clear();
141 args = {to_utf16("-D")};
142 DelayedSingleton<BundleActiveService>::GetInstance()->Dump(-1, args);
143 }
144
145 /*
146 * @tc.name: DeviceUsageStatisticsServiceTest_QueryModuleUsageRecords_001
147 * @tc.desc: QueryModuleUsageRecords
148 * @tc.type: FUNC
149 * @tc.require: issuesI5SOZY
150 */
151 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryModuleUsageRecords_001,
152 Function | MediumTest | Level0)
153 {
154 std::vector<BundleActiveModuleRecord> results;
155 int32_t maxNum = 0;
156 ErrCode code = DelayedSingleton<BundleActiveService>::GetInstance()->QueryModuleUsageRecords(maxNum, results, 100);
157 EXPECT_NE(code, 0);
158
159 maxNum = 1001;
160 code = DelayedSingleton<BundleActiveService>::GetInstance()->QueryModuleUsageRecords(maxNum, results, 100);
161 EXPECT_NE(code, 0);
162 }
163
164 /*
165 * @tc.name: DeviceUsageStatisticsServiceTest_AppGroupCallback_001
166 * @tc.desc: AppGroupCallback
167 * @tc.type: FUNC
168 * @tc.require: issuesI5SOZY
169 */
170 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_AppGroupCallback_001,
171 Function | MediumTest | Level0)
172 {
173 BUNDLE_ACTIVE_LOGI("DeviceUsageStatisticsServiceTest create BundleActiveService!");
174 sptr<TestServiceAppGroupChangeCallback> observer = new (std::nothrow) TestServiceAppGroupChangeCallback();
175 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_ = std::make_shared<BundleActiveCore>();
176 EXPECT_EQ(DelayedSingleton<BundleActiveService>::GetInstance()->RegisterAppGroupCallBack(observer), ERR_OK);
177 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->RegisterAppGroupCallBack(observer), ERR_OK);
178 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_->AddObserverDeathRecipient(observer);
179
180 EXPECT_EQ(DelayedSingleton<BundleActiveService>::GetInstance()->UnRegisterAppGroupCallBack(observer), ERR_OK);
181 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->UnRegisterAppGroupCallBack(observer), ERR_OK);
182
183 observer = nullptr;
184 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->RegisterAppGroupCallBack(observer), ERR_OK);
185
186 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_->AddObserverDeathRecipient(observer);
187 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_->RemoveObserverDeathRecipient(observer);
188
189 wptr<IRemoteObject> remote = nullptr;
190 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_->OnObserverDied(remote);
191 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_->OnObserverDiedInner(remote);
192 }
193
194 /*
195 * @tc.name: DeviceUsageStatisticsServiceTest_OnUserRemoved_001
196 * @tc.desc: OnUserRemoved
197 * @tc.type: FUNC
198 * @tc.require: issuesI5SOZY
199 */
200 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_OnUserRemoved_001,
201 Function | MediumTest | Level0)
202 {
203 int userId = 100;
204 auto coreObject = std::make_shared<BundleActiveCore>();
205 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(coreObject->debugCore_);
206 coreObject->InitBundleGroupController();
207 coreObject->RestoreToDatabase(userId);
208 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
209 coreObject->userStatServices_[userId] = userService;
210
211 BundleActiveEvent event;
212 coreObject->ReportEventToAllUserId(event);
213 coreObject->currentUsedUser_ = userId;
214 coreObject->OnUserRemoved(userId);
215 coreObject->OnUserSwitched(userId);
216 EXPECT_NE(coreObject, nullptr);
217 }
218
219 /*
220 * @tc.name: DeviceUsageStatisticsServiceTest_RestoreAllData_001
221 * @tc.desc: RestoreAllData
222 * @tc.type: FUNC
223 * @tc.require: issuesI5SOZY
224 */
225 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RestoreAllData_001,
226 Function | MediumTest | Level0)
227 {
228 auto coreObject = std::make_shared<BundleActiveCore>();
229 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(coreObject->debugCore_);
230 coreObject->InitBundleGroupController();
231
232 int userId = 100;
233 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
234 int64_t timeStamp = 20000000000000;
235 userService->Init(timeStamp);
236 coreObject->userStatServices_[userId] = userService;
237 userId = 101;
238 coreObject->userStatServices_[userId] = nullptr;
239 coreObject->RestoreAllData();
240
241 BundleActiveEvent event;
242 coreObject->ReportEventToAllUserId(event);
243 EXPECT_NE(coreObject, nullptr);
244 }
245
246 /*
247 * @tc.name: DeviceUsageStatisticsServiceTest_ObtainSystemEventName_001
248 * @tc.desc: ObtainSystemEventName
249 * @tc.type: FUNC
250 * @tc.require: issuesI5SOZY
251 */
252 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ObtainSystemEventName_001,
253 Function | MediumTest | Level0)
254 {
255 auto coreObject = std::make_shared<BundleActiveCore>();
256 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(coreObject->debugCore_);
257 BundleActiveEvent event;
258 event.eventId_ = BundleActiveEvent::SYSTEM_LOCK;
259 coreObject->ObtainSystemEventName(event);
260
261 event.eventId_ = BundleActiveEvent::SYSTEM_UNLOCK;
262 coreObject->ObtainSystemEventName(event);
263
264 event.eventId_ = BundleActiveEvent::SYSTEM_SLEEP;
265 coreObject->ObtainSystemEventName(event);
266
267 event.eventId_ = BundleActiveEvent::SYSTEM_WAKEUP;
268 coreObject->ObtainSystemEventName(event);
269 EXPECT_NE(coreObject, nullptr);
270 }
271
272 /*
273 * @tc.name: DeviceUsageStatisticsServiceTest_JudgeQueryCondition_001
274 * @tc.desc: JudgeQueryCondition
275 * @tc.type: FUNC
276 * @tc.require: issuesI5SOZY
277 */
278 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_JudgeQueryCondition_001,
279 Function | MediumTest | Level0)
280 {
281 auto database = std::make_shared<BundleActiveUsageDatabase>();
282 int64_t beginTime = 0;
283 int64_t endTime = 0;
284 int64_t eventTableTime = 0;
285 database->eventTableName_ = "defaultTableName";
286 EXPECT_EQ(database->JudgeQueryCondition(beginTime, endTime, eventTableTime), QUERY_CONDITION_INVALID);
287
288 endTime = 10;
289 eventTableTime = 11;
290 EXPECT_EQ(database->JudgeQueryCondition(beginTime, endTime, eventTableTime), QUERY_CONDITION_INVALID);
291 }
292
293 /*
294 * @tc.name: DeviceUsageStatisticsServiceTest_GetSystemEventName_001
295 * @tc.desc: GetSystemEventName
296 * @tc.type: FUNC
297 * @tc.require: issuesI5SOZY
298 */
299 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetSystemEventName_001,
300 Function | MediumTest | Level0)
301 {
302 auto database = std::make_shared<BundleActiveUsageDatabase>();
303 int32_t userId = BundleActiveEvent::SYSTEM_LOCK;
304 EXPECT_EQ(database->GetSystemEventName(userId), "SYSTEM_LOCK");
305
306 userId = BundleActiveEvent::SYSTEM_UNLOCK;
307 EXPECT_EQ(database->GetSystemEventName(userId), "SYSTEM_UNLOCK");
308
309 userId = BundleActiveEvent::SYSTEM_SLEEP;
310 EXPECT_EQ(database->GetSystemEventName(userId), "SYSTEM_SLEEP");
311
312 userId = BundleActiveEvent::SYSTEM_WAKEUP;
313 EXPECT_EQ(database->GetSystemEventName(userId), "SYSTEM_WAKEUP");
314
315 userId = BundleActiveEvent::ABILITY_FOREGROUND;
316 EXPECT_EQ(database->GetSystemEventName(userId), "");
317 }
318
319 /*
320 * @tc.name: DeviceUsageStatisticsServiceTest_GetOverdueTableCreateTime_001
321 * @tc.desc: GetOverdueTableCreateTime
322 * @tc.type: FUNC
323 * @tc.require: issuesI5SOZY
324 */
325 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetOverdueTableCreateTime_001,
326 Function | MediumTest | Level0)
327 {
328 auto database = std::make_shared<BundleActiveUsageDatabase>();
329 uint32_t databaseType = 4;
330 int64_t currentTimeMillis = 20000000000000;
331 database->GetOverdueTableCreateTime(databaseType, currentTimeMillis);
332
333 databaseType = 0;
334 database->GetOverdueTableCreateTime(databaseType, currentTimeMillis);
335 EXPECT_NE(database, nullptr);
336 }
337
338 /*
339 * @tc.name: DeviceUsageStatisticsServiceTest_DeleteInvalidTable_001
340 * @tc.desc: DeleteInvalidTable
341 * @tc.type: FUNC
342 * @tc.require: issuesI5SOZY
343 */
344 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_DeleteInvalidTable_001,
345 Function | MediumTest | Level0)
346 {
347 auto database = std::make_shared<BundleActiveUsageDatabase>();
348 uint32_t databaseType = 4;
349 int64_t currentTimeMillis = 20000000000000;
350 database->DeleteInvalidTable(databaseType, currentTimeMillis);
351
352 databaseType = 0;
353 database->DeleteInvalidTable(databaseType, currentTimeMillis);
354 EXPECT_NE(database, nullptr);
355 }
356
357 /*
358 * @tc.name: DeviceUsageStatisticsServiceTest_CreatePackageLogTable_001
359 * @tc.desc: CreatePackageLogTable
360 * @tc.type: FUNC
361 * @tc.require: issuesI5SOZY
362 */
363 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CreatePackageLogTable_001,
364 Function | MediumTest | Level0)
365 {
366 auto database = std::make_shared<BundleActiveUsageDatabase>();
367 uint32_t databaseType = 0;
368 int64_t currentTimeMillis = 20000000000000;
369 database->CreatePackageLogTable(databaseType, currentTimeMillis);
370 EXPECT_NE(database, nullptr);
371 }
372
373 /*
374 * @tc.name: DeviceUsageStatisticsServiceTest_CreateModuleRecordTable_001
375 * @tc.desc: CreateModuleRecordTable
376 * @tc.type: FUNC
377 * @tc.require: issuesI5SOZY
378 */
379 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CreateModuleRecordTable_001,
380 Function | MediumTest | Level0)
381 {
382 auto database = std::make_shared<BundleActiveUsageDatabase>();
383 uint32_t databaseType = 0;
384 int64_t currentTimeMillis = 20000000000000;
385 database->CreateModuleRecordTable(databaseType, currentTimeMillis);
386 EXPECT_NE(database, nullptr);
387 }
388
389 /*
390 * @tc.name: DeviceUsageStatisticsServiceTest_CreateFormRecordTable_001
391 * @tc.desc: CreateFormRecordTable
392 * @tc.type: FUNC
393 * @tc.require: issuesI5SOZY
394 */
395 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CreateFormRecordTable_001,
396 Function | MediumTest | Level0)
397 {
398 auto database = std::make_shared<BundleActiveUsageDatabase>();
399 uint32_t databaseType = 0;
400 int64_t currentTimeMillis = 20000000000000;
401 database->CreateFormRecordTable(databaseType, currentTimeMillis);
402 EXPECT_NE(database, nullptr);
403 }
404
405 /*
406 * @tc.name: DeviceUsageStatisticsServiceTest_CreateDurationTable_001
407 * @tc.desc: CreateDurationTable
408 * @tc.type: FUNC
409 * @tc.require: issuesI5SOZY
410 */
411 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CreateDurationTable_001,
412 Function | MediumTest | Level0)
413 {
414 auto database = std::make_shared<BundleActiveUsageDatabase>();
415 int32_t databaseType = DAILY_DATABASE_INDEX;
416 bool forModuleRecords = true;
417 database->InitUsageGroupDatabase(databaseType, forModuleRecords);
418 EXPECT_NE(database, nullptr);
419 }
420
421 /*
422 * @tc.name: DeviceUsageStatisticsServiceTest_CreateBundleHistoryTable_001
423 * @tc.desc: CreateBundleHistoryTable
424 * @tc.type: FUNC
425 * @tc.require: issuesI5SOZY
426 */
427 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CreateBundleHistoryTable_001,
428 Function | MediumTest | Level0)
429 {
430 auto database = std::make_shared<BundleActiveUsageDatabase>();
431 uint32_t databaseType = 0;
432 database->CreateBundleHistoryTable(databaseType);
433 EXPECT_NE(database, nullptr);
434 }
435
436 /*
437 * @tc.name: DeviceUsageStatisticsServiceTest_PutBundleHistoryData_001
438 * @tc.desc: PutBundleHistoryData
439 * @tc.type: FUNC
440 * @tc.require: issuesI5SOZY
441 */
442 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_PutBundleHistoryData_001,
443 Function | MediumTest | Level0)
444 {
445 auto database = std::make_shared<BundleActiveUsageDatabase>();
446 int32_t userId = 100;
447 std::shared_ptr<std::map<std::string, std::shared_ptr<BundleActivePackageHistory>>> userHistory = nullptr;
448 database->PutBundleHistoryData(userId, userHistory);
449
450 userHistory = std::make_shared<std::map<string, std::shared_ptr<BundleActivePackageHistory>>>();
451 userHistory->emplace("defaultTest", std::make_shared<BundleActivePackageHistory>());
452 database->PutBundleHistoryData(userId, userHistory);
453 database->PutBundleHistoryData(userId, userHistory);
454 EXPECT_NE(database, nullptr);
455 }
456
457 /*
458 * @tc.name: DeviceUsageStatisticsServiceTest_GetBundleHistoryData_001
459 * @tc.desc: GetBundleHistoryData
460 * @tc.type: FUNC
461 * @tc.require: issuesI5SOZY
462 */
463 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetBundleHistoryData_001,
464 Function | MediumTest | Level0)
465 {
466 auto database = std::make_shared<BundleActiveUsageDatabase>();
467 int32_t userId = 100;
468 database->GetBundleHistoryData(userId);
469 EXPECT_NE(database, nullptr);
470 }
471
472 /*
473 * @tc.name: DeviceUsageStatisticsServiceTest_FlushPackageInfo_001
474 * @tc.desc: FlushPackageInfo
475 * @tc.type: FUNC
476 * @tc.require: issuesI5SOZY
477 */
478 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_FlushPackageInfo_001,
479 Function | MediumTest | Level0)
480 {
481 auto database = std::make_shared<BundleActiveUsageDatabase>();
482 uint32_t databaseType = 0;
483 BundleActivePeriodStats stats;
484 stats.bundleStats_.emplace("defaultTest", std::make_shared<BundleActivePackageStats>());
485 database->FlushPackageInfo(databaseType, stats);
486 EXPECT_NE(database, nullptr);
487 }
488
489 /*
490 * @tc.name: DeviceUsageStatisticsServiceTest_GetCurrentUsageData_001
491 * @tc.desc: GetCurrentUsageData
492 * @tc.type: FUNC
493 * @tc.require: issuesI5SOZY
494 */
495 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetCurrentUsageData_001,
496 Function | MediumTest | Level0)
497 {
498 auto database = std::make_shared<BundleActiveUsageDatabase>();
499 int32_t databaseType = -1;
500 int32_t userId = 100;
501 database->GetCurrentUsageData(databaseType, userId);
502
503 databaseType = 4;
504 database->GetCurrentUsageData(databaseType, userId);
505
506 databaseType = 0;
507 database->GetCurrentUsageData(databaseType, userId);
508 EXPECT_NE(database, nullptr);
509 }
510
511 /*
512 * @tc.name: DeviceUsageStatisticsServiceTest_GetTableIndexSql_001
513 * @tc.desc: GetTableIndexSql
514 * @tc.type: FUNC
515 * @tc.require: issuesI5SOZY
516 */
517 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetTableIndexSql_001,
518 Function | MediumTest | Level0)
519 {
520 auto database = std::make_shared<BundleActiveUsageDatabase>();
521 uint32_t databaseType = 0;
522 int64_t tableTime = 20000000000000;
523 bool createFlag = false;
524 int32_t indexFlag = 0;
525 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
526
527 createFlag = true;
528 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
529
530 databaseType = 4;
531 createFlag = false;
532 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
533
534 databaseType = 5;
535 createFlag = false;
536 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
537 indexFlag = BUNDLE_ACTIVE_DB_INDEX_MODULE;
538 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
539
540 createFlag = true;
541 indexFlag = BUNDLE_ACTIVE_DB_INDEX_NORMAL;
542 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
543
544 indexFlag = BUNDLE_ACTIVE_DB_INDEX_MODULE;
545 database->GetTableIndexSql(databaseType, tableTime, createFlag, indexFlag);
546 EXPECT_NE(database, nullptr);
547 }
548
549 /*
550 * @tc.name: DeviceUsageStatisticsServiceTest_RenameTableName_001
551 * @tc.desc: RenameTableName
552 * @tc.type: FUNC
553 * @tc.require: issuesI5SOZY
554 */
555 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RenameTableName_001,
556 Function | MediumTest | Level0)
557 {
558 auto database = std::make_shared<BundleActiveUsageDatabase>();
559 uint32_t databaseType = 0;
560 int64_t tableOldTime = 0;
561 int64_t tableNewTime = 20000000000000;
562 database->RenameTableName(databaseType, tableOldTime, tableNewTime);
563
564 databaseType = 4;
565 database->RenameTableName(databaseType, tableOldTime, tableNewTime);
566
567 databaseType = 5;
568 database->RenameTableName(databaseType, tableOldTime, tableNewTime);
569 EXPECT_NE(database, nullptr);
570 }
571
572 /*
573 * @tc.name: DeviceUsageStatisticsServiceTest_RemoveOldData_001
574 * @tc.desc: RemoveOldData
575 * @tc.type: FUNC
576 * @tc.require: issuesI5SOZY
577 */
578 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RemoveOldData_001,
579 Function | MediumTest | Level0)
580 {
581 auto database = std::make_shared<BundleActiveUsageDatabase>();
582 int64_t currentTime = 20000000000000;
583 database->RemoveOldData(currentTime);
584 EXPECT_NE(database, nullptr);
585 }
586
587 /*
588 * @tc.name: DeviceUsageStatisticsServiceTest_QueryDatabaseUsageStats_001
589 * @tc.desc: QueryDatabaseUsageStats
590 * @tc.type: FUNC
591 * @tc.require: issuesI5SOZY
592 */
593 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryDatabaseUsageStats_001,
594 Function | MediumTest | Level0)
595 {
596 auto database = std::make_shared<BundleActiveUsageDatabase>();
597 int32_t databaseType = -1;
598 int64_t beginTime = 0;
599 int64_t endTime = 0;
600 int32_t userId = 100;
601 EXPECT_EQ(database->QueryDatabaseUsageStats(databaseType, beginTime, endTime, userId).size(), 0);
602
603 databaseType = 4;
604 EXPECT_EQ(database->QueryDatabaseUsageStats(databaseType, beginTime, endTime, userId).size(), 0);
605
606 databaseType = 0;
607 EXPECT_EQ(database->QueryDatabaseUsageStats(databaseType, beginTime, endTime, userId).size(), 0);
608
609 databaseType = 0;
610 endTime = 20000000000000;
611 database->QueryDatabaseUsageStats(databaseType, beginTime, endTime, userId);
612 EXPECT_NE(database, nullptr);
613 }
614
615 /*
616 * @tc.name: DeviceUsageStatisticsServiceTest_GetSystemTimeMs_001
617 * @tc.desc: GetSystemTimeMs
618 * @tc.type: FUNC
619 * @tc.require: issuesI5SOZY
620 */
621 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_GetSystemTimeMs_001,
622 Function | MediumTest | Level0)
623 {
624 auto database = std::make_shared<BundleActiveUsageDatabase>();
625 database->GetSystemTimeMs();
626 EXPECT_NE(database, nullptr);
627 }
628
629 /*
630 * @tc.name: DeviceUsageStatisticsServiceTest_ReportEvent_001
631 * @tc.desc: ReportEvent
632 * @tc.type: FUNC
633 * @tc.require: issuesI5SOZY
634 */
635 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ReportEvent_001,
636 Function | MediumTest | Level0)
637 {
638 auto coreObject = std::make_shared<BundleActiveCore>();
639 coreObject->Init();
640 coreObject->InitBundleGroupController();
641
642 BundleActiveEvent event;
643 int32_t userId = 0;
644 EXPECT_NE(coreObject->ReportEvent(event, userId), ERR_OK);
645
646 userId = 101;
647 event.bundleName_ = "com.ohos.launcher";
648 EXPECT_EQ(coreObject->ReportEvent(event, userId), ERR_OK);
649
650 event.bundleName_ = "com.ohos.settings";
651 event.eventId_ = 15;
652 EXPECT_EQ(coreObject->ReportEvent(event, userId), ERR_OK);
653
654 event.eventId_ = 16;
655 EXPECT_EQ(coreObject->ReportEvent(event, userId), ERR_OK);
656 }
657
658 /*
659 * @tc.name: DeviceUsageStatisticsServiceTest_InitBundleGroupController_001
660 * @tc.desc: InitBundleGroupController
661 * @tc.type: FUNC
662 * @tc.require: issuesI5SOZY
663 */
664 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_InitBundleGroupController_001,
665 Function | MediumTest | Level0)
666 {
667 auto coreObject = std::make_shared<BundleActiveCore>();
668 coreObject->InitBundleGroupController();
669 }
670
671 /*
672 * @tc.name: DeviceUsageStatisticsServiceTest_ReportEventToAllUserId_001
673 * @tc.desc: ReportEventToAllUserId
674 * @tc.type: FUNC
675 * @tc.require: issuesI5SOZY
676 */
677 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ReportEventToAllUserId_001,
678 Function | MediumTest | Level0)
679 {
680 auto coreObject = std::make_shared<BundleActiveCore>();
681 int userId = 100;
682 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
683 coreObject->userStatServices_[userId] = userService;
684 userId = 101;
685 coreObject->userStatServices_[userId] = nullptr;
686 BundleActiveEvent event;
687 coreObject->ReportEventToAllUserId(event);
688
689 coreObject->Init();
690 coreObject->InitBundleGroupController();
691 coreObject->ReportEventToAllUserId(event);
692 EXPECT_NE(coreObject, nullptr);
693 }
694
695 /*
696 * @tc.name: DeviceUsageStatisticsServiceTest_RestoreToDatabase_001
697 * @tc.desc: RestoreToDatabase
698 * @tc.type: FUNC
699 * @tc.require: issuesI5SOZY
700 */
701 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RestoreToDatabase_001,
702 Function | MediumTest | Level0)
703 {
704 auto coreObject = std::make_shared<BundleActiveCore>();
705 coreObject->bundleGroupController_ = std::make_shared<BundleActiveGroupController>(coreObject->debugCore_);
706 coreObject->InitBundleGroupController();
707
708 int userId = 100;
709 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
710 int64_t timeStamp = 20000000000000;
711 userService->Init(timeStamp);
712 coreObject->userStatServices_[userId] = userService;
713 coreObject->RestoreToDatabase(userId);
714
715 userId = 101;
716 coreObject->RestoreToDatabase(userId);
717 EXPECT_NE(coreObject, nullptr);
718 }
719
720 /*
721 * @tc.name: DeviceUsageStatisticsServiceTest_ShutDown_001
722 * @tc.desc: ShutDown
723 * @tc.type: FUNC
724 * @tc.require: issuesI5SOZY
725 */
726 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ShutDown_001,
727 Function | MediumTest | Level0)
728 {
729 auto coreObject = std::make_shared<BundleActiveCore>();
730 coreObject->Init();
731 coreObject->InitBundleGroupController();
732 coreObject->ShutDown();
733 EXPECT_NE(coreObject, nullptr);
734 }
735
736 /*
737 * @tc.name: DeviceUsageStatisticsServiceTest_CheckTimeChangeAndGetWallTime_001
738 * @tc.desc: CheckTimeChangeAndGetWallTime
739 * @tc.type: FUNC
740 * @tc.require: issuesI5SOZY
741 */
742 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CheckTimeChangeAndGetWallTime_001,
743 Function | MediumTest | Level0)
744 {
745 int userId = 100;
746 auto coreObject = std::make_shared<BundleActiveCore>();
747 coreObject->OnUserRemoved(100);
748 coreObject->Init();
749 coreObject->InitBundleGroupController();
750 auto userService = std::make_shared<BundleActiveUserService>(userId, *(coreObject.get()), false);
751 coreObject->userStatServices_[userId] = userService;
752
753 coreObject->CheckTimeChangeAndGetWallTime(userId);
754 coreObject->OnUserSwitched(userId);
755 EXPECT_NE(coreObject, nullptr);
756 }
757
758 /*
759 * @tc.name: DeviceUsageStatisticsServiceTest_QueryAppGroup_001
760 * @tc.desc: QueryAppGroup
761 * @tc.type: FUNC
762 * @tc.require: issuesI5SOZY
763 */
764 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryAppGroup_001,
765 Function | MediumTest | Level0)
766 {
767 auto groupController = std::make_shared<BundleActiveGroupController>(false);
768 int32_t appGroup = 10;
769 std::string bundleName = "";
770 int32_t userId = 100;
771 EXPECT_NE(groupController->QueryAppGroup(appGroup, bundleName, userId), ERR_OK);
772
773 groupController->sptrBundleMgr_ = nullptr;
774 bundleName = "defaultBundleName";
775 EXPECT_NE(groupController->QueryAppGroup(appGroup, bundleName, userId), ERR_OK);
776 }
777
778 /*
779 * @tc.name: DeviceUsageStatisticsServiceTest_ControllerReportEvent_001
780 * @tc.desc: ControllerReportEvent
781 * @tc.type: FUNC
782 * @tc.require: issuesI5SOZY
783 */
784 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ControllerReportEvent_001,
785 Function | MediumTest | Level0)
786 {
787 auto coreObject = std::make_shared<BundleActiveCore>();
788 coreObject->Init();
789 coreObject->InitBundleGroupController();
790
791 int64_t bootBasedTimeStamp = 20000000000000;
792 BundleActiveEvent event;
793 int32_t userId = 100;
794 coreObject->bundleGroupController_->bundleGroupEnable_ = false;
795 coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId);
796
797 coreObject->bundleGroupController_->bundleGroupEnable_ = true;
798 event.bundleName_ = "com.ohos.camera";
799 coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId);
800
801 event.eventId_ = BundleActiveEvent::NOTIFICATION_SEEN;
802 coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId);
803
804 event.eventId_ = BundleActiveEvent::SYSTEM_INTERACTIVE;
805 coreObject->bundleGroupController_->ReportEvent(event, bootBasedTimeStamp, userId);
806 EXPECT_NE(coreObject, nullptr);
807 }
808
809 /*
810 * @tc.name: DeviceUsageStatisticsServiceTest_CheckAndUpdateGroup_001
811 * @tc.desc: CheckAndUpdateGroup
812 * @tc.type: FUNC
813 * @tc.require: issuesI5SOZY
814 */
815 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_CheckAndUpdateGroup_001,
816 Function | MediumTest | Level0)
817 {
818 auto coreObject = std::make_shared<BundleActiveCore>();
819 coreObject->Init();
820 coreObject->InitBundleGroupController();
821
822 std::string bundleName = "com.ohos.camera";
823 int32_t userId = 100;
824 int64_t bootBasedTimeStamp = 20000000000000;
825 int32_t newGroup = 30;
826 uint32_t reason = GROUP_CONTROL_REASON_TIMEOUT;
827 bool isFlush = false;
828
829 int32_t appGroup = 0;
830 coreObject->bundleGroupController_->QueryAppGroup(appGroup, bundleName, userId);
831
832 coreObject->bundleGroupController_->SetAppGroup(bundleName, userId, newGroup, reason, bootBasedTimeStamp, isFlush);
833 coreObject->bundleGroupController_->CheckAndUpdateGroup(bundleName, userId, bootBasedTimeStamp);
834
835 newGroup = 20;
836 reason = GROUP_CONTROL_REASON_CALCULATED;
837 coreObject->bundleGroupController_->SetAppGroup(bundleName, userId, newGroup, reason, bootBasedTimeStamp, isFlush);
838 coreObject->bundleGroupController_->CheckAndUpdateGroup(bundleName, userId, bootBasedTimeStamp);
839 EXPECT_NE(coreObject, nullptr);
840 }
841
842 /*
843 * @tc.name: DeviceUsageStatisticsServiceTest_PreservePowerStateInfo_001
844 * @tc.desc: PreservePowerStateInfo
845 * @tc.type: FUNC
846 * @tc.require: issuesI5SOZY
847 */
848 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_PreservePowerStateInfo_001,
849 Function | MediumTest | Level0)
850 {
851 auto coreObject = std::make_shared<BundleActiveCore>();
852 coreObject->Init();
853 coreObject->InitBundleGroupController();
854
855 int32_t eventId = BundleActiveEvent::ABILITY_FOREGROUND;
856 coreObject->PreservePowerStateInfo(eventId);
857 EXPECT_NE(coreObject, nullptr);
858 }
859
860 /*
861 * @tc.name: DeviceUsageStatisticsServiceTest_UpdateModuleData_001
862 * @tc.desc: UpdateModuleData
863 * @tc.type: FUNC
864 * @tc.require: issuesI5SOZY
865 */
866 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_UpdateModuleData_001,
867 Function | MediumTest | Level0)
868 {
869 auto database = std::make_shared<BundleActiveUsageDatabase>();
870 auto moduleRecords = std::map<std::string, std::shared_ptr<BundleActiveModuleRecord>>();
871 int64_t timeStamp = 20000000000;
872 int32_t userId = 100;
873 database->UpdateModuleData(userId, moduleRecords, timeStamp);
874 EXPECT_NE(database, nullptr);
875 }
876
877 /*
878 * @tc.name: DeviceUsageStatisticsServiceTest_QueryNotificationEventStats_001
879 * @tc.desc: QueryNotificationEventStats
880 * @tc.type: FUNC
881 * @tc.require: issuesI5SOZY
882 */
883 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryNotificationEventStats_001,
884 Function | MediumTest | Level0)
885 {
886 auto database = std::make_shared<BundleActiveUsageDatabase>();
887
888 int32_t eventId = 2;
889 int64_t beginTime = 0;
890 int64_t endTime = 0;
891 auto notificationEventStats = std::map<std::string, BundleActiveEventStats>();
892 int32_t userId = 100;
893 BUNDLE_ACTIVE_LOGI("database->QueryNotificationEventStats");
894 database->QueryNotificationEventStats(eventId, beginTime, endTime, notificationEventStats, userId);
895 EXPECT_NE(database, nullptr);
896 }
897
898 /*
899 * @tc.name: DeviceUsageStatisticsServiceTest_QueryDeviceEventStats_001
900 * @tc.desc: QueryDeviceEventStats
901 * @tc.type: FUNC
902 * @tc.require: issuesI5SOZY
903 */
904 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryDeviceEventStats_001,
905 Function | MediumTest | Level0)
906 {
907 auto database = std::make_shared<BundleActiveUsageDatabase>();
908
909 int32_t eventId = 2;
910 int64_t beginTime = 0;
911 int64_t endTime = 0;
912 auto eventStats = std::map<std::string, BundleActiveEventStats>();
913 int32_t userId = 100;
914 BUNDLE_ACTIVE_LOGI("database->QueryDeviceEventStats");
915 database->QueryDeviceEventStats(eventId, beginTime, endTime, eventStats, userId);
916 EXPECT_NE(database, nullptr);
917 }
918
919 /*
920 * @tc.name: DeviceUsageStatisticsServiceTest_QueryDatabaseEvents_001
921 * @tc.desc: QueryDatabaseEvents
922 * @tc.type: FUNC
923 * @tc.require: issuesI5SOZY
924 */
925 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_QueryDatabaseEvents_001,
926 Function | MediumTest | Level0)
927 {
928 auto database = std::make_shared<BundleActiveUsageDatabase>();
929
930 int64_t beginTime = 0;
931 int64_t endTime = 0;
932 std::string bundleName;
933 int32_t userId = 100;
934 BUNDLE_ACTIVE_LOGI("database->QueryDatabaseEvents");
935 database->QueryDatabaseEvents(beginTime, endTime, userId, bundleName);
936
937 bundleName = "com.ohos.camera";
938 database->QueryDatabaseEvents(beginTime, endTime, userId, bundleName);
939 EXPECT_NE(database, nullptr);
940 }
941
942 /*
943 * @tc.name: DeviceUsageStatisticsServiceTest_UpdateEventData_001
944 * @tc.desc: UpdateEventData
945 * @tc.type: FUNC
946 * @tc.require: issuesI5SOZY
947 */
948 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_UpdateEventData_001,
949 Function | MediumTest | Level0)
950 {
951 auto database = std::make_shared<BundleActiveUsageDatabase>();
952
953 int32_t databaseType = WEEKLY_DATABASE_INDEX;
954 BundleActivePeriodStats stats;
955 database->UpdateEventData(databaseType, stats);
956
957 databaseType = DAILY_DATABASE_INDEX;
958 database->UpdateEventData(databaseType, stats);
959 EXPECT_NE(database, nullptr);
960 }
961
962 /*
963 * @tc.name: DeviceUsageStatisticsServiceTest_UpdateBundleUsageData_001
964 * @tc.desc: UpdateBundleUsageData
965 * @tc.type: FUNC
966 * @tc.require: issuesI5SOZY
967 */
968 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_UpdateBundleUsageData_001,
969 Function | MediumTest | Level0)
970 {
971 auto database = std::make_shared<BundleActiveUsageDatabase>();
972
973 int32_t databaseType = -1;
974 BundleActivePeriodStats stats;
975 database->UpdateBundleUsageData(databaseType, stats);
976
977 databaseType = EVENT_DATABASE_INDEX;
978 database->UpdateBundleUsageData(databaseType, stats);
979
980 databaseType = DAILY_DATABASE_INDEX;
981 database->UpdateBundleUsageData(databaseType, stats);
982 EXPECT_NE(database, nullptr);
983 }
984
985 /*
986 * @tc.name: DeviceUsageStatisticsServiceTest_RenewTableTime_001
987 * @tc.desc: RenewTableTime
988 * @tc.type: FUNC
989 * @tc.require: issuesI5SOZY
990 */
991 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RenewTableTime_001,
992 Function | MediumTest | Level0)
993 {
994 auto database = std::make_shared<BundleActiveUsageDatabase>();
995
996 int64_t timeDiffMillis = 0;
997 database->sortedTableArray_[0] = {-1, 0};
998 database->RenewTableTime(timeDiffMillis);
999
1000 database->eventTableName_ = "";
1001 database->RenewTableTime(timeDiffMillis);
1002
1003 database->eventTableName_ = "defaultTableName";
1004 database->RenewTableTime(timeDiffMillis);
1005
1006 database->formRecordsTableName_ = "defaultFormRecordsTableName";
1007 database->RenewTableTime(timeDiffMillis);
1008
1009 database->moduleRecordsTableName_ = "defaultModuleRecordsTableName_";
1010 database->RenewTableTime(timeDiffMillis);
1011 EXPECT_NE(database, nullptr);
1012 }
1013
1014 /*
1015 * @tc.name: DeviceUsageStatisticsServiceTest_SetNewIndexWhenTimeChanged_001
1016 * @tc.desc: SetNewIndexWhenTimeChanged
1017 * @tc.type: FUNC
1018 * @tc.require: issuesI5SOZY
1019 */
1020 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_SetNewIndexWhenTimeChanged_001,
1021 Function | MediumTest | Level0)
1022 {
1023 auto database = std::make_shared<BundleActiveUsageDatabase>();
1024
1025 uint32_t databaseType = APP_GROUP_DATABASE_INDEX;
1026 int64_t tableOldTime = 0;
1027 int64_t tableNewTime = 20000000000000;
1028 std::shared_ptr<NativeRdb::RdbStore> rdbStore = nullptr;
1029 EXPECT_NE(database->SetNewIndexWhenTimeChanged(databaseType, tableOldTime, tableNewTime, rdbStore), ERR_OK);
1030
1031 rdbStore = database->GetBundleActiveRdbStore(databaseType);
1032 database->SetNewIndexWhenTimeChanged(databaseType, tableOldTime, tableNewTime, rdbStore);
1033 EXPECT_NE(database, nullptr);
1034 }
1035
1036 /*
1037 * @tc.name: DeviceUsageStatisticsServiceTest_ReportContinuousTaskEvent_001
1038 * @tc.desc: ReportContinuousTaskEvent
1039 * @tc.type: FUNC
1040 * @tc.require: issuesI5SOZY
1041 */
1042 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_ReportContinuousTaskEvent_001,
1043 Function | MediumTest | Level0)
1044 {
1045 #ifdef BGTASKMGR_ENABLE
1046 auto bgtaskObserver = std::make_shared<BundleActiveContinuousTaskObserver>();
1047 auto continuousTaskCallbackInfo = std::shared_ptr<OHOS::BackgroundTaskMgr::ContinuousTaskCallbackInfo>();
1048 continuousTaskCallbackInfo->creatorUid_ = 20000000;
1049 bool isStart = false;
1050 bgtaskObserver->ReportContinuousTaskEvent(continuousTaskCallbackInfo, isStart);
1051
1052 isStart = true;
1053 bgtaskObserver->ReportContinuousTaskEvent(continuousTaskCallbackInfo, isStart);
1054 EXPECT_NE(bgtaskObserver, nullptr);
1055 #endif
1056 }
1057
1058 /*
1059 * @tc.name: DeviceUsageStatisticsServiceTest_RemoveFormData_001
1060 * @tc.desc: RemoveFormData
1061 * @tc.type: FUNC
1062 * @tc.require: issuesI5SOZY
1063 */
1064 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_RemoveFormData_001,
1065 Function | MediumTest | Level0)
1066 {
1067 auto database = std::make_shared<BundleActiveUsageDatabase>();
1068 int32_t userId = 100;
1069 std::string bundleName = "defaultBundleName";
1070 std::string moduleName = "defaultModuleName";
1071 std::string formName = "defaultFormName";
1072 database->InitUsageGroupDatabase(0, true);
1073 database->RemoveFormData(userId, bundleName, moduleName, formName, 0, 0);
1074 EXPECT_NE(database, nullptr);
1075 }
1076
1077 /*
1078 * @tc.name: DeviceUsageStatisticsServiceTest_UpdateFormData_001
1079 * @tc.desc: UpdateFormData
1080 * @tc.type: FUNC
1081 * @tc.require: issuesI5SOZY
1082 */
1083 HWTEST_F(DeviceUsageStatisticsServiceTest, DeviceUsageStatisticsServiceTest_UpdateFormData_001,
1084 Function | MediumTest | Level0)
1085 {
1086 auto database = std::make_shared<BundleActiveUsageDatabase>();
1087 int32_t userId = 100;
1088 std::string bundleName = "defaultBundleName";
1089 std::string moduleName = "defaultModuleName";
1090 std::string formName = "defaultFormName";
1091 database->InitUsageGroupDatabase(0, true);
1092 BundleActiveFormRecord formRecord;
1093 auto rdbStore = database->GetBundleActiveRdbStore(0);
1094 database->UpdateFormData(userId, bundleName, moduleName, formRecord, rdbStore);
1095 EXPECT_NE(database, nullptr);
1096 }
1097 } // namespace DeviceUsageStats
1098 } // namespace OHOS