1 /*
2 * Copyright (c) 2023 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 <gtest/hwext/gtest-multithread.h>
20 #include <unistd.h>
21 #include "system_ability_definition.h"
22
23 #include "bundle_active_client.h"
24 #include "bundle_active_event.h"
25 #include "app_group_callback_stub.h"
26 #include "bundle_active_group_map.h"
27 #include "app_group_callback_info.h"
28 #include "bundle_active_form_record.h"
29 #include "bundle_active_event_stats.h"
30 #include "bundle_active_module_record.h"
31 #include "bundle_active_package_stats.h"
32 #include "app_group_callback_proxy.h"
33 #include "bundle_active_log.h"
34 #include "iapp_group_callback.h"
35 #include "accesstoken_kit.h"
36 #include "token_setproc.h"
37 #include "nativetoken_kit.h"
38
39 using namespace testing::ext;
40 using namespace testing::mt;
41
42 namespace OHOS {
43 namespace DeviceUsageStats {
44 using namespace Security::AccessToken;
45 #ifdef __aarch64__
46 static std::string g_defaultBundleName = "com.huawei.hmos.camera";
47 #else
48 static std::string g_defaultBundleName = "com.ohos.camera";
49 #endif
50 static std::string g_defaultMoudleName = "defaultmodulename";
51 static std::string g_defaultFormName = "defaultformname";
52 static int32_t g_defaultDimension = 4;
53 static int64_t g_defaultFormId = 1;
54 static int32_t g_defaultUserId = 0;
55 static int32_t g_commonUserid = 100;
56 static int64_t g_largeNum = 20000000000000;
57 static int32_t g_defaultGroup = 10;
58 static int32_t g_intervalType = 4;
59 static int32_t g_maxNum = 1001;
60 static int32_t g_fourHour = 2 * DeviceUsageStatsGroupConst::TWO_HOUR;
61 static std::vector<int32_t> GROUP_TYPE {10, 20, 30, 40, 50};
62 static sptr<IAppGroupCallback> observer = nullptr;
63
64 class DeviceUsageStatisticsMultiTest : public testing::Test {
65 public:
66 static void SetUpTestCase(void);
67 static void TearDownTestCase(void);
68 void SetUp();
69 void TearDown();
70 };
71
SetUpTestCase(void)72 void DeviceUsageStatisticsMultiTest::SetUpTestCase(void)
73 {
74 static const char *perms[] = {
75 "ohos.permission.BUNDLE_ACTIVE_INFO",
76 };
77 uint64_t tokenId;
78 NativeTokenInfoParams infoInstance = {
79 .dcapsNum = 0,
80 .permsNum = 1,
81 .aclsNum = 0,
82 .dcaps = nullptr,
83 .perms = perms,
84 .acls = nullptr,
85 .processName = "DeviceUsageStatisticsMultiTest",
86 .aplStr = "system_core",
87 };
88 tokenId = GetAccessTokenId(&infoInstance);
89 SetSelfTokenID(tokenId);
90 AccessTokenKit::ReloadNativeTokenInfo();
91 }
92
TearDownTestCase(void)93 void DeviceUsageStatisticsMultiTest::TearDownTestCase(void)
94 {
95 }
96
SetUp(void)97 void DeviceUsageStatisticsMultiTest::SetUp(void)
98 {
99 }
100
TearDown(void)101 void DeviceUsageStatisticsMultiTest::TearDown(void)
102 {
103 }
104
105 class TestAppGroupChangeCallback : public AppGroupCallbackStub {
106 public:
107 ErrCode OnAppGroupChanged(const AppGroupCallbackInfo &appGroupCallbackInfo) override;
108 };
109
OnAppGroupChanged(const AppGroupCallbackInfo & appGroupCallbackInfo)110 ErrCode TestAppGroupChangeCallback::OnAppGroupChanged(const AppGroupCallbackInfo &appGroupCallbackInfo)
111 {
112 BUNDLE_ACTIVE_LOGI("TestAppGroupChangeCallback::OnAppGroupChanged!");
113 MessageParcel data;
114 if (!appGroupCallbackInfo.Marshalling(data)) {
115 BUNDLE_ACTIVE_LOGE("Marshalling fail");
116 }
117 appGroupCallbackInfo.Unmarshalling(data);
118 return ERR_OK;
119 }
120
121 /*
122 * @tc.name: DeviceUsageStatisticsMultiTest_IsBundleIdle_001
123 * @tc.desc: isbundleidle
124 * @tc.type: FUNC
125 * @tc.require: SR000GGTO5 AR000GH6PG
126 */
MultiTestIsBundleIdle(void)127 void MultiTestIsBundleIdle(void)
128 {
129 bool result = false;
130 int32_t errCode = BundleActiveClient::GetInstance().IsBundleIdle(result, g_defaultBundleName, g_defaultUserId);
131 EXPECT_EQ(result, false);
132 EXPECT_EQ(errCode, 0);
133 }
134
135 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_IsBundleIdle_001,
136 Function | MediumTest | Level0)
137 {
138 SET_THREAD_NUM(100);
139 GTEST_RUN_TASK(MultiTestIsBundleIdle);
140 }
141
142 /*
143 * @tc.name: DeviceUsageStatisticsMultiTest_ReportEvent_001
144 * @tc.desc: report a mock event
145 * @tc.type: FUNC
146 * @tc.require: SR000GGTO7 SR000GU31B AR000GH6PJ AR000GU380
147 */
MultiTestReportEvent(void)148 void MultiTestReportEvent(void)
149 {
150 BundleActiveEvent eventA(g_defaultBundleName, g_defaultMoudleName, g_defaultFormName,
151 g_defaultDimension, g_defaultFormId, BundleActiveEvent::FORM_IS_CLICKED);
152 BundleActiveClient::GetInstance().ReportEvent(eventA, g_defaultUserId);
153 BundleActiveEvent eventB(g_defaultBundleName, g_defaultMoudleName, g_defaultFormName,
154 g_defaultDimension, g_defaultFormId, BundleActiveEvent::FORM_IS_REMOVED);
155 BundleActiveClient::GetInstance().ReportEvent(eventB, g_defaultUserId);
156 }
157
158 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_ReportEvent_001, Function | MediumTest | Level0)
159 {
160 SET_THREAD_NUM(100);
161 GTEST_RUN_TASK(MultiTestReportEvent);
162 }
163
164 /*
165 * @tc.name: DeviceUsageStatisticsMultiTest_QueryBundleEvents_001
166 * @tc.desc: QueryBundleEvents
167 * @tc.type: FUNC
168 * @tc.require: SR000GGTO6 AR000GH6PH
169 */
MultiTestQueryBundleEvents(void)170 void MultiTestQueryBundleEvents(void)
171 {
172 std::vector<BundleActiveEvent> result;
173 BundleActiveClient::GetInstance().QueryBundleEvents(result, 0, g_largeNum, g_commonUserid);
174 EXPECT_EQ(result.size() > 0, true);
175 EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleEvents(result, g_largeNum, g_largeNum, g_commonUserid), 0);
176 }
177
178 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_QueryBundleEvents_001,
179 Function | MediumTest | Level0)
180 {
181 SET_THREAD_NUM(100);
182 GTEST_RUN_TASK(MultiTestQueryBundleEvents);
183 }
184
185 /*
186 * @tc.name: DeviceUsageStatisticsMultiTest_QueryCurrentBundleEvents_001
187 * @tc.desc: QueryCurrentBundleEvents
188 * @tc.type: FUNC
189 * @tc.require: SR000GGTO4 AR000GH6PF
190 */
MultiTestQueryCurrentBundleEvents(void)191 void MultiTestQueryCurrentBundleEvents(void)
192 {
193 std::vector<BundleActiveEvent> result;
194 BundleActiveClient::GetInstance().QueryCurrentBundleEvents(result, 0, g_largeNum);
195 EXPECT_EQ(result.size(), 0);
196 }
197
198 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_QueryCurrentBundleEvents_001,
199 Function | MediumTest | Level0)
200 {
201 SET_THREAD_NUM(100);
202 GTEST_RUN_TASK(MultiTestQueryCurrentBundleEvents);
203 }
204
205 /*
206 * @tc.name: DeviceUsageStatisticsMultiTest_QueryPackagesStats_001
207 * @tc.desc: querypackagestats
208 * @tc.type: FUNC
209 * @tc.require: SR000GGTO3 AR000GH6PD
210 */
MultiTestQueryBundleStatsInfoByInterval(void)211 void MultiTestQueryBundleStatsInfoByInterval(void)
212 {
213 std::vector<BundleActivePackageStats> result;
214 BundleActiveClient::GetInstance().QueryBundleStatsInfoByInterval(result, g_intervalType, 0, g_largeNum);
215 EXPECT_EQ(result.size(), 0);
216 EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleStatsInfoByInterval(
217 result, g_intervalType, g_largeNum, g_largeNum), 0);
218 }
219
220 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_QueryPackagesStats_001,
221 Function | MediumTest | Level0)
222 {
223 SET_THREAD_NUM(100);
224 GTEST_RUN_TASK(MultiTestQueryBundleStatsInfoByInterval);
225 }
226
227 /*
228 * @tc.name: DeviceUsageStatisticsMultiTest_QueryBundleStatsInfos_001
229 * @tc.desc: QueryBundleStatsInfos
230 * @tc.type: FUNC
231 * @tc.require: issuesI5QJD9
232 */
MultiTestQueryBundleStatsInfos(void)233 void MultiTestQueryBundleStatsInfos(void)
234 {
235 std::vector<BundleActivePackageStats> result;
236 BundleActiveClient::GetInstance().QueryBundleStatsInfos(result, g_intervalType, 0, g_largeNum);
237 EXPECT_EQ(result.size(), 0);
238 }
239
240 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_QueryBundleStatsInfos_001,
241 Function | MediumTest | Level0)
242 {
243 SET_THREAD_NUM(100);
244 GTEST_RUN_TASK(MultiTestQueryBundleStatsInfos);
245 }
246
247 /*
248 * @tc.name: DeviceUsageStatisticsMultiTest_QueryModuleUsageRecords_001
249 * @tc.desc: QueryModuleUsageRecords
250 * @tc.type: FUNC
251 * @tc.require: SR000GU2T1 AR000GU37U
252 */
MultiTestQueryModuleUsageRecords(void)253 void MultiTestQueryModuleUsageRecords(void)
254 {
255 int32_t maxNum = 1;
256 BundleActiveEvent eventA(g_defaultBundleName, g_defaultMoudleName, g_defaultFormName,
257 g_defaultDimension, g_defaultFormId, BundleActiveEvent::FORM_IS_CLICKED);
258 BundleActiveClient::GetInstance().ReportEvent(eventA, g_defaultUserId);
259 std::vector<BundleActiveModuleRecord> results;
260 int32_t errCode = BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, results, g_defaultUserId);
261 EXPECT_EQ(errCode, 0);
262 EXPECT_EQ(results.size(), 0);
263
264 results.clear();
265 maxNum = 0;
266 errCode = BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, results, g_defaultUserId);
267 EXPECT_NE(errCode, 0);
268
269 results.clear();
270 maxNum = g_maxNum;
271 errCode = BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, results, g_defaultUserId);
272 EXPECT_NE(errCode, 0);
273 }
274
275 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_QueryModuleUsageRecords_001,
276 Function | MediumTest | Level0)
277 {
278 SET_THREAD_NUM(100);
279 GTEST_RUN_TASK(MultiTestQueryModuleUsageRecords);
280 }
281
282 /*
283 * @tc.name: DeviceUsageStatisticsMultiTest_QueryAppGroup_001
284 * @tc.desc: QueryAppGroup, no bundleName
285 * @tc.type: FUNC
286 * @tc.require: SR000H0HAQ AR000H0ROE
287 */
MultiTestAppGroup(void)288 void MultiTestAppGroup(void)
289 {
290 BundleActiveClient::GetInstance().SetAppGroup(g_defaultBundleName, g_defaultGroup, g_commonUserid);
291 int32_t result = 0;
292 BundleActiveClient::GetInstance().QueryAppGroup(result, g_defaultBundleName, g_commonUserid);
293 bool flag = false;
294 for (auto item = GROUP_TYPE.begin(); item != GROUP_TYPE.end(); item++) {
295 if (*item == result) {
296 flag = true;
297 break;
298 }
299 }
300 EXPECT_EQ(flag, true);
301 }
302
303 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_AppGroup_001, Function | MediumTest | Level0)
304 {
305 SET_THREAD_NUM(100);
306 GTEST_RUN_TASK(MultiTestAppGroup);
307 }
308
309 /*
310 * @tc.name: DeviceUsageStatisticsMultiTest_QueryDeviceEventStats_001
311 * @tc.desc: QueryDeviceEventStats
312 * @tc.type: FUNC
313 * @tc.require: SR000H0H9H AR000H0ROG
314 */
MultiTestQueryDeviceEventStats(void)315 void MultiTestQueryDeviceEventStats(void)
316 {
317 std::vector<BundleActiveEventStats> eventStats;
318 int32_t errCode = BundleActiveClient::GetInstance().QueryDeviceEventStats(0, g_largeNum, eventStats);
319 EXPECT_EQ(errCode, 0);
320 errCode = BundleActiveClient::GetInstance().QueryDeviceEventStats(0, g_largeNum, eventStats, g_commonUserid);
321 EXPECT_EQ(errCode, 0);
322 }
323
324 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_QueryDeviceEventStats_001,
325 Function | MediumTest | Level0)
326 {
327 SET_THREAD_NUM(100);
328 GTEST_RUN_TASK(MultiTestQueryDeviceEventStats);
329 }
330
331 /*
332 * @tc.name: DeviceUsageStatisticsMultiTest_QueryNotificationEventStats_001
333 * @tc.desc: QueryNotificationEventStats
334 * @tc.type: FUNC
335 * @tc.require: SR000H0H7D AR000H0RR6
336 */
MultiTestQueryNotificationEventStats(void)337 void MultiTestQueryNotificationEventStats(void)
338 {
339 std::vector<BundleActiveEventStats> eventStats;
340 int32_t errCode = BundleActiveClient::GetInstance().QueryNotificationEventStats(0, g_largeNum, eventStats);
341 EXPECT_EQ(errCode, 0);
342 errCode = BundleActiveClient::GetInstance().QueryNotificationEventStats(0, g_largeNum, eventStats, g_commonUserid);
343 EXPECT_EQ(errCode, 0);
344 }
345
346 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_QueryNotificationEventStats_001,
347 Function | MediumTest | Level0)
348 {
349 SET_THREAD_NUM(100);
350 GTEST_RUN_TASK(MultiTestQueryNotificationEventStats);
351 }
352
353 /*
354 * @tc.name: DeviceUsageStatisticsMultiTest_BundleActiveGroupMap_001
355 * @tc.desc: BundleActiveGroupMap
356 * @tc.type: FUNC
357 * @tc.require: SR000H0G4F AR000H2US8
358 */
MultiTestDeviceUsageStatsGroupMap(void)359 void MultiTestDeviceUsageStatsGroupMap(void)
360 {
361 int64_t minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
362 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_FORCED_SET);
363 EXPECT_EQ(minInterval, 0);
364 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
365 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_ALIVE);
366 EXPECT_EQ(minInterval, DeviceUsageStatsGroupConst::TWO_HOUR);
367 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
368 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_DAILY);
369 EXPECT_EQ(minInterval, g_fourHour);
370 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
371 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_FIXED);
372 EXPECT_EQ(minInterval, DeviceUsageStatsGroupConst::TWENTY_FOUR_HOUR);
373 minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
374 .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_RARE);
375 EXPECT_EQ(minInterval, DeviceUsageStatsGroupConst::FOURTY_EIGHT_HOUR);
376 }
377
378 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_BundleActiveGroupMap_001,
379 Function | MediumTest | Level0)
380 {
381 SET_THREAD_NUM(100);
382 GTEST_RUN_TASK(MultiTestDeviceUsageStatsGroupMap);
383 }
384 } // namespace DeviceUsageStats
385 } // namespace OHOS
386
387