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
37 using namespace testing::ext;
38
39 namespace OHOS {
40 namespace DeviceUsageStats {
41 using namespace Security::AccessToken;
42 #ifdef __aarch64__
43 static std::string g_defaultBundleName = "com.huawei.hmos.camera";
44 #else
45 static std::string g_defaultBundleName = "com.ohos.camera";
46 #endif
47 static std::string g_defaultMoudleName = "defaultmodulename";
48 static std::string g_defaultFormName = "defaultformname";
49 static int32_t g_defaultDimension = 4;
50 static int64_t g_defaultFormId = 1;
51 static int32_t g_defaultUserId = 0;
52 static int32_t g_commonUserid = 100;
53 static int32_t DEFAULT_ERRCODE = 0;
54 static int64_t g_largeNum = 20000000000000;
55 static int32_t g_defaultGroup = 10;
56 static std::vector<int32_t> GROUP_TYPE {10, 20, 30, 40, 50};
57 static sptr<IAppGroupCallback> observer = nullptr;
58
59 class DeviceUsageStatisticsTest : public testing::Test {
60 public:
61 static void SetUpTestCase(void);
62 static void TearDownTestCase(void);
63 void SetUp();
64 void TearDown();
65 };
66
SetUpTestCase(void)67 void DeviceUsageStatisticsTest::SetUpTestCase(void)
68 {
69 static const char *perms[] = {
70 "ohos.permission.BUNDLE_ACTIVE_INFO",
71 };
72 uint64_t tokenId;
73 NativeTokenInfoParams infoInstance = {
74 .dcapsNum = 0,
75 .permsNum = 1,
76 .aclsNum = 0,
77 .dcaps = nullptr,
78 .perms = perms,
79 .acls = nullptr,
80 .processName = "DeviceUsageStatisticsTest",
81 .aplStr = "system_core",
82 };
83 tokenId = GetAccessTokenId(&infoInstance);
84 SetSelfTokenID(tokenId);
85 AccessTokenKit::ReloadNativeTokenInfo();
86 }
87
TearDownTestCase(void)88 void DeviceUsageStatisticsTest::TearDownTestCase(void)
89 {
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, Function | MediumTest | Level0)
125 {
126 sptr<ISystemAbilityManager> systemAbilityManager =
127 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
128 EXPECT_NE(systemAbilityManager, nullptr);
129
130 sptr<IRemoteObject> remoteObject =
131 systemAbilityManager->GetSystemAbility(DEVICE_USAGE_STATISTICS_SYS_ABILITY_ID);
132 EXPECT_NE(remoteObject, nullptr);
133 }
134
135 /*
136 * @tc.name: DeviceUsageStatisticsTest_ReportEvent_001
137 * @tc.desc: report a mock event
138 * @tc.type: FUNC
139 * @tc.require: SR000GGTO7 SR000GU31B AR000GH6PJ AR000GU380
140 */
141 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_ReportEvent_001, Function | MediumTest | Level0)
142 {
143 BundleActiveEvent eventA(g_defaultBundleName, g_defaultMoudleName, g_defaultFormName,
144 g_defaultDimension, g_defaultFormId, BundleActiveEvent::FORM_IS_CLICKED);
145 BundleActiveClient::GetInstance().ReportEvent(eventA, g_defaultUserId);
146 BundleActiveEvent eventB(g_defaultBundleName, g_defaultMoudleName, g_defaultFormName,
147 g_defaultDimension, g_defaultFormId, BundleActiveEvent::FORM_IS_REMOVED);
148 BundleActiveClient::GetInstance().ReportEvent(eventB, g_defaultUserId);
149 EXPECT_TRUE(BundleActiveClient::GetInstance().bundleActiveProxy_ != nullptr);
150 }
151
152 /*
153 * @tc.name: DeviceUsageStatisticsTest_QueryBundleEvents_001
154 * @tc.desc: QueryBundleEvents
155 * @tc.type: FUNC
156 * @tc.require: SR000GGTO6 AR000GH6PH
157 */
158 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryBundleEvents_001, Function | MediumTest | Level0)
159 {
160 std::vector<BundleActiveEvent> result;
161 BundleActiveClient::GetInstance().QueryBundleEvents(result, 0, g_largeNum, 100);
162 EXPECT_EQ(result.size() > 0, true);
163 EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleEvents(result, g_largeNum, g_largeNum, 100), 0);
164 }
165
166 /*
167 * @tc.name: DeviceUsageStatisticsTest_QueryCurrentBundleEvents_001
168 * @tc.desc: QueryCurrentBundleEvents
169 * @tc.type: FUNC
170 * @tc.require: SR000GGTO4 AR000GH6PF
171 */
172 HWTEST_F(DeviceUsageStatisticsTest,
173 DeviceUsageStatisticsTest_QueryCurrentBundleEvents_001, Function | MediumTest | Level0)
174 {
175 std::vector<BundleActiveEvent> result;
176 BundleActiveClient::GetInstance().QueryCurrentBundleEvents(result, 0, g_largeNum);
177 EXPECT_EQ(result.size(), 0);
178 }
179
180 /*
181 * @tc.name: DeviceUsageStatisticsTest_QueryPackagesStats_001
182 * @tc.desc: querypackagestats
183 * @tc.type: FUNC
184 * @tc.require: SR000GGTO3 AR000GH6PD
185 */
186 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryPackagesStats_001, Function | MediumTest | Level0)
187 {
188 std::vector<BundleActivePackageStats> result;
189 BundleActiveClient::GetInstance().QueryBundleStatsInfoByInterval(result, 4, 0, g_largeNum);
190 EXPECT_EQ(result.size(), 0);
191 EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleStatsInfoByInterval(result, 4, g_largeNum, g_largeNum), 0);
192 }
193
194 /*
195 * @tc.name: DeviceUsageStatisticsTest_QueryBundleStatsInfos_001
196 * @tc.desc: QueryBundleStatsInfos
197 * @tc.type: FUNC
198 * @tc.require: issuesI5QJD9
199 */
200 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryBundleStatsInfos_001,
201 Function | MediumTest | Level0)
202 {
203 std::vector<BundleActivePackageStats> result;
204 BundleActiveClient::GetInstance().QueryBundleStatsInfos(result, 4, 0, g_largeNum);
205 EXPECT_EQ(result.size(), 0);
206 }
207
208 /*
209 * @tc.name: DeviceUsageStatisticsTest_IsBundleIdle_001
210 * @tc.desc: isbundleidle
211 * @tc.type: FUNC
212 * @tc.require: SR000GGTO5 AR000GH6PG
213 */
214 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_IsBundleIdle_001, Function | MediumTest | Level0)
215 {
216 bool result = false;
217 int32_t errCode = BundleActiveClient::GetInstance().IsBundleIdle(result, g_defaultBundleName, g_defaultUserId);
218 EXPECT_EQ(result, false);
219 EXPECT_EQ(errCode, 0);
220 }
221
222 /*
223 * @tc.name: DeviceUsageStatisticsTest_IsBundleUsePeriod_001
224 * @tc.desc: IsBundleUsePeriod
225 * @tc.type: FUNC
226 * @tc.require: issueIBB2G4
227 */
228 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_IsBundleUsePeriod_001, Function | MediumTest | Level0)
229 {
230 bool result = false;
231 int32_t errCode = BundleActiveClient::GetInstance().IsBundleUsePeriod(result, g_defaultBundleName, g_defaultUserId);
232 EXPECT_EQ(result, false);
233 EXPECT_EQ(errCode, 0);
234 }
235
236 /*
237 * @tc.name: DeviceUsageStatisticsTest_QueryModuleUsageRecords_001
238 * @tc.desc: QueryModuleUsageRecords
239 * @tc.type: FUNC
240 * @tc.require: SR000GU2T1 AR000GU37U
241 */
242 HWTEST_F(DeviceUsageStatisticsTest,
243 DeviceUsageStatisticsTest_QueryModuleUsageRecords_001, Function | MediumTest | Level0)
244 {
245 int32_t maxNum = 1;
246 BundleActiveEvent eventA(g_defaultBundleName, g_defaultMoudleName, g_defaultFormName,
247 g_defaultDimension, g_defaultFormId, BundleActiveEvent::FORM_IS_CLICKED);
248 BundleActiveClient::GetInstance().ReportEvent(eventA, g_defaultUserId);
249 std::vector<BundleActiveModuleRecord> results;
250 int32_t errCode = BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, results, g_defaultUserId);
251 EXPECT_EQ(errCode, 0);
252 EXPECT_EQ(results.size(), 0);
253
254 results.clear();
255 maxNum = 0;
256 errCode = BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, results, g_defaultUserId);
257 EXPECT_NE(errCode, 0);
258
259 results.clear();
260 maxNum = 1001;
261 errCode = BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, results, g_defaultUserId);
262 EXPECT_NE(errCode, 0);
263 }
264
265 /*
266 * @tc.name: DeviceUsageStatisticsTest_RegisterAppGroupCallBack_001
267 * @tc.desc: RegisterAppGroupCallBack
268 * @tc.type: FUNC
269 * @tc.require: SR000H0HAQ AR000H0ROE
270 */
271 HWTEST_F(DeviceUsageStatisticsTest,
272 DeviceUsageStatisticsTest_RegisterAppGroupCallBack_001, Function | MediumTest | Level0)
273 {
274 if (!observer) {
275 BUNDLE_ACTIVE_LOGI("RegisterAppGroupCallBack construct observer!");
276 observer = new (std::nothrow) TestAppGroupChangeCallback();
277 }
278 ASSERT_NE(observer, nullptr);
279 int32_t result = BundleActiveClient::GetInstance().RegisterAppGroupCallBack(observer);
280 EXPECT_EQ(result, DEFAULT_ERRCODE);
281 }
282
283 /*
284 * @tc.name: DeviceUsageStatisticsTest_SetBundleGroup_001
285 * @tc.desc: setbundlename
286 * @tc.type: FUNC
287 * @tc.require: SR000H0HAQ AR000H0ROE
288 */
289 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_SetAppGroup_001, Function | MediumTest | Level0)
290 {
291 int32_t result = 0;
292 BundleActiveClient::GetInstance().QueryAppGroup(result, g_defaultBundleName, g_commonUserid);
293 g_defaultGroup = (result == g_defaultGroup) ? (result + 10) : g_defaultGroup;
294 result = BundleActiveClient::GetInstance().SetAppGroup(g_defaultBundleName, g_defaultGroup, g_commonUserid);
295 EXPECT_EQ(result, DEFAULT_ERRCODE);
296
297 result = BundleActiveClient::GetInstance().SetAppGroup(g_defaultBundleName, g_defaultGroup, -1);
298 EXPECT_NE(result, DEFAULT_ERRCODE);
299 }
300
301 /*
302 * @tc.name: DeviceUsageStatisticsTest_QueryAppGroup_001
303 * @tc.desc: QueryAppGroup, no bundleName
304 * @tc.type: FUNC
305 * @tc.require: SR000H0HAQ AR000H0ROE
306 */
307 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryAppGroup_001, Function | MediumTest | Level0)
308 {
309 BundleActiveClient::GetInstance().SetAppGroup(g_defaultBundleName, g_defaultGroup, g_commonUserid);
310 int32_t result = 0;
311 BundleActiveClient::GetInstance().QueryAppGroup(result, g_defaultBundleName, g_commonUserid);
312 bool flag = false;
313 for (auto item = GROUP_TYPE.begin(); item != GROUP_TYPE.end(); item++) {
314 if (*item == result) {
315 flag = true;
316 break;
317 }
318 }
319 EXPECT_EQ(flag, true);
320 }
321
322 /*
323 * @tc.name: DeviceUsageStatisticsTest_UnRegisterAppGroupCallBack_001
324 * @tc.desc: UnRegisterAppGroupCallBack
325 * @tc.type: FUNC
326 * @tc.require: SR000H0HAQ AR000H0ROE
327 */
328 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_UnRegisterAppGroupCallBack_001,
329 Function | MediumTest | Level0)
330 {
331 if (!observer) {
332 BUNDLE_ACTIVE_LOGI("observer has been delete");
333 }
334 ASSERT_NE(observer, nullptr);
335 int32_t result = BundleActiveClient::GetInstance().UnRegisterAppGroupCallBack(observer);
336 observer = nullptr;
337 EXPECT_EQ(result, DEFAULT_ERRCODE);
338 }
339
340 /*
341 * @tc.name: DeviceUsageStatisticsTest_QueryDeviceEventStats_001
342 * @tc.desc: QueryDeviceEventStats
343 * @tc.type: FUNC
344 * @tc.require: SR000H0H9H AR000H0ROG
345 */
346 HWTEST_F(DeviceUsageStatisticsTest,
347 DeviceUsageStatisticsTest_QueryDeviceEventStats_001, Function | MediumTest | Level0)
348 {
349 std::vector<BundleActiveEventStats> eventStats;
350 int32_t errCode = BundleActiveClient::GetInstance().QueryDeviceEventStats(0, g_largeNum, eventStats);
351 EXPECT_EQ(errCode, 0);
352 errCode = BundleActiveClient::GetInstance().QueryDeviceEventStats(0, g_largeNum, eventStats, g_commonUserid);
353 EXPECT_EQ(errCode, 0);
354 }
355
356 /*
357 * @tc.name: DeviceUsageStatisticsTest_QueryNotificationEventStats_001
358 * @tc.desc: QueryNotificationEventStats
359 * @tc.type: FUNC
360 * @tc.require: SR000H0H7D AR000H0RR6
361 */
362 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_QueryNotificationEventStats_001, Function
363 | MediumTest | Level0)
364 {
365 std::vector<BundleActiveEventStats> eventStats;
366 int32_t errCode = BundleActiveClient::GetInstance().QueryNotificationEventStats(0, g_largeNum, eventStats);
367 EXPECT_EQ(errCode, 0);
368 errCode = BundleActiveClient::GetInstance().QueryNotificationEventStats(0, g_largeNum, eventStats, g_commonUserid);
369 EXPECT_EQ(errCode, 0);
370 }
371
372 /*
373 * @tc.name: DeviceUsageStatisticsTest_BundleActiveGroupMap_001
374 * @tc.desc: BundleActiveGroupMap
375 * @tc.type: FUNC
376 * @tc.require: SR000H0G4F AR000H2US8
377 */
378 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_BundleActiveGroupMap_001, Function | MediumTest | Level0)
379 {
380 int64_t minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
381 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_FORCED_SET);
382 EXPECT_EQ(minInterval, 0);
383 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
384 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_ALIVE);
385 EXPECT_EQ(minInterval, DeviceUsageStatsGroupConst::TWO_HOUR);
386 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
387 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_DAILY);
388 EXPECT_EQ(minInterval, 2 * DeviceUsageStatsGroupConst::TWO_HOUR);
389 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
390 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_FIXED);
391 EXPECT_EQ(minInterval, DeviceUsageStatsGroupConst::TWENTY_FOUR_HOUR);
392 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
393 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_RARE);
394 EXPECT_EQ(minInterval, DeviceUsageStatsGroupConst::FOURTY_EIGHT_HOUR);
395 }
396
397 /*
398 * @tc.name: DeviceUsageStatisticsTest_DeathRecipient_001
399 * @tc.desc: DeathRecipient_001
400 * @tc.type: FUNC
401 * @tc.require: issuesI5SOZY
402 */
403 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_DeathRecipient_001, Function | MediumTest | Level0)
404 {
405 auto deathTest = std::make_shared<BundleActiveClient::BundleActiveClientDeathRecipient>();
406 deathTest->AddObserver(observer);
407 deathTest->RemoveObserver();
408 deathTest->OnServiceDiedInner();
409
410 deathTest->observer_ = new (std::nothrow) TestAppGroupChangeCallback();
411 deathTest->OnServiceDiedInner();
412 EXPECT_TRUE(deathTest != nullptr);
413 deathTest->OnRemoteDied(nullptr);
414 }
415
416 /*
417 * @tc.name: DeviceUsageStatisticsTest_AppGroupCallbackInfo_001
418 * @tc.desc: AppGroupCallbackInfo_001
419 * @tc.type: FUNC
420 * @tc.require: issuesI5SOZY
421 */
422 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_AppGroupCallbackInfo_001, Function | MediumTest | 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, Function | MediumTest | Level0)
450 {
451 auto bundleActiveEventStats = std::make_shared<BundleActiveEventStats>();
452 bundleActiveEventStats->eventId_ = g_commonUserid;
453 bundleActiveEventStats->beginTimeStamp_ = 0;
454 bundleActiveEventStats->endTimeStamp_ = g_largeNum;
455 bundleActiveEventStats->lastEventTime_ = g_largeNum;
456 bundleActiveEventStats->totalTime_ = g_largeNum;
457 bundleActiveEventStats->count_ = 1;
458
459 MessageParcel data;
460 EXPECT_TRUE(bundleActiveEventStats->Marshalling(data));
461 auto tempEventStats = bundleActiveEventStats->Unmarshalling(data);
462 EXPECT_TRUE(tempEventStats != nullptr);
463
464 auto bundleActiveEvent = std::make_shared<BundleActiveEvent>();
465 EXPECT_TRUE(bundleActiveEvent->Marshalling(data));
466 auto tempEvent = bundleActiveEvent->Unmarshalling(data);
467 EXPECT_TRUE(tempEvent != nullptr);
468
469 EXPECT_EQ(tempEventStats->GetEventId(), g_commonUserid);
470 EXPECT_EQ(tempEventStats->GetFirstTimeStamp(), 0);
471 EXPECT_EQ(tempEventStats->GetLastTimeStamp(), g_largeNum);
472 EXPECT_EQ(tempEventStats->GetLastEventTime(), g_largeNum);
473 EXPECT_EQ(tempEventStats->GetTotalTime(), g_largeNum);
474 EXPECT_EQ(tempEventStats->GetCount(), 1);
475 }
476
477 /*
478 * @tc.name: DeviceUsageStatisticsTest_FormRecord_001
479 * @tc.desc: BundleActiveFormRecord_001
480 * @tc.type: FUNC
481 * @tc.require: issuesI5SOZY
482 */
483 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_FormRecord_001, Function | MediumTest | Level0)
484 {
485 auto bundleActiveFormRecord = std::make_shared<BundleActiveFormRecord>();
486 EXPECT_NE(bundleActiveFormRecord->ToString(), " ");
487
488 MessageParcel data;
489 EXPECT_TRUE(bundleActiveFormRecord->Marshalling(data));
490 EXPECT_TRUE(bundleActiveFormRecord->Unmarshalling(data) != nullptr);
491
492 BundleActiveFormRecord bundleActiveFormRecordA;
493 bundleActiveFormRecordA.count_ = 2;
494 BundleActiveFormRecord bundleActiveFormRecordB;
495 bundleActiveFormRecordB.count_ = 1;
496 EXPECT_TRUE(bundleActiveFormRecord->cmp(bundleActiveFormRecordA, bundleActiveFormRecordB));
497 }
498
499 /*
500 * @tc.name: DeviceUsageStatisticsTest_BundleActiveEvent_001
501 * @tc.desc: BundleActiveEvent_001
502 * @tc.type: FUNC
503 * @tc.require: issuesI5SOZY
504 */
505 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_BundleActiveEvent_001, Function | MediumTest | Level0)
506 {
507 BundleActiveEvent bundleActiveEvent;
508 BundleActiveEvent bundleActiveEventA;
509 EXPECT_NE(bundleActiveEvent.ToString(), " ");
510 bundleActiveEvent = bundleActiveEventA;
511 }
512
513 /*
514 * @tc.name: DeviceUsageStatisticsTest_PackageStats_001
515 * @tc.desc: BundleActivePackageStats_001
516 * @tc.type: FUNC
517 * @tc.require: issuesI5SOZY
518 */
519 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_PackageStats_001, Function | MediumTest | Level0)
520 {
521 auto bundleActivePackageStats = std::make_shared<BundleActivePackageStats>();
522 bundleActivePackageStats->IncrementBundleLaunchedCount();
523 EXPECT_NE(bundleActivePackageStats->ToString(), " ");
524
525 MessageParcel data;
526 EXPECT_TRUE(bundleActivePackageStats->Marshalling(data));
527 EXPECT_TRUE(bundleActivePackageStats->Unmarshalling(data) != nullptr);
528 }
529
530 /*
531 * @tc.name: DeviceUsageStatisticsTest_ModuleRecord_001
532 * @tc.desc: BundleActiveModuleRecord_001
533 * @tc.type: FUNC
534 * @tc.require: issuesI5SOZY
535 */
536 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_ModuleRecord_001, Function | MediumTest | Level0)
537 {
538 auto bundleActiveModuleRecord = std::make_shared<BundleActiveModuleRecord>();
539 EXPECT_NE(bundleActiveModuleRecord->ToString(), " ");
540
541 MessageParcel data;
542 EXPECT_TRUE(bundleActiveModuleRecord->Marshalling(data));
543 EXPECT_TRUE(bundleActiveModuleRecord->Unmarshalling(data) != nullptr);
544
545 BundleActiveModuleRecord bundleActiveModuleRecordA;
546 bundleActiveModuleRecordA.lastModuleUsedTime_ = 2;
547 BundleActiveModuleRecord bundleActiveModuleRecordB;
548 bundleActiveModuleRecordB.lastModuleUsedTime_ = 1;
549 EXPECT_TRUE(bundleActiveModuleRecord->cmp(bundleActiveModuleRecordA, bundleActiveModuleRecordB));
550
551 BundleActiveModuleRecord bundleActiveModuleRecordC;
552 bundleActiveModuleRecordC.lastModuleUsedTime_ = 2;
553 bundleActiveModuleRecord->UpdateModuleRecord(1000);
554 SUCCEED();
555 }
556
557 /*
558 * @tc.name: DeviceUsageStatisticsTest_AppGroupCallbackProxy_001
559 * @tc.desc: AppGroupCallbackProxy_001
560 * @tc.type: FUNC
561 * @tc.require: issuesI5SOZY
562 */
563 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_AppGroupCallbackProxy_001, Function | MediumTest | Level0)
564 {
565 int32_t oldGroup = 60;
566 int32_t newGroup = 10;
567 uint32_t changeReason = 1;
568 AppGroupCallbackInfo appGroupCallbackInfo(g_commonUserid, oldGroup, newGroup, changeReason, g_defaultBundleName);
569
570 auto appGroupCallbackProxy = std::make_shared<AppGroupCallbackProxy>(nullptr);
571 appGroupCallbackProxy->OnAppGroupChanged(appGroupCallbackInfo);
572 EXPECT_NE(appGroupCallbackProxy, nullptr);
573 }
574
575 /*
576 * @tc.name: DeviceUsageStatisticsTest_AppGroupCallbackStub_001
577 * @tc.desc: AppGroupCallbackStub_001
578 * @tc.type: FUNC
579 * @tc.require: issuesI5SOZY
580 */
581 HWTEST_F(DeviceUsageStatisticsTest, DeviceUsageStatisticsTest_AppGroupCallbackStub_001, Function | MediumTest | Level0)
582 {
583 int32_t oldGroup = 60;
584 int32_t newGroup = 10;
585 uint32_t changeReason = 1;
586 AppGroupCallbackInfo appGroupCallbackInfo(g_commonUserid, oldGroup, newGroup, changeReason, g_defaultBundleName);
587
588 auto appGroupCallbackStub = std::make_shared<TestAppGroupChangeCallback>();
589 appGroupCallbackStub->OnAppGroupChanged(appGroupCallbackInfo);
590 MessageParcel data1;
591 MessageParcel reply;
592 MessageOption option;
593 EXPECT_EQ(appGroupCallbackStub->OnRemoteRequest(1, data1, reply, option), 1);
594 data1.WriteInterfaceToken(AppGroupCallbackStub::GetDescriptor());
595 EXPECT_EQ(appGroupCallbackStub->OnRemoteRequest(1, data1, reply, option), 5);
596 }
597 } // namespace DeviceUsageStats
598 } // namespace OHOS
599
600