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 <string>
17
18 #include <gtest/gtest.h>
19 #include "system_ability_definition.h"
20
21 #include "bundle_active_client.h"
22 #include "bundle_active_event.h"
23 #include "app_group_callback_stub.h"
24 #include "bundle_active_group_map.h"
25 #include "app_group_callback_info.h"
26 #include "bundle_active_form_record.h"
27 #include "bundle_active_event_stats.h"
28 #include "bundle_active_module_record.h"
29 #include "bundle_active_package_stats.h"
30 #include "app_group_callback_proxy.h"
31 #include "iapp_group_callback.h"
32 #include "bundle_active_log.h"
33 #include "accesstoken_kit.h"
34 #include "token_setproc.h"
35 #include "nativetoken_kit.h"
36 #include "bundle_active_test_util.h"
37 #include "bundle_active_high_frequency_period.h"
38
39 using namespace testing::ext;
40
41 namespace OHOS {
42 namespace DeviceUsageStats {
43 using namespace Security::AccessToken;
44 static std::string g_defaultBundleName = "com.ohos.contacts";
45 static std::string g_defaultMoudleName = "defaultmodulename";
46 static std::string g_defaultFormName = "defaultformname";
47 static int32_t g_defaultDimension = 4;
48 static int64_t g_defaultFormId = 1;
49 static int32_t g_defaultUserId = 0;
50 static int32_t g_commonUserid = 100;
51 static int32_t DEFAULT_ERRCODE = 0;
52 static int64_t g_largeNum = 20000000000000;
53 static int32_t g_defaultGroup = 10;
54 static std::vector<int32_t> GROUP_TYPE {10, 20, 30, 40, 50};
55 static sptr<IAppGroupCallback> observer = nullptr;
56
57 class DeviceUsageStatisticsTest : public testing::Test {
58 public:
59 static void SetUpTestCase(void);
60 static void TearDownTestCase(void);
61 void SetUp();
62 void TearDown();
63 };
64
SetUpTestCase(void)65 void DeviceUsageStatisticsTest::SetUpTestCase(void)
66 {
67 static const char *perms[] = {
68 "ohos.permission.BUNDLE_ACTIVE_INFO",
69 };
70 uint64_t tokenId;
71 NativeTokenInfoParams infoInstance = {
72 .dcapsNum = 0,
73 .permsNum = 1,
74 .aclsNum = 0,
75 .dcaps = nullptr,
76 .perms = perms,
77 .acls = nullptr,
78 .processName = "DeviceUsageStatisticsTest",
79 .aplStr = "system_core",
80 };
81 tokenId = GetAccessTokenId(&infoInstance);
82 SetSelfTokenID(tokenId);
83 AccessTokenKit::ReloadNativeTokenInfo();
84 BundleActiveTestUtil::TestInit();
85 }
86
TearDownTestCase(void)87 void DeviceUsageStatisticsTest::TearDownTestCase(void)
88 {
89 BundleActiveTestUtil::TestDeInit();
90 }
91
SetUp(void)92 void DeviceUsageStatisticsTest::SetUp(void)
93 {
94 }
95
TearDown(void)96 void DeviceUsageStatisticsTest::TearDown(void)
97 {
98 }
99
100 class TestAppGroupChangeCallback : public AppGroupCallbackStub {
101 public:
102 TestAppGroupChangeCallback() = default;
103 virtual ~TestAppGroupChangeCallback() = default;
104 ErrCode OnAppGroupChanged(const AppGroupCallbackInfo &appGroupCallbackInfo) override;
105 };
106
OnAppGroupChanged(const AppGroupCallbackInfo & appGroupCallbackInfo)107 ErrCode TestAppGroupChangeCallback::OnAppGroupChanged(const AppGroupCallbackInfo &appGroupCallbackInfo)
108 {
109 BUNDLE_ACTIVE_LOGI("TestAppGroupChangeCallback::OnAppGroupChanged!");
110 MessageParcel data;
111 if (!appGroupCallbackInfo.Marshalling(data)) {
112 BUNDLE_ACTIVE_LOGE("Marshalling fail");
113 }
114 appGroupCallbackInfo.Unmarshalling(data);
115 return ERR_OK;
116 }
117
118 /*
119 * @tc.name: DeviceUsageStatisticsTest_GetServiceObject_001
120 * @tc.desc: get service object
121 * @tc.type: FUNC
122 * @tc.require: SR000GGTO8 AR000GH6PK
123 */
124 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_GetServiceObject_001,
125 Function | MediumTest | TestSize.Level0)
126 {
127 sptr<ISystemAbilityManager> systemAbilityManager =
128 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
129 EXPECT_NE(systemAbilityManager, nullptr);
130
131 sptr<IRemoteObject> remoteObject =
132 systemAbilityManager->GetSystemAbility(DEVICE_USAGE_STATISTICS_SYS_ABILITY_ID);
133 EXPECT_NE(remoteObject, nullptr);
134 }
135
136 /*
137 * @tc.name: DeviceUsageStatisticsTest_ReportEvent_001
138 * @tc.desc: report a mock event
139 * @tc.type: FUNC
140 * @tc.require: SR000GGTO7 SR000GU31B AR000GH6PJ AR000GU380
141 */
142 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_ReportEvent_001, Function | MediumTest | TestSize.Level0)
143 {
144 BundleActiveEvent eventA(g_defaultBundleName, g_defaultMoudleName, g_defaultFormName,
145 g_defaultDimension, g_defaultFormId, BundleActiveEvent::FORM_IS_CLICKED);
146 BundleActiveClient::GetInstance().ReportEvent(eventA, g_defaultUserId);
147 BundleActiveEvent eventB(g_defaultBundleName, g_defaultMoudleName, g_defaultFormName,
148 g_defaultDimension, g_defaultFormId, BundleActiveEvent::FORM_IS_REMOVED);
149 BundleActiveClient::GetInstance().ReportEvent(eventB, g_defaultUserId);
150 EXPECT_TRUE(BundleActiveClient::GetInstance().bundleActiveProxy_ != nullptr);
151 }
152
153 /*
154 * @tc.name: DeviceUsageStatisticsTest_QueryBundleEvents_001
155 * @tc.desc: QueryBundleEvents
156 * @tc.type: FUNC
157 * @tc.require: SR000GGTO6 AR000GH6PH
158 */
159 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryBundleEvents_001,
160 Function | MediumTest | TestSize.Level0)
161 {
162 std::vector<BundleActiveEvent> result;
163 BundleActiveClient::GetInstance().QueryBundleEvents(result, 0, g_largeNum, 100);
164 EXPECT_EQ(result.size() > 0, true);
165 EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleEvents(result, g_largeNum, g_largeNum, 100), 0);
166 }
167
168 /*
169 * @tc.name: DeviceUsageStatisticsTest_QueryCurrentBundleEvents_001
170 * @tc.desc: QueryCurrentBundleEvents
171 * @tc.type: FUNC
172 * @tc.require: SR000GGTO4 AR000GH6PF
173 */
174 HWTEST_F(DeviceUsageStatisticsTest,
175 DeviceUsageStatisticsTest_QueryCurrentBundleEvents_001, Function | MediumTest | TestSize.Level0)
176 {
177 std::vector<BundleActiveEvent> result;
178 BundleActiveClient::GetInstance().QueryCurrentBundleEvents(result, 0, g_largeNum);
179 EXPECT_EQ(result.size(), 0);
180 }
181
182 /*
183 * @tc.name: DeviceUsageStatisticsTest_QueryPackagesStats_001
184 * @tc.desc: querypackagestats
185 * @tc.type: FUNC
186 * @tc.require: SR000GGTO3 AR000GH6PD
187 */
188 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryPackagesStats_001,
189 Function | MediumTest | TestSize.Level0)
190 {
191 std::vector<BundleActivePackageStats> result;
192 BundleActiveClient::GetInstance().QueryBundleStatsInfoByInterval(result, 4, 0, g_largeNum);
193 EXPECT_EQ(result.size(), 0);
194 EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleStatsInfoByInterval(result, 4, g_largeNum, g_largeNum), 0);
195 }
196
197 /*
198 * @tc.name: DeviceUsageStatisticsTest_QueryBundleStatsInfos_001
199 * @tc.desc: QueryBundleStatsInfos
200 * @tc.type: FUNC
201 * @tc.require: issuesI5QJD9
202 */
203 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryBundleStatsInfos_001,
204 Function | MediumTest | TestSize.Level0)
205 {
206 std::vector<BundleActivePackageStats> result;
207 BundleActiveClient::GetInstance().QueryBundleStatsInfos(result, 4, 0, g_largeNum);
208 EXPECT_EQ(result.size(), 0);
209 }
210
211 /*
212 * @tc.name: DeviceUsageStatisticsTest_IsBundleIdle_001
213 * @tc.desc: isbundleidle
214 * @tc.type: FUNC
215 * @tc.require: SR000GGTO5 AR000GH6PG
216 */
217 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_IsBundleIdle_001,
218 Function | MediumTest | TestSize.Level0)
219 {
220 bool result = false;
221 int32_t errCode = BundleActiveClient::GetInstance().IsBundleIdle(result, g_defaultBundleName, g_defaultUserId);
222 EXPECT_EQ(errCode, 0);
223 }
224
225 /*
226 * @tc.name: DeviceUsageStatisticsTest_IsBundleUsePeriod_001
227 * @tc.desc: IsBundleUsePeriod
228 * @tc.type: FUNC
229 * @tc.require: issueIBB2G4
230 */
231 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_IsBundleUsePeriod_001,
232 Function | MediumTest | TestSize.Level0)
233 {
234 bool result = false;
235 int32_t errCode = BundleActiveClient::GetInstance().IsBundleUsePeriod(result, g_defaultBundleName, g_defaultUserId);
236 EXPECT_EQ(errCode, 0);
237 }
238
239 /*
240 * @tc.name: DeviceUsageStatisticsTest_QueryModuleUsageRecords_001
241 * @tc.desc: QueryModuleUsageRecords
242 * @tc.type: FUNC
243 * @tc.require: SR000GU2T1 AR000GU37U
244 */
245 HWTEST_F(DeviceUsageStatisticsTest,
246 DeviceUsageStatisticsTest_QueryModuleUsageRecords_001, Function | MediumTest | TestSize.Level0)
247 {
248 int32_t maxNum = 1;
249 BundleActiveEvent eventA(g_defaultBundleName, g_defaultMoudleName, g_defaultFormName,
250 g_defaultDimension, g_defaultFormId, BundleActiveEvent::FORM_IS_CLICKED);
251 BundleActiveClient::GetInstance().ReportEvent(eventA, g_defaultUserId);
252 std::vector<BundleActiveModuleRecord> results;
253 int32_t errCode = BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, results, g_defaultUserId);
254 EXPECT_EQ(errCode, 0);
255 EXPECT_EQ(results.size(), 0);
256
257 results.clear();
258 maxNum = 0;
259 errCode = BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, results, g_defaultUserId);
260 EXPECT_NE(errCode, 0);
261
262 results.clear();
263 maxNum = 1001;
264 errCode = BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, results, g_defaultUserId);
265 EXPECT_NE(errCode, 0);
266 }
267
268 /*
269 * @tc.name: DeviceUsageStatisticsTest_RegisterAppGroupCallBack_001
270 * @tc.desc: RegisterAppGroupCallBack
271 * @tc.type: FUNC
272 * @tc.require: SR000H0HAQ AR000H0ROE
273 */
274 HWTEST_F(DeviceUsageStatisticsTest,
275 DeviceUsageStatisticsTest_RegisterAppGroupCallBack_001, Function | MediumTest | TestSize.Level0)
276 {
277 if (!observer) {
278 BUNDLE_ACTIVE_LOGI("RegisterAppGroupCallBack construct observer!");
279 observer = new (std::nothrow) TestAppGroupChangeCallback();
280 }
281 ASSERT_NE(observer, nullptr);
282 int32_t result = BundleActiveClient::GetInstance().RegisterAppGroupCallBack(observer);
283 EXPECT_EQ(result, DEFAULT_ERRCODE);
284 }
285
286 /*
287 * @tc.name: DeviceUsageStatisticsTest_SetBundleGroup_001
288 * @tc.desc: setbundlename
289 * @tc.type: FUNC
290 * @tc.require: SR000H0HAQ AR000H0ROE
291 */
292 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_SetAppGroup_001, Function | MediumTest | TestSize.Level0)
293 {
294 int32_t result = 0;
295 BundleActiveClient::GetInstance().QueryAppGroup(result, g_defaultBundleName, g_commonUserid);
296 g_defaultGroup = (result == g_defaultGroup) ? (result + 10) : g_defaultGroup;
297 result = BundleActiveClient::GetInstance().SetAppGroup(g_defaultBundleName, g_defaultGroup, g_commonUserid);
298 EXPECT_EQ(result, DEFAULT_ERRCODE);
299
300 result = BundleActiveClient::GetInstance().SetAppGroup(g_defaultBundleName, g_defaultGroup, -1);
301 EXPECT_NE(result, DEFAULT_ERRCODE);
302 }
303
304 /*
305 * @tc.name: DeviceUsageStatisticsTest_QueryAppGroup_001
306 * @tc.desc: QueryAppGroup, no bundleName
307 * @tc.type: FUNC
308 * @tc.require: SR000H0HAQ AR000H0ROE
309 */
310 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryAppGroup_001,
311 Function | MediumTest | TestSize.Level0)
312 {
313 BundleActiveClient::GetInstance().SetAppGroup(g_defaultBundleName, g_defaultGroup, g_commonUserid);
314 int32_t result = 0;
315 BundleActiveClient::GetInstance().QueryAppGroup(result, g_defaultBundleName, g_commonUserid);
316 EXPECT_NE(result, DEFAULT_ERRCODE);
317 }
318
319 /*
320 * @tc.name: DeviceUsageStatisticsTest_UnRegisterAppGroupCallBack_001
321 * @tc.desc: UnRegisterAppGroupCallBack
322 * @tc.type: FUNC
323 * @tc.require: SR000H0HAQ AR000H0ROE
324 */
325 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_UnRegisterAppGroupCallBack_001,
326 Function | MediumTest | TestSize.Level0)
327 {
328 if (!observer) {
329 BUNDLE_ACTIVE_LOGI("observer has been delete");
330 }
331 ASSERT_NE(observer, nullptr);
332 int32_t result = BundleActiveClient::GetInstance().UnRegisterAppGroupCallBack(observer);
333 observer = nullptr;
334 EXPECT_EQ(result, DEFAULT_ERRCODE);
335 }
336
337 /*
338 * @tc.name: DeviceUsageStatisticsTest_QueryDeviceEventStats_001
339 * @tc.desc: QueryDeviceEventStats
340 * @tc.type: FUNC
341 * @tc.require: SR000H0H9H AR000H0ROG
342 */
343 HWTEST_F(DeviceUsageStatisticsTest,
344 DeviceUsageStatisticsTest_QueryDeviceEventStats_001, Function | MediumTest | TestSize.Level0)
345 {
346 std::vector<BundleActiveEventStats> eventStats;
347 int32_t errCode = BundleActiveClient::GetInstance().QueryDeviceEventStats(0, g_largeNum, eventStats);
348 EXPECT_EQ(errCode, 0);
349 errCode = BundleActiveClient::GetInstance().QueryDeviceEventStats(0, g_largeNum, eventStats, g_commonUserid);
350 EXPECT_EQ(errCode, 0);
351 }
352
353 /*
354 * @tc.name: DeviceUsageStatisticsTest_QueryNotificationEventStats_001
355 * @tc.desc: QueryNotificationEventStats
356 * @tc.type: FUNC
357 * @tc.require: SR000H0H7D AR000H0RR6
358 */
359 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryNotificationEventStats_001, Function
360 | MediumTest | TestSize.Level0)
361 {
362 std::vector<BundleActiveEventStats> eventStats;
363 int32_t errCode = BundleActiveClient::GetInstance().QueryNotificationEventStats(0, g_largeNum, eventStats);
364 EXPECT_EQ(errCode, 0);
365 errCode = BundleActiveClient::GetInstance().QueryNotificationEventStats(0, g_largeNum, eventStats, g_commonUserid);
366 EXPECT_EQ(errCode, 0);
367 }
368
369 /*
370 * @tc.name: DeviceUsageStatisticsTest_BundleActiveGroupMap_001
371 * @tc.desc: BundleActiveGroupMap
372 * @tc.type: FUNC
373 * @tc.require: SR000H0G4F AR000H2US8
374 */
375 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_BundleActiveGroupMap_001,
376 Function | MediumTest | TestSize.Level0)
377 {
378 int64_t minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
379 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_FORCED_SET);
380 EXPECT_EQ(minInterval, 0);
381 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
382 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_ALIVE);
383 EXPECT_EQ(minInterval, DeviceUsageStatsGroupConst::TWO_HOUR);
384 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
385 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_DAILY);
386 EXPECT_EQ(minInterval, 2 * DeviceUsageStatsGroupConst::TWO_HOUR);
387 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
388 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_FIXED);
389 EXPECT_EQ(minInterval, DeviceUsageStatsGroupConst::TWENTY_FOUR_HOUR);
390 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
391 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_RARE);
392 EXPECT_EQ(minInterval, DeviceUsageStatsGroupConst::FOURTY_EIGHT_HOUR);
393 }
394
395 /*
396 * @tc.name: DeviceUsageStatisticsTest_DeathRecipient_001
397 * @tc.desc: DeathRecipient_001
398 * @tc.type: FUNC
399 * @tc.require: issuesI5SOZY
400 */
401 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_DeathRecipient_001,
402 Function | MediumTest | TestSize.Level0)
403 {
404 auto deathTest = std::make_shared<BundleActiveClient::BundleActiveClientDeathRecipient>();
405 deathTest->AddObserver(observer);
406 deathTest->RemoveObserver();
407 deathTest->OnServiceDiedInner();
408
409 deathTest->observer_ = new (std::nothrow) TestAppGroupChangeCallback();
410 deathTest->OnServiceDiedInner();
411 EXPECT_TRUE(deathTest != nullptr);
412 deathTest->OnRemoteDied(nullptr);
413 }
414
415 /*
416 * @tc.name: DeviceUsageStatisticsTest_AppGroupCallbackInfo_001
417 * @tc.desc: AppGroupCallbackInfo_001
418 * @tc.type: FUNC
419 * @tc.require: issuesI5SOZY
420 */
421 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_AppGroupCallbackInfo_001,
422 Function | MediumTest | TestSize.Level0)
423 {
424 int32_t oldGroup = 60;
425 int32_t newGroup = 10;
426 uint32_t changeReason = 1;
427 auto appGroupCallbackInfo =
428 std::make_shared<AppGroupCallbackInfo>(g_commonUserid, oldGroup, newGroup, changeReason, g_defaultBundleName);
429
430 MessageParcel data;
431 EXPECT_TRUE(appGroupCallbackInfo->Marshalling(data));
432 auto appGroupCallback = appGroupCallbackInfo->Unmarshalling(data);
433 EXPECT_TRUE(appGroupCallback != nullptr);
434
435 EXPECT_EQ(appGroupCallback->GetUserId(), g_commonUserid);
436 EXPECT_EQ(appGroupCallback->GetOldGroup(), oldGroup);
437 EXPECT_EQ(appGroupCallback->GetNewGroup(), newGroup);
438 EXPECT_EQ(appGroupCallback->GetChangeReason(), changeReason);
439 EXPECT_EQ(appGroupCallback->GetBundleName(), g_defaultBundleName);
440 delete appGroupCallback;
441 }
442
443 /*
444 * @tc.name: DeviceUsageStatisticsTest_BundleActiveEventStat_001
445 * @tc.desc: BundleActiveEventStats_001
446 * @tc.type: FUNC
447 * @tc.require: issuesI5SOZY
448 */
449 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_BundleActiveEventStat_001,
450 Function | MediumTest | TestSize.Level0)
451 {
452 auto bundleActiveEventStats = std::make_shared<BundleActiveEventStats>();
453 bundleActiveEventStats->eventId_ = g_commonUserid;
454 bundleActiveEventStats->beginTimeStamp_ = 0;
455 bundleActiveEventStats->endTimeStamp_ = g_largeNum;
456 bundleActiveEventStats->lastEventTime_ = g_largeNum;
457 bundleActiveEventStats->totalTime_ = g_largeNum;
458 bundleActiveEventStats->count_ = 1;
459
460 MessageParcel data;
461 EXPECT_TRUE(bundleActiveEventStats->Marshalling(data));
462 auto tempEventStats = bundleActiveEventStats->Unmarshalling(data);
463 EXPECT_TRUE(tempEventStats != nullptr);
464
465 auto bundleActiveEvent = std::make_shared<BundleActiveEvent>();
466 EXPECT_TRUE(bundleActiveEvent->Marshalling(data));
467 auto tempEvent = bundleActiveEvent->Unmarshalling(data);
468 EXPECT_TRUE(tempEvent != nullptr);
469
470 EXPECT_EQ(tempEventStats->GetEventId(), g_commonUserid);
471 EXPECT_EQ(tempEventStats->GetFirstTimeStamp(), 0);
472 EXPECT_EQ(tempEventStats->GetLastTimeStamp(), g_largeNum);
473 EXPECT_EQ(tempEventStats->GetLastEventTime(), g_largeNum);
474 EXPECT_EQ(tempEventStats->GetTotalTime(), g_largeNum);
475 EXPECT_EQ(tempEventStats->GetCount(), 1);
476 }
477
478 /*
479 * @tc.name: DeviceUsageStatisticsTest_FormRecord_001
480 * @tc.desc: BundleActiveFormRecord_001
481 * @tc.type: FUNC
482 * @tc.require: issuesI5SOZY
483 */
484 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_FormRecord_001, Function | MediumTest | TestSize.Level0)
485 {
486 auto bundleActiveFormRecord = std::make_shared<BundleActiveFormRecord>();
487 EXPECT_NE(bundleActiveFormRecord->ToString(), " ");
488
489 MessageParcel data;
490 EXPECT_TRUE(bundleActiveFormRecord->Marshalling(data));
491 EXPECT_TRUE(bundleActiveFormRecord->Unmarshalling(data) != nullptr);
492
493 BundleActiveFormRecord bundleActiveFormRecordA;
494 bundleActiveFormRecordA.count_ = 2;
495 BundleActiveFormRecord bundleActiveFormRecordB;
496 bundleActiveFormRecordB.count_ = 1;
497 EXPECT_TRUE(bundleActiveFormRecord->cmp(bundleActiveFormRecordA, bundleActiveFormRecordB));
498 }
499
500 /*
501 * @tc.name: DeviceUsageStatisticsTest_BundleActiveEvent_001
502 * @tc.desc: BundleActiveEvent_001
503 * @tc.type: FUNC
504 * @tc.require: issuesI5SOZY
505 */
506 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_BundleActiveEvent_001,
507 Function | MediumTest | TestSize.Level0)
508 {
509 BundleActiveEvent bundleActiveEvent;
510 BundleActiveEvent bundleActiveEventA;
511 EXPECT_NE(bundleActiveEvent.ToString(), " ");
512 bundleActiveEvent = bundleActiveEventA;
513 }
514
515 /*
516 * @tc.name: DeviceUsageStatisticsTest_PackageStats_001
517 * @tc.desc: BundleActivePackageStats_001
518 * @tc.type: FUNC
519 * @tc.require: issuesI5SOZY
520 */
521 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_PackageStats_001, Function | MediumTest | TestSize.Level0)
522 {
523 auto bundleActivePackageStats = std::make_shared<BundleActivePackageStats>();
524 bundleActivePackageStats->IncrementBundleLaunchedCount();
525 EXPECT_NE(bundleActivePackageStats->ToString(), " ");
526
527 MessageParcel data;
528 EXPECT_TRUE(bundleActivePackageStats->Marshalling(data));
529 EXPECT_TRUE(bundleActivePackageStats->Unmarshalling(data) != nullptr);
530 }
531
532 /*
533 * @tc.name: DeviceUsageStatisticsTest_ModuleRecord_001
534 * @tc.desc: BundleActiveModuleRecord_001
535 * @tc.type: FUNC
536 * @tc.require: issuesI5SOZY
537 */
538 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_ModuleRecord_001, Function | MediumTest | TestSize.Level0)
539 {
540 auto bundleActiveModuleRecord = std::make_shared<BundleActiveModuleRecord>();
541 EXPECT_NE(bundleActiveModuleRecord->ToString(), " ");
542
543 MessageParcel data;
544 EXPECT_TRUE(bundleActiveModuleRecord->Marshalling(data));
545 EXPECT_TRUE(bundleActiveModuleRecord->Unmarshalling(data) != nullptr);
546
547 BundleActiveModuleRecord bundleActiveModuleRecordA;
548 bundleActiveModuleRecordA.lastModuleUsedTime_ = 2;
549 BundleActiveModuleRecord bundleActiveModuleRecordB;
550 bundleActiveModuleRecordB.lastModuleUsedTime_ = 1;
551 EXPECT_TRUE(bundleActiveModuleRecord->cmp(bundleActiveModuleRecordA, bundleActiveModuleRecordB));
552
553 BundleActiveModuleRecord bundleActiveModuleRecordC;
554 bundleActiveModuleRecordC.lastModuleUsedTime_ = 2;
555 bundleActiveModuleRecord->UpdateModuleRecord(1000);
556 SUCCEED();
557 }
558
559 /*
560 * @tc.name: DeviceUsageStatisticsTest_AppGroupCallbackProxy_001
561 * @tc.desc: AppGroupCallbackProxy_001
562 * @tc.type: FUNC
563 * @tc.require: issuesI5SOZY
564 */
565 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_AppGroupCallbackProxy_001,
566 Function | MediumTest | TestSize.Level0)
567 {
568 int32_t oldGroup = 60;
569 int32_t newGroup = 10;
570 uint32_t changeReason = 1;
571 AppGroupCallbackInfo appGroupCallbackInfo(g_commonUserid, oldGroup, newGroup, changeReason, g_defaultBundleName);
572
573 auto appGroupCallbackProxy = std::make_shared<AppGroupCallbackProxy>(nullptr);
574 appGroupCallbackProxy->OnAppGroupChanged(appGroupCallbackInfo);
575 EXPECT_NE(appGroupCallbackProxy, nullptr);
576 }
577
578 /*
579 * @tc.name: DeviceUsageStatisticsTest_AppGroupCallbackStub_001
580 * @tc.desc: AppGroupCallbackStub_001
581 * @tc.type: FUNC
582 * @tc.require: issuesI5SOZY
583 */
584 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_AppGroupCallbackStub_001,
585 Function | MediumTest | TestSize.Level0)
586 {
587 int32_t oldGroup = 60;
588 int32_t newGroup = 10;
589 uint32_t changeReason = 1;
590 AppGroupCallbackInfo appGroupCallbackInfo(g_commonUserid, oldGroup, newGroup, changeReason, g_defaultBundleName);
591
592 auto appGroupCallbackStub = std::make_shared<TestAppGroupChangeCallback>();
593 appGroupCallbackStub->OnAppGroupChanged(appGroupCallbackInfo);
594 MessageParcel data1;
595 MessageParcel reply;
596 MessageOption option;
597 EXPECT_EQ(appGroupCallbackStub->OnRemoteRequest(1, data1, reply, option), 1);
598 data1.WriteInterfaceToken(AppGroupCallbackStub::GetDescriptor());
599 EXPECT_EQ(appGroupCallbackStub->OnRemoteRequest(1, data1, reply, option), 5);
600 }
601
602 /*
603 * @tc.name: DeviceUsageStatisticsTest_QueryHighFrequencyPeriodBundle_001
604 * @tc.desc: QueryHighFrequencyPeriodBundle
605 * @tc.type: FUNC
606 * @tc.require: SR20250319441801 AR20250322520501
607 */
608 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryHighFrequencyPeriodBundle_001,
609 Function | MediumTest | TestSize.Level0)
610 {
611 std::vector<BundleActiveHighFrequencyPeriod> appFreqHours;
612 ErrCode ret = BundleActiveClient::GetInstance().QueryHighFrequencyPeriodBundle(
613 appFreqHours, g_defaultFormId);
614 EXPECT_EQ(ret, 0);
615 EXPECT_EQ(appFreqHours.size(), 0);
616 ret = BundleActiveClient::GetInstance().QueryHighFrequencyPeriodBundle(
617 appFreqHours, g_commonUserid);
618 EXPECT_EQ(ret, 0);
619 }
620
621 /*
622 * @tc.name: DeviceUsageStatisticsTest__QueryBundleTodayLatestUsedTime_001
623 * @tc.desc: _QueryBundleTodayLatestUsedTime
624 * @tc.type: FUNC
625 * @tc.require: SR20250319441801 AR20250322520501
626 */
627 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryBundleTodayLatestUsedTime_001,
628 Function | MediumTest | TestSize.Level0)
629 {
630 int64_t latestUsedTime = 0;
631 ErrCode ret = BundleActiveClient::GetInstance().QueryBundleTodayLatestUsedTime(
632 latestUsedTime, g_defaultFormName, g_commonUserid);
633 EXPECT_NE(ret, 0);
634 EXPECT_EQ(latestUsedTime, 0);
635 }
636
637 /*
638 * @tc.name: DeviceUsageStatisticsTest__BundleActiveHighFrequencyPeriod_001
639 * @tc.desc: BundleActiveHighFrequencyPeriod
640 * @tc.type: FUNC
641 * @tc.require: SR20250319441801 AR20250322520501
642 */
643 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_BundleActiveHighFrequencyPeriod_001,
644 Function | MediumTest | TestSize.Level0)
645 {
646 BundleActiveHighFrequencyPeriod originalBundle;
647 std::vector<int32_t> highFreqHour;
648 highFreqHour.push_back(1);
649 originalBundle.bundleName_ = g_defaultFormName;
650 originalBundle.highFreqHours_ = highFreqHour;
651 EXPECT_EQ(originalBundle.bundleName_, g_defaultFormName);
652
653 BundleActiveHighFrequencyPeriod copy(originalBundle);
654 EXPECT_EQ(copy.bundleName_, originalBundle.bundleName_);
655
656 BundleActiveHighFrequencyPeriod withPara(g_defaultFormName, highFreqHour);
657 EXPECT_EQ(withPara.bundleName_, g_defaultFormName);
658 }
659
660 /*
661 * @tc.name: DeviceUsageStatisticsTest__BundleActiveHighFrequencyPeriod_002
662 * @tc.desc: BundleActiveHighFrequencyPeriod
663 * @tc.type: FUNC
664 * @tc.require: SR20250319441801 AR20250322520501
665 */
666 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_BundleActiveHighFrequencyPeriod_002,
667 Function | MediumTest | TestSize.Level0)
668 {
669 BundleActiveHighFrequencyPeriod testShall;
670 MessageParcel parcel1;
671 EXPECT_TRUE(testShall.Marshalling(parcel1));
672 EXPECT_NE(testShall.Unmarshalling(parcel1), nullptr);
673
674 MessageParcel parcel2;
675 testShall.bundleName_ = g_defaultFormName;
676 testShall.highFreqHours_.push_back(1);
677 EXPECT_TRUE(testShall.Marshalling(parcel2));
678 EXPECT_NE(testShall.Unmarshalling(parcel2), nullptr);
679
680 MessageParcel parcel3;
681 parcel3.WriteString(g_defaultFormName);
682 parcel3.WriteUint32(3);
683 parcel3.WriteInt32(1);
684 parcel3.WriteInt32(2);
685 EXPECT_EQ(testShall.Unmarshalling(parcel3), nullptr);
686
687 MessageParcel parcel4;
688 parcel4.WriteString(g_defaultFormName);
689 parcel4.WriteUint32(2);
690 parcel4.WriteInt32(1);
691 parcel4.WriteInt32(2);
692 EXPECT_NE(testShall.Unmarshalling(parcel4), nullptr);
693
694 MessageParcel parcel5;
695 parcel5.WriteString(g_defaultFormName);
696 parcel5.WriteUint32(25);
697 parcel5.WriteInt32(1);
698 parcel5.WriteInt32(2);
699 EXPECT_EQ(testShall.Unmarshalling(parcel5), nullptr);
700
701 MessageParcel parcel6;
702 testShall.highFreqHours_.resize(25);
703 EXPECT_FALSE(testShall.Marshalling(parcel6));
704 }
705
706 /*
707 * @tc.name: DeviceUsageStatisticsTest__BundleActiveHighFrequencyPeriod_003
708 * @tc.desc: BundleActiveHighFrequencyPeriod
709 * @tc.type: FUNC
710 * @tc.require: SR20250319441801 AR20250322520501
711 */
712 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_BundleActiveHighFrequencyPeriod_003,
713 Function | MediumTest | TestSize.Level0)
714 {
715 BundleActiveHighFrequencyPeriod originalBundle;
716 EXPECT_EQ(originalBundle.ToString(), "bundle name is , highFreqHours_ is \n");
717
718 originalBundle.bundleName_ = "test";
719 originalBundle.highFreqHours_.push_back(1);
720 EXPECT_EQ(originalBundle.ToString(), "bundle name is test, highFreqHours_ is 1\n");
721
722 originalBundle.highFreqHours_.push_back(2);
723 EXPECT_EQ(originalBundle.ToString(), "bundle name is test, highFreqHours_ is 1, 2\n");
724 }
725 } // namespace DeviceUsageStats
726 } // namespace OHOS
727
728