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 #include <gtest/gtest.h>
17 #include "system_ability_definition.h"
18
19 #include "bundle_active_client.h"
20 #include "bundle_active_event.h"
21 #include "bundle_active_service.h"
22 #include "bundle_active_group_map.h"
23 #include "app_group_callback_stub.h"
24 #include "app_group_callback_info.h"
25 #include "iapp_group_callback.h"
26 #include "bundle_active_constant.h"
27 #include "bundle_active_usage_database.h"
28 #include "bundle_active_test_util.h"
29 #include "bundle_active_high_frequency_period.h"
30
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace DeviceUsageStats {
35 static std::string g_defaultBundleName = "com.ohos.camera";
36 static std::string g_defaultMoudleName = "defaultmodulename";
37 static std::string g_defaultFormName = "defaultformname";
38 static int32_t g_defaultDimension = 4;
39 static int64_t g_defaultFormId = 1;
40 static int32_t g_defaultUserId = 0;
41 static int32_t g_commonUserid = 100;
42 static int64_t g_largeNum = 20000000000000;
43 static int32_t g_defaultGroup = 10;
44 static int32_t g_intervalType = 4;
45 static sptr<IAppGroupCallback> observer = nullptr;
46
47 class DeviceUsageStatisticsMockTest : public testing::Test {
48 public:
49 static void SetUpTestCase(void);
50 static void TearDownTestCase(void);
51 void SetUp();
52 void TearDown();
53 };
54
SetUpTestCase(void)55 void DeviceUsageStatisticsMockTest::SetUpTestCase(void)
56 {
57 BundleActiveTestUtil::TestInit();
58 }
59
TearDownTestCase(void)60 void DeviceUsageStatisticsMockTest::TearDownTestCase(void)
61 {
62 BundleActiveTestUtil::TestDeInit();
63 }
64
SetUp(void)65 void DeviceUsageStatisticsMockTest::SetUp(void)
66 {
67 }
68
TearDown(void)69 void DeviceUsageStatisticsMockTest::TearDown(void)
70 {
71 }
72
73 /*
74 * @tc.name: DeviceUsageStatisticsMockTest_GetBundleActiveProxy_001
75 * @tc.desc: test client getBundleActiveProxy boundary condition
76 * @tc.type: FUNC
77 * @tc.require: issuesI5SOZY
78 */
79 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_GetBundleActiveProxy_001,
80 Function | MediumTest | TestSize.Level0)
81 {
82 BundleActiveEvent eventA(g_defaultBundleName, g_defaultMoudleName, g_defaultFormName,
83 g_defaultDimension, g_defaultFormId, BundleActiveEvent::FORM_IS_CLICKED);
84 EXPECT_NE(BundleActiveClient::GetInstance().ReportEvent(eventA, g_defaultUserId), ERR_OK);
85
86 bool isIdle = false;
87 bool isUsePeriod = false;
88 EXPECT_NE(BundleActiveClient::GetInstance().IsBundleIdle(isIdle, g_defaultBundleName, g_defaultUserId), ERR_OK);
89 EXPECT_NE(BundleActiveClient::GetInstance().IsBundleUsePeriod(isUsePeriod, g_defaultBundleName, g_defaultUserId),
90 ERR_OK);
91
92 std::vector<BundleActivePackageStats> packageStats;
93 EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleStatsInfoByInterval(packageStats,
94 g_intervalType, 0, g_largeNum), ERR_OK);
95 EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleStatsInfos(packageStats,
96 g_intervalType, 0, g_largeNum), ERR_OK);
97
98 std::vector<BundleActiveEvent> event;
99 EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleEvents(event, 0, g_largeNum, 100), ERR_OK);
100 EXPECT_NE(BundleActiveClient::GetInstance().QueryCurrentBundleEvents(event, 0, g_largeNum), ERR_OK);
101
102 int32_t result = 0;
103 EXPECT_NE(BundleActiveClient::GetInstance().QueryAppGroup(result, g_defaultBundleName, g_commonUserid), ERR_OK);
104
105 EXPECT_NE(BundleActiveClient::GetInstance().SetAppGroup(
106 g_defaultBundleName, g_defaultGroup, g_commonUserid), ERR_OK);
107
108 EXPECT_NE(BundleActiveClient::GetInstance().RegisterAppGroupCallBack(observer), ERR_OK);
109 EXPECT_NE(BundleActiveClient::GetInstance().UnRegisterAppGroupCallBack(observer), ERR_OK);
110
111 std::vector<BundleActiveEventStats> eventStats;
112 EXPECT_NE(BundleActiveClient::GetInstance().QueryDeviceEventStats(0, g_largeNum, eventStats), ERR_OK);
113 EXPECT_NE(BundleActiveClient::GetInstance().QueryNotificationEventStats(0, g_largeNum, eventStats), ERR_OK);
114
115 std::vector<BundleActiveModuleRecord> moduleRecord;
116 int32_t maxNum = 1000;
117 EXPECT_NE(BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, moduleRecord, g_defaultUserId), ERR_OK);
118 std::vector<BundleActiveHighFrequencyPeriod> appFreqHours;
119 EXPECT_NE(BundleActiveClient::GetInstance().QueryHighFrequencyPeriodBundle(appFreqHours, g_defaultUserId), ERR_OK);
120 int64_t latestUsedTime;
121 EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleTodayLatestUsedTime(
122 latestUsedTime, g_defaultBundleName, g_commonUserid), ERR_OK);
123 }
124
125 /*
126 * @tc.name: DeviceUsageStatisticsMockTest_GetBundleMgrProxy_001
127 * @tc.desc: test service getBundleMgrProxy boundary condition
128 * @tc.type: FUNC
129 * @tc.require: issuesI5SOZY
130 */
131 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_GetBundleMgrProxy_001,
132 Function | MediumTest | TestSize.Level0)
133 {
134 std::string bundleName;
135 bool isBundleIdle = false;
136 bool isUsePeriod = false;
137 ErrCode code = DelayedSingleton<BundleActiveService>::GetInstance()->IsBundleIdle(isBundleIdle, bundleName, -1);
138 EXPECT_NE(code, ERR_OK);
139 code = DelayedSingleton<BundleActiveService>::GetInstance()->
140 IsBundleUsePeriod(isUsePeriod, bundleName, -1);
141 EXPECT_NE(code, ERR_OK);
142
143 code = DelayedSingleton<BundleActiveService>::GetInstance()->CheckBundleIsSystemAppAndHasPermission(100, 100000);
144 EXPECT_NE(code, ERR_OK);
145 }
146
147 /*
148 * @tc.name: DeviceUsageStatisticsMockTest_QueryDeviceEventStats_001
149 * @tc.desc: test service queryDeviceEventStats boundary condition
150 * @tc.type: FUNC
151 * @tc.require: issuesI5SOZY
152 */
153 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryDeviceEventStats_001,
154 Function | MediumTest | TestSize.Level0)
155 {
156 std::vector<BundleActiveEventStats> eventStats;
157 ErrCode code =
158 DelayedSingleton<BundleActiveService>::GetInstance()->QueryDeviceEventStats(0, g_largeNum, eventStats, -1);
159 EXPECT_NE(code, ERR_OK);
160 }
161
162 /*
163 * @tc.name: DeviceUsageStatisticsMockTest_QueryNotificationEventStats_001
164 * @tc.desc: test service queryNotificationEventStats boundary condition
165 * @tc.type: FUNC
166 * @tc.require: issuesI5SOZY
167 */
168 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryNotificationEventStats_001,
169 Function | MediumTest | TestSize.Level0)
170 {
171 std::vector<BundleActiveEventStats> eventStats;
172 ErrCode code = DelayedSingleton<BundleActiveService>::GetInstance()->QueryNotificationEventStats(
173 0, g_largeNum, eventStats, -1);
174 EXPECT_NE(code, ERR_OK);
175 }
176
177 /*
178 * @tc.name: DeviceUsageStatisticsMockTest_QueryModuleUsageRecords_001
179 * @tc.desc: test service queryModuleUsageRecords boundary condition
180 * @tc.type: FUNC
181 * @tc.require: issuesI5SOZY
182 */
183 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryModuleUsageRecords_001,
184 Function | MediumTest | TestSize.Level0)
185 {
186 std::vector<BundleActiveModuleRecord> records;
187 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->QueryModuleUsageRecords(1000, records, -1), ERR_OK);
188
189 BundleActiveModuleRecord bundleActiveModuleRecord;
190 DelayedSingleton<BundleActiveService>::GetInstance()->QueryModuleRecordInfos(bundleActiveModuleRecord);
191 }
192
193 /*
194 * @tc.name: DeviceUsageStatisticsMockTest_QueryAppGroup_001
195 * @tc.desc: test service queryAppGroup boundary condition
196 * @tc.type: FUNC
197 * @tc.require: issuesI5SOZY
198 */
199 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryAppGroup_001,
200 Function | MediumTest | TestSize.Level0)
201 {
202 int32_t appGroup;
203 std::string bundleName;
204 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->QueryAppGroup(appGroup, bundleName, -1), ERR_OK);
205 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->QueryAppGroup(appGroup, bundleName, 100), ERR_OK);
206 }
207
208 /*
209 * @tc.name: DeviceUsageStatisticsMockTest_SetAppGroup_001
210 * @tc.desc: test service SetAppGroup boundary condition
211 * @tc.type: FUNC
212 * @tc.require: issuesI5SOZY
213 */
214 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_SetAppGroup_001,
215 Function | MediumTest | TestSize.Level0)
216 {
217 int32_t appGroup = 100;
218 std::string bundleName;
219 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->SetAppGroup(bundleName, appGroup, -1), ERR_OK);
220 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->SetAppGroup(bundleName, appGroup, 100), ERR_OK);
221 }
222
223 /*
224 * @tc.name: DeviceUsageStatisticsMockTest_AppGroupCallback_001
225 * @tc.desc: test service appGroupCallback boundary condition
226 * @tc.type: FUNC
227 * @tc.require: issuesI5SOZY
228 */
229 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_AppGroupCallback_001,
230 Function | MediumTest | TestSize.Level0)
231 {
232 sptr<IAppGroupCallback> observer = nullptr;
233 DelayedSingleton<BundleActiveService>::GetInstance()->bundleActiveCore_ = nullptr;
234 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->RegisterAppGroupCallBack(observer), ERR_OK);
235 EXPECT_NE(DelayedSingleton<BundleActiveService>::GetInstance()->UnRegisterAppGroupCallBack(observer), ERR_OK);
236 }
237
238 /*
239 * @tc.name: DeviceUsageStatisticsMockTest_QueryBundleEvents_001
240 * @tc.desc: test service queryBundleEvents boundary condition
241 * @tc.type: FUNC
242 * @tc.require: issuesI5SOZY
243 */
244 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryBundleEvents_001,
245 Function | MediumTest | TestSize.Level0)
246 {
247 std::vector<BundleActiveEvent> bundleActiveEvents;
248 ErrCode code = DelayedSingleton<BundleActiveService>::GetInstance()
249 ->QueryBundleEvents(bundleActiveEvents, 0, g_largeNum, -1);
250 EXPECT_NE(code, ERR_OK);
251 code = DelayedSingleton<BundleActiveService>::GetInstance()
252 ->QueryCurrentBundleEvents(bundleActiveEvents, 0, g_largeNum);
253 EXPECT_NE(code, ERR_OK);
254 }
255
256 /*
257 * @tc.name: DeviceUsageStatisticsMockTest_QueryBundleStatsInfoByInterval_001
258 * @tc.desc: test service queryBundleStatsInfoByInterval boundary condition
259 * @tc.type: FUNC
260 * @tc.require: issuesI5SOZY
261 */
262 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryBundleStatsInfoByInterval_001,
263 Function | MediumTest | TestSize.Level0)
264 {
265 std::vector<BundleActivePackageStats> packageStats;
266 ErrCode code = DelayedSingleton<BundleActiveService>::GetInstance()
267 ->QueryBundleStatsInfoByInterval(packageStats, 0, 0, g_largeNum, -1);
268 EXPECT_NE(code, ERR_OK);
269 }
270
271 /*
272 * @tc.name: DeviceUsageStatisticsMockTest_QueryBundleStatsInfos_001
273 * @tc.desc: test service queryBundleStatsInfos boundary condition
274 * @tc.type: FUNC
275 * @tc.require: issuesI5SOZY
276 */
277 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryBundleStatsInfos_001,
278 Function | MediumTest | TestSize.Level0)
279 {
280 std::vector<BundleActivePackageStats> packageStats;
281 ErrCode code = DelayedSingleton<BundleActiveService>::GetInstance()
282 ->QueryBundleStatsInfos(packageStats, 0, 0, g_largeNum);
283 EXPECT_NE(code, ERR_OK);
284 }
285
286 /*
287 * @tc.name: DeviceUsageStatisticsMockTest_QueryBundleStatsInfos_001
288 * @tc.desc: test service queryBundleStatsInfos boundary condition
289 * @tc.type: FUNC
290 * @tc.require: issuesI5SOZY
291 */
292 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_CheckTimeChangeAndGetWallTime_001,
293 Function | MediumTest | TestSize.Level0)
294 {
295 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
296
297 BundleActiveEvent event;
298 event.bundleName_ = "com.ohos.settings";
299 int32_t userId = 101;
300 EXPECT_NE(bundleActiveCore->ReportEvent(event, userId), ERR_OK);
301
302 EXPECT_NE(bundleActiveCore->ReportEventToAllUserId(event), ERR_OK);
303
304 std::vector<BundleActiveEventStats> eventStats;
305 EXPECT_NE(bundleActiveCore->QueryNotificationEventStats(0, g_largeNum, eventStats, g_defaultUserId), ERR_OK);
306 EXPECT_NE(bundleActiveCore->QueryDeviceEventStats(0, g_largeNum, eventStats, g_defaultUserId), ERR_OK);
307
308 std::vector<BundleActiveModuleRecord> moduleRecords;
309 EXPECT_NE(bundleActiveCore->QueryModuleUsageRecords(1000, moduleRecords, g_defaultUserId), ERR_OK);
310
311 std::vector<BundleActiveEvent> activeEvent;
312 ErrCode code = bundleActiveCore->QueryBundleEvents(
313 activeEvent, g_defaultUserId, 0, g_largeNum, g_defaultBundleName);
314 EXPECT_NE(code, ERR_OK);
315
316 std::vector<BundleActivePackageStats> packageStats;
317 code = bundleActiveCore->QueryBundleStatsInfos(
318 packageStats, g_defaultUserId, g_intervalType, 0, g_largeNum, g_defaultBundleName);
319 EXPECT_NE(code, ERR_OK);
320
321 BundleActiveEvent eventTemp;
322 EXPECT_NE(bundleActiveCore->ReportEventToAllUserId(eventTemp), ERR_OK);
323 int32_t uid = 0;
324 int32_t appIndex = 0;
325 bundleActiveCore->OnBundleUninstalled(g_defaultUserId, g_defaultBundleName, uid, appIndex);
326
327 EXPECT_NE(bundleActiveCore->QueryNotificationEventStats(0, g_largeNum, eventStats, g_commonUserid), ERR_OK);
328 EXPECT_NE(bundleActiveCore->QueryDeviceEventStats(0, g_largeNum, eventStats, g_commonUserid), ERR_OK);
329 EXPECT_NE(bundleActiveCore->QueryModuleUsageRecords(1000, moduleRecords, g_commonUserid), ERR_OK);
330
331 code = bundleActiveCore->QueryBundleEvents(activeEvent, g_commonUserid, 0, g_largeNum, g_defaultBundleName);
332 EXPECT_NE(code, ERR_OK);
333
334 code = bundleActiveCore->QueryBundleStatsInfos(packageStats, g_commonUserid,
335 g_intervalType, 0, g_largeNum, g_defaultBundleName);
336 EXPECT_NE(code, ERR_OK);
337
338 bundleActiveCore->OnBundleUninstalled(g_commonUserid, g_defaultBundleName, uid, appIndex);
339 }
340
341 /*
342 * @tc.name: DeviceUsageStatisticsMockTest_getUserHistory_001
343 * @tc.desc: test service getUserHistory boundary condition
344 * @tc.type: FUNC
345 * @tc.require: issuesI5SOZY
346 */
347 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_getUserHistory_001,
348 Function | MediumTest | TestSize.Level0)
349 {
350 auto groupController = std::make_shared<BundleActiveGroupController>();
351 const int64_t timeStamp = g_largeNum;
352 int32_t uid = 0;
353 int32_t appIndex = 0;
354 auto bundleActiveCore = std::make_shared<BundleActiveCore>();
355 groupController->bundleUserHistory_ = std::make_shared<BundleActiveUserHistory>(timeStamp, bundleActiveCore);
356
357 groupController->OnBundleUninstalled(0, g_defaultBundleName, uid, appIndex);
358 EXPECT_NE(groupController, nullptr);
359 }
360
361 /*
362 * @tc.name: DeviceUsageStatisticsMockTest_calculationTimeOut_001
363 * @tc.desc: test service calculationTimeOut boundary condition
364 * @tc.type: FUNC
365 * @tc.require: issuesI5SOZY
366 */
367 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_calculationTimeOut_001,
368 Function | MediumTest | TestSize.Level0)
369 {
370 auto groupController = std::make_shared<BundleActiveGroupController>();
371
372 std::shared_ptr<BundleActivePackageHistory> history = nullptr;
373 groupController->calculationTimeOut(history, g_largeNum);
374 history = std::make_shared<BundleActivePackageHistory>();
375 groupController->calculationTimeOut(history, g_largeNum);
376 EXPECT_NE(groupController, nullptr);
377 }
378
379 /*
380 * @tc.name: DeviceUsageStatisticsMockTest_QueryStatsInfoByStep_001
381 * @tc.desc: test QueryStatsInfoByStep
382 * @tc.type: FUNC
383 * @tc.require: issuesI5SOZY
384 */
385 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryStatsInfoByStep_001,
386 Function | MediumTest | TestSize.Level0)
387 {
388 auto database = std::make_shared<BundleActiveUsageDatabase>();
389
390 int32_t databaseType = DAILY_DATABASE_INDEX;
391 bool forModuleRecords = true;
392 database->InitUsageGroupDatabase(databaseType, forModuleRecords);
393
394 database->HandleTableInfo(databaseType);
395 int64_t currentTimeMillis = 20000000000000;
396 database->GetOverdueTableCreateTime(databaseType, currentTimeMillis);
397
398 int32_t userId = 100;
399 database->GetBundleHistoryData(userId);
400
401 database->GetDurationData();
402
403 database->GetCurrentUsageData(databaseType, userId);
404
405 int64_t beginTime = 0;
406 int64_t endTime = 20000000000000;
407 database->QueryDatabaseUsageStats(databaseType, beginTime, endTime, userId);
408
409 std::string bundleName = "defaultBundleName";
410 database->QueryDatabaseEvents(beginTime, endTime, userId, bundleName);
411
412 std::map<std::string, std::shared_ptr<BundleActiveModuleRecord>> moduleRecords;
413 database->LoadModuleData(userId, moduleRecords);
414
415 database->LoadFormData(userId, moduleRecords);
416
417 std::map<std::string, BundleActiveEventStats> eventStats;
418 int32_t eventId = 2;
419 database->QueryDeviceEventStats(eventId, beginTime, endTime, eventStats, userId);
420
421 database->QueryNotificationEventStats(eventId, beginTime, endTime, eventStats, userId);
422 }
423
424 /*
425 * @tc.name: DeviceUsageStatisticsMockTest_GetBundleActiveRdbStore_001
426 * @tc.desc: test GetBundleActiveRdbStore
427 * @tc.type: FUNC
428 * @tc.require: issuesI5SOZY
429 */
430 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_GetBundleActiveRdbStore_001,
431 Function | MediumTest | TestSize.Level0)
432 {
433 auto database = std::make_shared<BundleActiveUsageDatabase>();
434 int32_t databaseType = EVENT_DATABASE_INDEX;
435 database->DeleteExcessiveTableData(databaseType);
436 database->DeleteInvalidTable(databaseType, 0);
437 database->CreateEventLogTable(databaseType, 0);
438 database->CreatePackageLogTable(databaseType, 0);
439 database->CreateModuleRecordTable(databaseType, 0);
440 database->CreateFormRecordTable(databaseType, 0);
441 database->CreateDurationTable(databaseType);
442 database->CreateBundleHistoryTable(databaseType);
443
444 int32_t userId = 100;
445 auto userHistory = std::make_shared<std::map<std::string, std::shared_ptr<BundleActivePackageHistory>>>();
446 database->PutBundleHistoryData(userId, userHistory);
447
448 int64_t bootBasedDuration = 0;
449 int64_t screenOnDuration = 20000000000;
450 database->PutDurationData(bootBasedDuration, screenOnDuration);
451
452 BundleActivePeriodStats stats;
453 database->FlushPackageInfo(databaseType, stats);
454 database->FlushEventInfo(databaseType, stats);
455 database->RenameTableName(databaseType, 0, 0);
456 std::string bundleName = "defaultBundleName";
457 std::string tableName = "defaultTableName";
458 int32_t uid = 0;
459 int32_t appIndex = 0;
460 database->DeleteUninstalledInfo(userId, bundleName, uid, tableName, databaseType, appIndex);
461
462 auto moduleRecords = std::map<std::string, std::shared_ptr<BundleActiveModuleRecord>>();
463 int64_t timeStamp = 20000000000;
464 database->UpdateModuleData(userId, moduleRecords, timeStamp);
465
466 std::string moduleName = "defaultMoudleName";
467 std::string formName = "defaultFormName";
468 database->RemoveFormData(userId, bundleName, moduleName, formName, 0, 0, uid);
469 }
470
471 /*
472 * @tc.name: DeviceUsageStatisticsMockTest_QueryHighFrequencyPeriodBundle_001
473 * @tc.desc: test QueryHighFrequencyPeriodBundle
474 * @tc.type: FUNC
475 * @tc.require: SR20250319441801 AR20250322520501
476 */
477 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryHighFrequencyPeriodBundle_001,
478 Function | MediumTest | TestSize.Level0)
479 {
480 std::vector<BundleActiveHighFrequencyPeriod> appFreqHours;
481 ErrCode code =
482 DelayedSingleton<BundleActiveService>::GetInstance()->QueryHighFrequencyPeriodBundle(appFreqHours, 0);
483 EXPECT_NE(code, ERR_OK);
484
485 code =
486 DelayedSingleton<BundleActiveService>::GetInstance()->QueryHighFrequencyPeriodBundle(appFreqHours, -1);
487 EXPECT_NE(code, ERR_OK);
488 }
489
490 /*
491 * @tc.name: DeviceUsageStatisticsMockTest_QueryBundleTodayLatestUsedTime_001
492 * @tc.desc: test QueryHighFrequencyPeriodBundle
493 * @tc.type: FUNC
494 * @tc.require: SR20250319441801 AR20250322520501
495 */
496 HWTEST_F(DeviceUsageStatisticsMockTest, DeviceUsageStatisticsMockTest_QueryBundleTodayLatestUsedTime_001,
497 Function | MediumTest | TestSize.Level0)
498 {
499 int64_t latestUsedTime = 0;
500 ErrCode code =
501 DelayedSingleton<BundleActiveService>::GetInstance()->QueryBundleTodayLatestUsedTime(latestUsedTime, "test", 0);
502 EXPECT_NE(code, ERR_OK);
503 EXPECT_EQ(latestUsedTime, 0);
504 code = DelayedSingleton<BundleActiveService>::GetInstance()->QueryBundleTodayLatestUsedTime(
505 latestUsedTime, "test", -1);
506 EXPECT_NE(code, ERR_OK);
507 }
508 } // namespace DeviceUsageStats
509 } // namespace OHOS
510
511