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     void OnAppGroupChanged(const AppGroupCallbackInfo &appGroupCallbackInfo) override;
108 };
109 
OnAppGroupChanged(const AppGroupCallbackInfo & appGroupCallbackInfo)110 void 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 }
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 | 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     BundleActiveClient::GetInstance().ReportEvent(eventB, g_defaultUserId);
155 }
156 
157 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_ReportEvent_001, Function | MediumTest | Level0)
158 {
159     SET_THREAD_NUM(100);
160     GTEST_RUN_TASK(MultiTestReportEvent);
161 }
162 
163 /*
164  * @tc.name: DeviceUsageStatisticsMultiTest_QueryBundleEvents_001
165  * @tc.desc: QueryBundleEvents
166  * @tc.type: FUNC
167  * @tc.require: SR000GGTO6 AR000GH6PH
168  */
MultiTestQueryBundleEvents(void)169 void MultiTestQueryBundleEvents(void)
170 {
171     std::vector<BundleActiveEvent> result;
172     BundleActiveClient::GetInstance().QueryBundleEvents(result, 0, g_largeNum, g_commonUserid);
173     EXPECT_EQ(result.size() > 0, true);
174     EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleEvents(result, g_largeNum, g_largeNum, g_commonUserid), 0);
175 }
176 
177 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_QueryBundleEvents_001,
178     Function | MediumTest | Level0)
179 {
180     SET_THREAD_NUM(100);
181     GTEST_RUN_TASK(MultiTestQueryBundleEvents);
182 }
183 
184 /*
185  * @tc.name: DeviceUsageStatisticsMultiTest_QueryCurrentBundleEvents_001
186  * @tc.desc: QueryCurrentBundleEvents
187  * @tc.type: FUNC
188  * @tc.require: SR000GGTO4 AR000GH6PF
189  */
MultiTestQueryCurrentBundleEvents(void)190 void MultiTestQueryCurrentBundleEvents(void)
191 {
192     std::vector<BundleActiveEvent> result;
193     BundleActiveClient::GetInstance().QueryCurrentBundleEvents(result, 0, g_largeNum);
194     EXPECT_EQ(result.size(), 0);
195 }
196 
197 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_QueryCurrentBundleEvents_001,
198     Function | MediumTest | Level0)
199 {
200     SET_THREAD_NUM(100);
201     GTEST_RUN_TASK(MultiTestQueryCurrentBundleEvents);
202 }
203 
204 /*
205  * @tc.name: DeviceUsageStatisticsMultiTest_QueryPackagesStats_001
206  * @tc.desc: querypackagestats
207  * @tc.type: FUNC
208  * @tc.require: SR000GGTO3 AR000GH6PD
209  */
MultiTestQueryBundleStatsInfoByInterval(void)210 void MultiTestQueryBundleStatsInfoByInterval(void)
211 {
212     std::vector<BundleActivePackageStats> result;
213     BundleActiveClient::GetInstance().QueryBundleStatsInfoByInterval(result, g_intervalType, 0, g_largeNum);
214     EXPECT_EQ(result.size(), 0);
215     EXPECT_NE(BundleActiveClient::GetInstance().QueryBundleStatsInfoByInterval(
216         result, g_intervalType, g_largeNum, g_largeNum), 0);
217 }
218 
219 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_QueryPackagesStats_001,
220     Function | MediumTest | Level0)
221 {
222     SET_THREAD_NUM(100);
223     GTEST_RUN_TASK(MultiTestQueryBundleStatsInfoByInterval);
224 }
225 
226 /*
227  * @tc.name: DeviceUsageStatisticsMultiTest_QueryBundleStatsInfos_001
228  * @tc.desc: QueryBundleStatsInfos
229  * @tc.type: FUNC
230  * @tc.require: issuesI5QJD9
231  */
MultiTestQueryBundleStatsInfos(void)232 void MultiTestQueryBundleStatsInfos(void)
233 {
234     std::vector<BundleActivePackageStats> result;
235     BundleActiveClient::GetInstance().QueryBundleStatsInfos(result, g_intervalType, 0, g_largeNum);
236     EXPECT_EQ(result.size(), 0);
237 }
238 
239 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_QueryBundleStatsInfos_001,
240     Function | MediumTest | Level0)
241 {
242     SET_THREAD_NUM(100);
243     GTEST_RUN_TASK(MultiTestQueryBundleStatsInfos);
244 }
245 
246 /*
247  * @tc.name: DeviceUsageStatisticsMultiTest_QueryModuleUsageRecords_001
248  * @tc.desc: QueryModuleUsageRecords
249  * @tc.type: FUNC
250  * @tc.require: SR000GU2T1 AR000GU37U
251  */
MultiTestQueryModuleUsageRecords(void)252 void MultiTestQueryModuleUsageRecords(void)
253 {
254     int32_t maxNum = 1;
255     BundleActiveEvent eventA(g_defaultBundleName, g_defaultMoudleName, g_defaultFormName,
256         g_defaultDimension, g_defaultFormId, BundleActiveEvent::FORM_IS_CLICKED);
257     BundleActiveClient::GetInstance().ReportEvent(eventA, g_defaultUserId);
258     std::vector<BundleActiveModuleRecord> results;
259     int32_t errCode = BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, results, g_defaultUserId);
260     EXPECT_EQ(errCode, 0);
261     EXPECT_EQ(results.size(), 0);
262 
263     results.clear();
264     maxNum = 0;
265     errCode = BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, results, g_defaultUserId);
266     EXPECT_NE(errCode, 0);
267 
268     results.clear();
269     maxNum = g_maxNum;
270     errCode = BundleActiveClient::GetInstance().QueryModuleUsageRecords(maxNum, results, g_defaultUserId);
271     EXPECT_NE(errCode, 0);
272 }
273 
274 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_QueryModuleUsageRecords_001,
275     Function | MediumTest | Level0)
276 {
277     SET_THREAD_NUM(100);
278     GTEST_RUN_TASK(MultiTestQueryModuleUsageRecords);
279 }
280 
281 /*
282  * @tc.name: DeviceUsageStatisticsMultiTest_QueryAppGroup_001
283  * @tc.desc: QueryAppGroup, no bundleName
284  * @tc.type: FUNC
285  * @tc.require: SR000H0HAQ AR000H0ROE
286  */
MultiTestAppGroup(void)287 void MultiTestAppGroup(void)
288 {
289     BundleActiveClient::GetInstance().SetAppGroup(g_defaultBundleName, g_defaultGroup, g_commonUserid);
290     int32_t result = 0;
291     BundleActiveClient::GetInstance().QueryAppGroup(result, g_defaultBundleName, g_commonUserid);
292     bool flag = false;
293     for (auto item = GROUP_TYPE.begin(); item != GROUP_TYPE.end(); item++) {
294         if (*item == result) {
295             flag = true;
296             break;
297         }
298     }
299     EXPECT_EQ(flag, true);
300 }
301 
302 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_AppGroup_001, Function | MediumTest | Level0)
303 {
304     SET_THREAD_NUM(100);
305     GTEST_RUN_TASK(MultiTestAppGroup);
306 }
307 
308 /*
309  * @tc.name: DeviceUsageStatisticsMultiTest_QueryDeviceEventStats_001
310  * @tc.desc: QueryDeviceEventStats
311  * @tc.type: FUNC
312  * @tc.require: SR000H0H9H AR000H0ROG
313  */
MultiTestQueryDeviceEventStats(void)314 void MultiTestQueryDeviceEventStats(void)
315 {
316     std::vector<BundleActiveEventStats> eventStats;
317     int32_t errCode = BundleActiveClient::GetInstance().QueryDeviceEventStats(0, g_largeNum, eventStats);
318     EXPECT_EQ(errCode, 0);
319     errCode = BundleActiveClient::GetInstance().QueryDeviceEventStats(0, g_largeNum, eventStats, g_commonUserid);
320     EXPECT_EQ(errCode, 0);
321 }
322 
323 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_QueryDeviceEventStats_001,
324     Function | MediumTest | Level0)
325 {
326     SET_THREAD_NUM(100);
327     GTEST_RUN_TASK(MultiTestQueryDeviceEventStats);
328 }
329 
330 /*
331  * @tc.name: DeviceUsageStatisticsMultiTest_QueryNotificationEventStats_001
332  * @tc.desc: QueryNotificationEventStats
333  * @tc.type: FUNC
334  * @tc.require: SR000H0H7D AR000H0RR6
335  */
MultiTestQueryNotificationEventStats(void)336 void MultiTestQueryNotificationEventStats(void)
337 {
338     std::vector<BundleActiveEventStats> eventStats;
339     int32_t errCode = BundleActiveClient::GetInstance().QueryNotificationEventStats(0, g_largeNum, eventStats);
340     EXPECT_EQ(errCode, 0);
341     errCode = BundleActiveClient::GetInstance().QueryNotificationEventStats(0, g_largeNum, eventStats, g_commonUserid);
342     EXPECT_EQ(errCode, 0);
343 }
344 
345 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_QueryNotificationEventStats_001,
346     Function | MediumTest | Level0)
347 {
348     SET_THREAD_NUM(100);
349     GTEST_RUN_TASK(MultiTestQueryNotificationEventStats);
350 }
351 
352 /*
353  * @tc.name: DeviceUsageStatisticsMultiTest_BundleActiveGroupMap_001
354  * @tc.desc: BundleActiveGroupMap
355  * @tc.type: FUNC
356  * @tc.require: SR000H0G4F AR000H2US8
357  */
MultiTestDeviceUsageStatsGroupMap(void)358 void MultiTestDeviceUsageStatsGroupMap(void)
359 {
360     int64_t minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
361         .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_FORCED_SET);
362     EXPECT_EQ(minInterval, 0);
363     minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
364         .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_ALIVE);
365     EXPECT_EQ(minInterval, DeviceUsageStatsGroupConst::TWO_HOUR);
366     minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
367         .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_DAILY);
368     EXPECT_EQ(minInterval, g_fourHour);
369     minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
370         .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_FIXED);
371     EXPECT_EQ(minInterval, DeviceUsageStatsGroupConst::TWENTY_FOUR_HOUR);
372     minInterval = DeviceUsageStatsGroupMap::groupIntervalMap_
373         .at(DeviceUsageStatsGroupConst::ACTIVE_GROUP_RARE);
374     EXPECT_EQ(minInterval, DeviceUsageStatsGroupConst::FOURTY_EIGHT_HOUR);
375 }
376 
377 HWTEST_F(DeviceUsageStatisticsMultiTest, DeviceUsageStatisticsMultiTest_BundleActiveGroupMap_001,
378     Function | MediumTest | Level0)
379 {
380     SET_THREAD_NUM(100);
381     GTEST_RUN_TASK(MultiTestDeviceUsageStatsGroupMap);
382 }
383 }  // namespace DeviceUsageStats
384 }  // namespace OHOS
385 
386