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