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