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_client.h"
25 #include "bundle_active_event.h"
26 #include "app_group_callback_stub.h"
27 #include "bundle_active_group_map.h"
28 #include "app_group_callback_info.h"
29 #include "bundle_active_form_record.h"
30 #include "bundle_active_event_stats.h"
31 #include "bundle_active_module_record.h"
32 #include "bundle_active_package_stats.h"
33 #include "app_group_callback_proxy.h"
34 #include "iapp_group_callback.h"
35
36 using namespace testing::ext;
37
38 namespace OHOS {
39 namespace DeviceUsageStats {
40 #ifdef __aarch64__
41 static std::string g_defaultBundleName = "com.huawei.hmos.camera";
42 #else
43 static std::string g_defaultBundleName = "com.ohos.camera";
44 #endif
45 static std::string g_defaultMoudleName = "defaultmodulename";
46 static std::string g_defaultFormName = "defaultformname";
47 static int32_t DEFAULT_DIMENSION = 4;
48 static int64_t DEFAULT_FORMID = 1;
49 static int32_t DEFAULT_USERID = 0;
50 static int32_t COMMON_USERID = 100;
51 static int32_t DEFAULT_ERRCODE = 0;
52 static int64_t LARGE_NUM = 20000000000000;
53 static int32_t DEFAULT_GROUP = 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 }
68
TearDownTestCase(void)69 void DeviceUsageStatisticsTest::TearDownTestCase(void)
70 {
71 }
72
SetUp(void)73 void DeviceUsageStatisticsTest::SetUp(void)
74 {
75 }
76
TearDown(void)77 void DeviceUsageStatisticsTest::TearDown(void)
78 {
79 }
80
81 class TestAppGroupChangeCallback : public AppGroupCallbackStub {
82 public:
83 void OnAppGroupChanged(const AppGroupCallbackInfo &appGroupCallbackInfo) override;
84 };
85
OnAppGroupChanged(const AppGroupCallbackInfo & appGroupCallbackInfo)86 void TestAppGroupChangeCallback::OnAppGroupChanged(const AppGroupCallbackInfo &appGroupCallbackInfo)
87 {
88 BUNDLE_ACTIVE_LOGI("TestAppGroupChangeCallback::OnAppGroupChanged!");
89 MessageParcel data;
90 if (!appGroupCallbackInfo.Marshalling(data)) {
91 BUNDLE_ACTIVE_LOGE("Marshalling fail");
92 }
93 appGroupCallbackInfo.Unmarshalling(data);
94 }
95
96 /*
97 * @tc.name: DeviceUsageStatisticsTest_GetServiceObject_001
98 * @tc.desc: get service object
99 * @tc.type: FUNC
100 * @tc.require: SR000GGTO8 AR000GH6PK
101 */
102 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_GetServiceObject_001, Function | MediumTest | Level0)
103 {
104 sptr<ISystemAbilityManager> systemAbilityManager =
105 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
106 EXPECT_NE(systemAbilityManager, nullptr);
107
108 sptr<IRemoteObject> remoteObject =
109 systemAbilityManager->GetSystemAbility(DEVICE_USAGE_STATISTICS_SYS_ABILITY_ID);
110 EXPECT_NE(remoteObject, nullptr);
111 }
112
113 /*
114 * @tc.name: DeviceUsageStatisticsTest_ReportEvent_001
115 * @tc.desc: report a mock event
116 * @tc.type: FUNC
117 * @tc.require: SR000GGTO7 SR000GU31B AR000GH6PJ AR000GU380
118 */
119 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_ReportEvent_001, Function | MediumTest | Level0)
120 {
121 BundleActiveEvent eventA(g_defaultBundleName, g_defaultMoudleName, g_defaultFormName,
122 DEFAULT_DIMENSION, DEFAULT_FORMID, BundleActiveEvent::FORM_IS_CLICKED);
123 BundleActiveClient::GetInstance().ReportEvent(eventA, DEFAULT_USERID);
124 BundleActiveEvent eventB(g_defaultBundleName, g_defaultMoudleName, g_defaultFormName,
125 DEFAULT_DIMENSION, DEFAULT_FORMID, BundleActiveEvent::FORM_IS_REMOVED);
126 BundleActiveClient::GetInstance().ReportEvent(eventB, DEFAULT_USERID);
127 }
128
129 /*
130 * @tc.name: DeviceUsageStatisticsTest_QueryBundleEvents_001
131 * @tc.desc: QueryBundleEvents
132 * @tc.type: FUNC
133 * @tc.require: SR000GGTO6 AR000GH6PH
134 */
135 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryBundleEvents_001, Function | MediumTest | Level0)
136 {
137 std::vector<BundleActiveEvent> result;
138 BundleActiveClient::GetInstance().QueryBundleEvents(result, 0, LARGE_NUM, 100);
139 EXPECT_EQ(result.size() > 0, true);
140 EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleEvents(result, LARGE_NUM, LARGE_NUM, 100), 0);
141 }
142
143 /*
144 * @tc.name: DeviceUsageStatisticsTest_QueryCurrentBundleEvents_001
145 * @tc.desc: QueryCurrentBundleEvents
146 * @tc.type: FUNC
147 * @tc.require: SR000GGTO4 AR000GH6PF
148 */
149 HWTEST_F(DeviceUsageStatisticsTest,
150 DeviceUsageStatisticsTest_QueryCurrentBundleEvents_001, Function | MediumTest | Level0)
151 {
152 std::vector<BundleActiveEvent> result;
153 BundleActiveClient::GetInstance().QueryCurrentBundleEvents(result, 0, LARGE_NUM);
154 EXPECT_EQ(result.size(), 0);
155 }
156
157 /*
158 * @tc.name: DeviceUsageStatisticsTest_QueryPackagesStats_001
159 * @tc.desc: querypackagestats
160 * @tc.type: FUNC
161 * @tc.require: SR000GGTO3 AR000GH6PD
162 */
163 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryPackagesStats_001, Function | MediumTest | Level0)
164 {
165 std::vector<BundleActivePackageStats> result;
166 BundleActiveClient::GetInstance().QueryBundleStatsInfoByInterval(result, 4, 0, LARGE_NUM);
167 EXPECT_EQ(result.size(), 0);
168 EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleStatsInfoByInterval(result, 4, LARGE_NUM, LARGE_NUM), 0);
169 }
170
171 /*
172 * @tc.name: DeviceUsageStatisticsTest_QueryBundleStatsInfos_001
173 * @tc.desc: QueryBundleStatsInfos
174 * @tc.type: FUNC
175 * @tc.require: issuesI5QJD9
176 */
177 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryBundleStatsInfos_001,
178 Function | MediumTest | Level0)
179 {
180 std::vector<BundleActivePackageStats> result;
181 BundleActiveClient::GetInstance().QueryBundleStatsInfos(result, 4, 0, LARGE_NUM);
182 EXPECT_EQ(result.size(), 0);
183 }
184
185 /*
186 * @tc.name: DeviceUsageStatisticsTest_IsBundleIdle_001
187 * @tc.desc: isbundleidle
188 * @tc.type: FUNC
189 * @tc.require: SR000GGTO5 AR000GH6PG
190 */
191 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_IsBundleIdle_001, Function | MediumTest | Level0)
192 {
193 bool result = false;
194 int32_t errCode = BundleActiveClient::GetInstance().IsBundleIdle(result, g_defaultBundleName, DEFAULT_USERID);
195 EXPECT_EQ(result, false);
196 EXPECT_EQ(errCode, 0);
197 }
198
199 /*
200 * @tc.name: DeviceUsageStatisticsTest_QueryModuleUsageRecords_001
201 * @tc.desc: QueryModuleUsageRecords
202 * @tc.type: FUNC
203 * @tc.require: SR000GU2T1 AR000GU37U
204 */
205 HWTEST_F(DeviceUsageStatisticsTest,
206 DeviceUsageStatisticsTest_QueryModuleUsageRecords_001, Function | MediumTest | Level0)
207 {
208 int32_t maxNum = 1;
209 BundleActiveEvent eventA(g_defaultBundleName, g_defaultMoudleName, g_defaultFormName,
210 DEFAULT_DIMENSION, DEFAULT_FORMID, BundleActiveEvent::FORM_IS_CLICKED);
211 BundleActiveClient::GetInstance().ReportEvent(eventA, DEFAULT_USERID);
212 std::vector<BundleActiveModuleRecord> results;
213 int32_t errCode = BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, results, DEFAULT_USERID);
214 EXPECT_EQ(errCode, 0);
215 EXPECT_EQ(results.size(), 0);
216
217 results.clear();
218 maxNum = 0;
219 errCode = BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, results, DEFAULT_USERID);
220 EXPECT_NE(errCode, 0);
221
222 results.clear();
223 maxNum = 1001;
224 errCode = BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, results, DEFAULT_USERID);
225 EXPECT_NE(errCode, 0);
226 }
227
228 /*
229 * @tc.name: DeviceUsageStatisticsTest_RegisterAppGroupCallBack_001
230 * @tc.desc: RegisterAppGroupCallBack
231 * @tc.type: FUNC
232 * @tc.require: SR000H0HAQ AR000H0ROE
233 */
234 HWTEST_F(DeviceUsageStatisticsTest,
235 DeviceUsageStatisticsTest_RegisterAppGroupCallBack_001, Function | MediumTest | Level0)
236 {
237 if (!observer) {
238 BUNDLE_ACTIVE_LOGI("RegisterAppGroupCallBack construct observer!");
239 observer = new (std::nothrow) TestAppGroupChangeCallback();
240 }
241 ASSERT_NE(observer, nullptr);
242 int32_t result = BundleActiveClient::GetInstance().RegisterAppGroupCallBack(observer);
243 EXPECT_EQ(result, DEFAULT_ERRCODE);
244 }
245
246 /*
247 * @tc.name: DeviceUsageStatisticsTest_SetBundleGroup_001
248 * @tc.desc: setbundlename
249 * @tc.type: FUNC
250 * @tc.require: SR000H0HAQ AR000H0ROE
251 */
252 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_SetAppGroup_001, Function | MediumTest | Level0)
253 {
254 int32_t result = 0;
255 BundleActiveClient::GetInstance().QueryAppGroup(result, g_defaultBundleName, COMMON_USERID);
256 DEFAULT_GROUP = (result == DEFAULT_GROUP) ? (result + 10) : DEFAULT_GROUP;
257 result = BundleActiveClient::GetInstance().SetAppGroup(g_defaultBundleName, DEFAULT_GROUP, COMMON_USERID);
258 EXPECT_EQ(result, DEFAULT_ERRCODE);
259
260 result = BundleActiveClient::GetInstance().SetAppGroup(g_defaultBundleName, DEFAULT_GROUP, -1);
261 EXPECT_NE(result, DEFAULT_ERRCODE);
262 }
263
264 /*
265 * @tc.name: DeviceUsageStatisticsTest_QueryAppGroup_001
266 * @tc.desc: QueryAppGroup, no bundleName
267 * @tc.type: FUNC
268 * @tc.require: SR000H0HAQ AR000H0ROE
269 */
270 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryAppGroup_001, Function | MediumTest | Level0)
271 {
272 BundleActiveClient::GetInstance().SetAppGroup(g_defaultBundleName, DEFAULT_GROUP, COMMON_USERID);
273 int32_t result = 0;
274 BundleActiveClient::GetInstance().QueryAppGroup(result, g_defaultBundleName, COMMON_USERID);
275 bool flag = false;
276 for (auto item = GROUP_TYPE.begin(); item != GROUP_TYPE.end(); item++) {
277 if (*item == result) {
278 flag = true;
279 break;
280 }
281 }
282 EXPECT_EQ(flag, true);
283 }
284
285 /*
286 * @tc.name: DeviceUsageStatisticsTest_UnRegisterAppGroupCallBack_001
287 * @tc.desc: UnRegisterAppGroupCallBack
288 * @tc.type: FUNC
289 * @tc.require: SR000H0HAQ AR000H0ROE
290 */
291 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_UnRegisterAppGroupCallBack_001,
292 Function | MediumTest | Level0)
293 {
294 if (!observer) {
295 BUNDLE_ACTIVE_LOGI("observer has been delete");
296 }
297 ASSERT_NE(observer, nullptr);
298 int32_t result = BundleActiveClient::GetInstance().UnRegisterAppGroupCallBack(observer);
299 observer = nullptr;
300 EXPECT_EQ(result, DEFAULT_ERRCODE);
301 }
302
303 /*
304 * @tc.name: DeviceUsageStatisticsTest_QueryDeviceEventStats_001
305 * @tc.desc: QueryDeviceEventStats
306 * @tc.type: FUNC
307 * @tc.require: SR000H0H9H AR000H0ROG
308 */
309 HWTEST_F(DeviceUsageStatisticsTest,
310 DeviceUsageStatisticsTest_QueryDeviceEventStats_001, Function | MediumTest | Level0)
311 {
312 std::vector<BundleActiveEventStats> eventStats;
313 int32_t errCode = BundleActiveClient::GetInstance().QueryDeviceEventStats(0, LARGE_NUM, eventStats);
314 EXPECT_EQ(errCode, 0);
315 errCode = BundleActiveClient::GetInstance().QueryDeviceEventStats(0, LARGE_NUM, eventStats, COMMON_USERID);
316 EXPECT_EQ(errCode, 0);
317 }
318
319 /*
320 * @tc.name: DeviceUsageStatisticsTest_QueryNotificationEventStats_001
321 * @tc.desc: QueryNotificationEventStats
322 * @tc.type: FUNC
323 * @tc.require: SR000H0H7D AR000H0RR6
324 */
325 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryNotificationEventStats_001, Function
326 | MediumTest | Level0)
327 {
328 std::vector<BundleActiveEventStats> eventStats;
329 int32_t errCode = BundleActiveClient::GetInstance().QueryNotificationEventStats(0, LARGE_NUM, eventStats);
330 EXPECT_EQ(errCode, 0);
331 errCode = BundleActiveClient::GetInstance().QueryNotificationEventStats(0, LARGE_NUM, eventStats, COMMON_USERID);
332 EXPECT_EQ(errCode, 0);
333 }
334
335 /*
336 * @tc.name: DeviceUsageStatisticsTest_BundleActiveGroupMap_001
337 * @tc.desc: BundleActiveGroupMap
338 * @tc.type: FUNC
339 * @tc.require: SR000H0G4F AR000H2US8
340 */
341 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_BundleActiveGroupMap_001, Function | MediumTest | Level0)
342 {
343 int64_t minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
344 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_FORCED_SET);
345 EXPECT_EQ(minInterval, 0);
346 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
347 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_ALIVE);
348 EXPECT_EQ(minInterval, DeviceUsageStatsGroupConst::TWO_HOUR);
349 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
350 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_DAILY);
351 EXPECT_EQ(minInterval, 2 * DeviceUsageStatsGroupConst::TWO_HOUR);
352 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
353 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_FIXED);
354 EXPECT_EQ(minInterval, DeviceUsageStatsGroupConst::TWENTY_FOUR_HOUR);
355 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
356 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_RARE);
357 EXPECT_EQ(minInterval, DeviceUsageStatsGroupConst::FOURTY_EIGHT_HOUR);
358 }
359
360 /*
361 * @tc.name: DeviceUsageStatisticsTest_DeathRecipient_001
362 * @tc.desc: DeathRecipient_001
363 * @tc.type: FUNC
364 * @tc.require: issuesI5SOZY
365 */
366 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_DeathRecipient_001, Function | MediumTest | Level0)
367 {
368 auto deathTest = std::make_shared<BundleActiveClient::BundleActiveClientDeathRecipient>();
369 deathTest->AddObserver(observer);
370 deathTest->RemoveObserver();
371 deathTest->OnServiceDiedInner();
372
373 deathTest->observer_ = new (std::nothrow) TestAppGroupChangeCallback();
374 deathTest->OnServiceDiedInner();
375 EXPECT_TRUE(deathTest != nullptr);
376 deathTest->OnRemoteDied(nullptr);
377 }
378
379 /*
380 * @tc.name: DeviceUsageStatisticsTest_AppGroupCallbackInfo_001
381 * @tc.desc: AppGroupCallbackInfo_001
382 * @tc.type: FUNC
383 * @tc.require: issuesI5SOZY
384 */
385 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_AppGroupCallbackInfo_001, Function | MediumTest | Level0)
386 {
387 int32_t oldGroup = 60;
388 int32_t newGroup = 10;
389 uint32_t changeReason = 1;
390 auto appGroupCallbackInfo =
391 std::make_shared<AppGroupCallbackInfo>(COMMON_USERID, oldGroup, newGroup, changeReason, g_defaultBundleName);
392
393 MessageParcel data;
394 EXPECT_TRUE(appGroupCallbackInfo->Marshalling(data));
395 auto appGroupCallback = appGroupCallbackInfo->Unmarshalling(data);
396 EXPECT_TRUE(appGroupCallback != nullptr);
397
398 EXPECT_EQ(appGroupCallback->GetUserId(), COMMON_USERID);
399 EXPECT_EQ(appGroupCallback->GetOldGroup(), oldGroup);
400 EXPECT_EQ(appGroupCallback->GetNewGroup(), newGroup);
401 EXPECT_EQ(appGroupCallback->GetChangeReason(), changeReason);
402 EXPECT_EQ(appGroupCallback->GetBundleName(), g_defaultBundleName);
403 delete appGroupCallback;
404 }
405
406 /*
407 * @tc.name: DeviceUsageStatisticsTest_BundleActiveEventStat_001
408 * @tc.desc: BundleActiveEventStats_001
409 * @tc.type: FUNC
410 * @tc.require: issuesI5SOZY
411 */
412 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_BundleActiveEventStat_001, Function | MediumTest | Level0)
413 {
414 auto bundleActiveEventStats = std::make_shared<BundleActiveEventStats>();
415 bundleActiveEventStats->eventId_ = COMMON_USERID;
416 bundleActiveEventStats->beginTimeStamp_ = 0;
417 bundleActiveEventStats->endTimeStamp_ = LARGE_NUM;
418 bundleActiveEventStats->lastEventTime_ = LARGE_NUM;
419 bundleActiveEventStats->totalTime_ = LARGE_NUM;
420 bundleActiveEventStats->count_ = 1;
421
422 MessageParcel data;
423 EXPECT_TRUE(bundleActiveEventStats->Marshalling(data));
424 auto tempEventStats = bundleActiveEventStats->UnMarshalling(data);
425 EXPECT_TRUE(tempEventStats != nullptr);
426
427 auto bundleActiveEvent = std::make_shared<BundleActiveEvent>();
428 EXPECT_TRUE(bundleActiveEvent->Marshalling(data));
429 auto tempEvent = bundleActiveEvent->UnMarshalling(data);
430 EXPECT_TRUE(tempEvent != nullptr);
431
432 EXPECT_EQ(tempEventStats->GetEventId(), COMMON_USERID);
433 EXPECT_EQ(tempEventStats->GetFirstTimeStamp(), 0);
434 EXPECT_EQ(tempEventStats->GetLastTimeStamp(), LARGE_NUM);
435 EXPECT_EQ(tempEventStats->GetLastEventTime(), LARGE_NUM);
436 EXPECT_EQ(tempEventStats->GetTotalTime(), LARGE_NUM);
437 EXPECT_EQ(tempEventStats->GetCount(), 1);
438 }
439
440 /*
441 * @tc.name: DeviceUsageStatisticsTest_FormRecord_001
442 * @tc.desc: BundleActiveFormRecord_001
443 * @tc.type: FUNC
444 * @tc.require: issuesI5SOZY
445 */
446 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_FormRecord_001, Function | MediumTest | Level0)
447 {
448 auto bundleActiveFormRecord = std::make_shared<BundleActiveFormRecord>();
449 EXPECT_NE(bundleActiveFormRecord->ToString(), " ");
450
451 MessageParcel data;
452 EXPECT_TRUE(bundleActiveFormRecord->Marshalling(data));
453 EXPECT_TRUE(bundleActiveFormRecord->UnMarshalling(data) != nullptr);
454
455 BundleActiveFormRecord bundleActiveFormRecordA;
456 bundleActiveFormRecordA.count_ = 2;
457 BundleActiveFormRecord bundleActiveFormRecordB;
458 bundleActiveFormRecordB.count_ = 1;
459 EXPECT_TRUE(bundleActiveFormRecord->cmp(bundleActiveFormRecordA, bundleActiveFormRecordB));
460 }
461
462 /*
463 * @tc.name: DeviceUsageStatisticsTest_BundleActiveEvent_001
464 * @tc.desc: BundleActiveEvent_001
465 * @tc.type: FUNC
466 * @tc.require: issuesI5SOZY
467 */
468 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_BundleActiveEvent_001, Function | MediumTest | Level0)
469 {
470 BundleActiveEvent bundleActiveEvent;
471 BundleActiveEvent bundleActiveEventA;
472 EXPECT_NE(bundleActiveEvent.ToString(), " ");
473 bundleActiveEvent = bundleActiveEventA;
474 }
475
476 /*
477 * @tc.name: DeviceUsageStatisticsTest_PackageStats_001
478 * @tc.desc: BundleActivePackageStats_001
479 * @tc.type: FUNC
480 * @tc.require: issuesI5SOZY
481 */
482 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_PackageStats_001, Function | MediumTest | Level0)
483 {
484 auto bundleActivePackageStats = std::make_shared<BundleActivePackageStats>();
485 bundleActivePackageStats->IncrementBundleLaunchedCount();
486 EXPECT_NE(bundleActivePackageStats->ToString(), " ");
487
488 MessageParcel data;
489 EXPECT_TRUE(bundleActivePackageStats->Marshalling(data));
490 EXPECT_TRUE(bundleActivePackageStats->UnMarshalling(data) != nullptr);
491 }
492
493 /*
494 * @tc.name: DeviceUsageStatisticsTest_ModuleRecord_001
495 * @tc.desc: BundleActiveModuleRecord_001
496 * @tc.type: FUNC
497 * @tc.require: issuesI5SOZY
498 */
499 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_ModuleRecord_001, Function | MediumTest | Level0)
500 {
501 auto bundleActiveModuleRecord = std::make_shared<BundleActiveModuleRecord>();
502 EXPECT_NE(bundleActiveModuleRecord->ToString(), " ");
503
504 MessageParcel data;
505 EXPECT_TRUE(bundleActiveModuleRecord->Marshalling(data));
506 EXPECT_TRUE(bundleActiveModuleRecord->UnMarshalling(data) != nullptr);
507
508 BundleActiveModuleRecord bundleActiveModuleRecordA;
509 bundleActiveModuleRecordA.lastModuleUsedTime_ = 2;
510 BundleActiveModuleRecord bundleActiveModuleRecordB;
511 bundleActiveModuleRecordB.lastModuleUsedTime_ = 1;
512 EXPECT_TRUE(bundleActiveModuleRecord->cmp(bundleActiveModuleRecordA, bundleActiveModuleRecordB));
513
514 BundleActiveModuleRecord bundleActiveModuleRecordC;
515 bundleActiveModuleRecordC.lastModuleUsedTime_ = 2;
516 bundleActiveModuleRecord->UpdateModuleRecord(1000);
517 }
518
519 /*
520 * @tc.name: DeviceUsageStatisticsTest_AppGroupCallbackProxy_001
521 * @tc.desc: AppGroupCallbackProxy_001
522 * @tc.type: FUNC
523 * @tc.require: issuesI5SOZY
524 */
525 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_AppGroupCallbackProxy_001, Function | MediumTest | Level0)
526 {
527 int32_t oldGroup = 60;
528 int32_t newGroup = 10;
529 uint32_t changeReason = 1;
530 AppGroupCallbackInfo appGroupCallbackInfo(COMMON_USERID, oldGroup, newGroup, changeReason, g_defaultBundleName);
531
532 auto appGroupCallbackProxy = std::make_shared<BundleActiveGroupCallbackProxy>(nullptr);
533 appGroupCallbackProxy->OnAppGroupChanged(appGroupCallbackInfo);
534 EXPECT_NE(appGroupCallbackProxy, nullptr);
535 }
536
537 /*
538 * @tc.name: DeviceUsageStatisticsTest_AppGroupCallbackStub_001
539 * @tc.desc: AppGroupCallbackStub_001
540 * @tc.type: FUNC
541 * @tc.require: issuesI5SOZY
542 */
543 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_AppGroupCallbackStub_001, Function | MediumTest | Level0)
544 {
545 int32_t oldGroup = 60;
546 int32_t newGroup = 10;
547 uint32_t changeReason = 1;
548 AppGroupCallbackInfo appGroupCallbackInfo(COMMON_USERID, oldGroup, newGroup, changeReason, g_defaultBundleName);
549
550 auto appGroupCallbackStub = std::make_shared<AppGroupCallbackStub>();
551 appGroupCallbackStub->OnAppGroupChanged(appGroupCallbackInfo);
552 MessageParcel data1;
553 MessageParcel reply;
554 MessageOption option;
555 EXPECT_EQ(appGroupCallbackStub->OnRemoteRequest(1, data1, reply, option), -1);
556 data1.WriteInterfaceToken(AppGroupCallbackStub::GetDescriptor());
557 EXPECT_EQ(appGroupCallbackStub->OnRemoteRequest(1, data1, reply, option), -1);
558 }
559 } // namespace DeviceUsageStats
560 } // namespace OHOS
561
562