1 /*
2 * Copyright (c) 2024-2025 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 "background_sensitive_task_overlapping_scene_recognizer.h"
17 #include "gtest/gtest.h"
18 #include "res_type.h"
19 #include "scene_recognize_test.h"
20 #include "scene_recognizer_mgr.h"
21 #include "slide_recognizer.h"
22 #include "continuous_app_install_recognizer.h"
23 #include "system_upgrade_scene_recognizer.h"
24
25 using namespace std;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace ResourceSchedule {
30 static uint32_t g_slideState = SlideRecognizeStat::IDLE;
SetUpTestCase()31 void SceneRecognizeTest::SetUpTestCase() {}
32
TearDownTestCase()33 void SceneRecognizeTest::TearDownTestCase() {}
34
SetUp()35 void SceneRecognizeTest::SetUp() {}
36
TearDown()37 void SceneRecognizeTest::TearDown() {}
38
39 /**
40 * @tc.name: SceneRecognizerMgr AppInstallTest test
41 * @tc.desc: test the interface DispatchResource
42 * @tc.type: FUNC
43 * @tc.require: issueI9S1FA
44 * @tc.author:baiheng
45 */
46 HWTEST_F(SceneRecognizeTest, AppInstallTest001, Function | MediumTest | Level0)
47 {
48 nlohmann::json payload;
49 SceneRecognizerMgr::GetInstance().DispatchResource(std::make_shared<ResData>(ResType::RES_TYPE_SCREEN_STATUS,
50 ResType::ScreenStatus::SCREEN_ON, payload));
51 EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
52 SceneRecognizerMgr::GetInstance().DispatchResource(std::make_shared<ResData>(-1,
53 -1, payload));
54 EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
55 SceneRecognizerMgr::GetInstance().DispatchResource(std::make_shared<ResData>(
56 ResType::RES_TYPE_APP_INSTALL_UNINSTALL, ResType::AppInstallStatus::APP_INSTALL_END, payload));
57 EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
58 SceneRecognizerMgr::GetInstance().DispatchResource(std::make_shared<ResData>(
59 ResType::RES_TYPE_APP_INSTALL_UNINSTALL, ResType::AppInstallStatus::APP_INSTALL_END, payload));
60 }
61
62 /**
63 * @tc.name: ContinuousAppInstallRecognizer AppInstallTest test
64 * @tc.desc: test the interface OnDispatchResource
65 * @tc.type: FUNC
66 * @tc.require: issuesIAJZVI
67 * @tc.author: fengyang
68 */
69 HWTEST_F(SceneRecognizeTest, AppInstallTest002, Function | MediumTest | Level0)
70 {
71 auto continuousAppInstallRecognizer = std::make_shared<ContinuousAppInstallRecognizer>();
72 nlohmann::json payload;
73 continuousAppInstallRecognizer->OnDispatchResource(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
74 ResType::AppInstallStatus::APP_INSTALL_END, payload);
75 continuousAppInstallRecognizer->OnDispatchResource(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
76 ResType::AppInstallStatus::APP_INSTALL_END, payload);
77 continuousAppInstallRecognizer->OnDispatchResource(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
78 ResType::AppInstallStatus::APP_INSTALL_START, payload);
79 EXPECT_NE(continuousAppInstallRecognizer, nullptr);
80 }
81
82 /**
83 * @tc.name: SceneRecognizerMgr Bgtask test
84 * @tc.desc: test the interface DispatchResource
85 * @tc.type: FUNC
86 * @tc.require: issueI9S1FA
87 * @tc.author:baiheng
88 */
89 HWTEST_F(SceneRecognizeTest, BgtaskTest001, Function | MediumTest | Level0)
90 {
91 auto bgtaskRecognizer = std::make_shared<BackgroundSensitiveTaskOverlappingSceneRecognizer>();
92 nlohmann::json payload;
93 payload["pid"] = "2000";
94 bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_REPORT_SCENE_BOARD,
95 0, payload);
96 EXPECT_EQ(bgtaskRecognizer->sceneboardPid_, 2000);
97 EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, false);
98 payload["pid"] = "3000";
99 bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_APP_STATE_CHANGE,
100 ResType::ProcessStatus::PROCESS_FOREGROUND, payload);
101 EXPECT_EQ(bgtaskRecognizer->foregroundPid_, 3000);
102 EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, false);
103 payload["pid"] = "4000";
104 payload["typeIds"] = { 2 };
105 bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_CONTINUOUS_TASK,
106 ResType::ContinuousTaskStatus::CONTINUOUS_TASK_START, payload);
107 EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, true);
108 payload["pid"] = "2000";
109 bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_APP_STATE_CHANGE,
110 ResType::ProcessStatus::PROCESS_FOREGROUND, payload);
111 EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, false);
112 payload["pid"] = "3000";
113 bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_APP_STATE_CHANGE,
114 ResType::ProcessStatus::PROCESS_FOREGROUND, payload);
115 EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, true);
116 payload["pid"] = "4000";
117 payload["typeIds"] = { 1 };
118 bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_CONTINUOUS_TASK,
119 ResType::ContinuousTaskStatus::CONTINUOUS_TASK_UPDATE, payload);
120 EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, false);
121 payload["typeIds"] = { 2 };
122 bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_CONTINUOUS_TASK,
123 ResType::ContinuousTaskStatus::CONTINUOUS_TASK_UPDATE, payload);
124 EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, true);
125 bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_CONTINUOUS_TASK,
126 ResType::ContinuousTaskStatus::CONTINUOUS_TASK_END, payload);
127 EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, false);
128 payload["typeIds"] = { 1, 2 };
129 bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_CONTINUOUS_TASK,
130 ResType::ContinuousTaskStatus::CONTINUOUS_TASK_END, payload);
131 bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_CONTINUOUS_TASK,
132 -1, payload);
133 bgtaskRecognizer->HandleForeground(ResType::RES_TYPE_CONTINUOUS_TASK,
134 ResType::ContinuousTaskStatus::CONTINUOUS_TASK_END, payload);
135 SUCCEED();
136 }
137
138 /**
139 * @tc.name: SceneRecognizerMgr Bgtask test
140 * @tc.desc: test the interface IsValidFilteredTypeIds
141 * @tc.type: FUNC
142 * @tc.require: IC9V05
143 * @tc.author:fengshiyi
144 */
145 HWTEST_F(SceneRecognizeTest, BgtaskTest002, Function | MediumTest | Level0)
146 {
147 auto bgtaskRecognizer = std::make_shared<BackgroundSensitiveTaskOverlappingSceneRecognizer>();
148 std::vector<uint32_t> filteredTypeIds;
149 filteredTypeIds.push_back(0);
150 EXPECT_FALSE(bgtaskRecognizer->IsValidFilteredTypeIds(filteredTypeIds));
151 filteredTypeIds.clear();
152 filteredTypeIds.push_back(1);
153 EXPECT_TRUE(bgtaskRecognizer->IsValidFilteredTypeIds(filteredTypeIds));
154 filteredTypeIds.clear();
155 filteredTypeIds.push_back(100);
156 EXPECT_FALSE(bgtaskRecognizer->IsValidFilteredTypeIds(filteredTypeIds));
157 std::vector<uint32_t> typeIds(100, 1);
158 EXPECT_FALSE(bgtaskRecognizer->IsValidFilteredTypeIds(typeIds));
159 }
160
161 /**
162 * @tc.name: SceneRecognizerMgr Bgtask test
163 * @tc.desc: test the interface IsValidPid
164 * @tc.type: FUNC
165 * @tc.require: IC9V05
166 * @tc.author:fengshiyi
167 */
168 HWTEST_F(SceneRecognizeTest, BgtaskTest003, Function | MediumTest | Level0)
169 {
170 auto bgtaskRecognizer = std::make_shared<BackgroundSensitiveTaskOverlappingSceneRecognizer>();
171 pid_t pid = -2;
172 EXPECT_FALSE(bgtaskRecognizer->IsValidPid(pid));
173 pid = INT32_MAX;
174 EXPECT_TRUE(bgtaskRecognizer->IsValidPid(pid));
175 pid = 100;
176 EXPECT_TRUE(bgtaskRecognizer->IsValidPid(pid));
177 }
178
179 /**
180 * @tc.name: SceneRecognizerMgr Slide test
181 * @tc.desc: test the interface DispatchResource
182 * @tc.type: FUNC
183 * @tc.require: issuesIAJZVI
184 * @tc.author: fengyang
185 */
186 HWTEST_F(SceneRecognizeTest, SlideTest001, Function | MediumTest | Level0)
187 {
188 nlohmann::json payload;
189 payload["clientPid"] = "2000";
190 SceneRecognizerMgr::GetInstance().DispatchResource(std::make_shared<ResData>(ResType::RES_TYPE_SLIDE_RECOGNIZE,
191 ResType::SlideEventStatus::SLIDE_EVENT_DETECTING, payload));
192 EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
193 SceneRecognizerMgr::GetInstance().DispatchResource(std::make_shared<ResData>(ResType::RES_TYPE_SEND_FRAME_EVENT,
194 0, payload));
195 EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
196 SceneRecognizerMgr::GetInstance().DispatchResource(std::make_shared<ResData>(ResType::RES_TYPE_CLICK_RECOGNIZE,
197 ResType::ClickEventType::TOUCH_EVENT_UP, payload));
198 EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
199 SceneRecognizerMgr::GetInstance().DispatchResource(std::make_shared<ResData>(ResType::RES_TYPE_CLICK_RECOGNIZE,
200 ResType::ClickEventType::TOUCH_EVENT_PULL_UP, payload));
201 EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
202 }
203
204 /**
205 * @tc.name: SystemUpgradeSceneRecognizer Slide test
206 * @tc.desc: test the interface OnDispatchResource
207 * @tc.type: FUNC
208 * @tc.require: issuesIAJZVI
209 * @tc.author: fengyang
210 */
211 HWTEST_F(SceneRecognizeTest, SystemUpgradeSceneRecognizer_001, Function | MediumTest | Level0)
212 {
213 auto systemUpgradeSceneRecognizer = std::make_shared<SystemUpgradeSceneRecognizer>();
214 int64_t value = 0;
215 nlohmann::json payload;
216 systemUpgradeSceneRecognizer->OnDispatchResource(ResType::RES_TYPE_BOOT_COMPLETED, value, payload);
217 EXPECT_EQ(systemUpgradeSceneRecognizer->isSystemUpgraded_, false);
218 }
219
220 /**
221 * @tc.name: SceneRecognizer HandleSlideEvent
222 * @tc.desc: test the interface HandleSlideEvent
223 * @tc.type: FUNC
224 * @tc.require: issuesIAJZVI
225 * @tc.author: fengyang
226 */
227 HWTEST_F(SceneRecognizeTest, slideRecognizer_001, Function | MediumTest | Level0)
228 {
229 auto slideRecognizer = std::make_shared<SlideRecognizer>();
230 int64_t value = ResType::SlideEventStatus::SLIDE_EVENT_ON;
231 nlohmann::json payload;
232 payload["clientPid"] = "2000";
233 slideRecognizer->HandleSlideEvent(value, payload);
234 EXPECT_EQ(g_slideState, SlideRecognizeStat::IDLE);
235 }
236
237 /**
238 * @tc.name: SceneRecognizer HandleSlideDetecting_001
239 * @tc.desc: test the interface HandleSlideDetecting
240 * @tc.type: FUNC
241 * @tc.require: issuesIAJZVI
242 * @tc.author: fengyang
243 */
244 HWTEST_F(SceneRecognizeTest, HandleSlideDetecting_001, Function | MediumTest | Level0)
245 {
246 auto slideRecognizer = std::make_shared<SlideRecognizer>();
247 nlohmann::json payload;
248 slideRecognizer->HandleSlideDetecting(payload);
249 std::string testPid = "2000";
250 payload["clientPid"] = testPid;
251 slideRecognizer->HandleListFlingStart(payload);
252 g_slideState = SlideRecognizeStat::LIST_FLING;
253 slideRecognizer->HandleSlideDetecting(payload);
254 sleep(1);
255 EXPECT_EQ(slideRecognizer->slidePid_, testPid);
256 }
257
258 /**
259 * @tc.name: SceneRecognizer HandleClickEvent_001
260 * @tc.desc: test the interface HandleClickEvent
261 * @tc.type: FUNC
262 * @tc.require: issuesIAJZVI
263 * @tc.author: fengyang
264 */
265 HWTEST_F(SceneRecognizeTest, HandleClickEvent_001, Function | MediumTest | Level0)
266 {
267 auto slideRecognizer = std::make_shared<SlideRecognizer>();
268 std::string testPid = "2000";
269 slideRecognizer->slidePid_ = testPid;
270 int64_t value = ResType::SlideEventStatus::SLIDE_EVENT_ON;
271 nlohmann::json payload;
272 g_slideState = SlideRecognizeStat::SLIDE_NORMAL_DETECTING;
273 slideRecognizer->HandleClickEvent(value, payload);
274 g_slideState = SlideRecognizeStat::SLIDE_NORMAL;
275 slideRecognizer->HandleClickEvent(value, payload);
276 payload["clientPid"] = testPid;
277 payload["up_speed"] = std::to_string(slideRecognizer->listFlingTimeOutTime_ + 1);
278 value = ResType::ClickEventType::TOUCH_EVENT_DOWN;
279 slideRecognizer->HandleClickEvent(value, payload);
280 slideRecognizer->HandleClickEvent(value, payload);
281 EXPECT_EQ(slideRecognizer->isInTouching_, true);
282 }
283
284 /**
285 * @tc.name: SceneRecognizer FillRealPidAndUid_001
286 * @tc.desc: test the interface FillRealPidAndUid
287 * @tc.type: FUNC
288 * @tc.require: issuesIAJZVI
289 * @tc.author: fengyang
290 */
291 HWTEST_F(SceneRecognizeTest, FillRealPidAndUid_001, Function | MediumTest | Level0)
292 {
293 auto slideRecognizer = std::make_shared<SlideRecognizer>();
294 nlohmann::json payload;
295 auto result = slideRecognizer->FillRealPidAndUid(payload);
296 EXPECT_EQ(result["scrTid"], "");
297 }
298
299 /**
300 * @tc.name: SceneRecognizer SetListFlingTimeoutTime_001
301 * @tc.desc: test the interface SetListFlingTimeoutTime
302 * @tc.type: FUNC
303 * @tc.require: issuesIAJZVI
304 * @tc.author: fengyang
305 */
306 HWTEST_F(SceneRecognizeTest, SetListFlingTimeoutTime_001, Function | MediumTest | Level0)
307 {
308 auto slideRecognizer = std::make_shared<SlideRecognizer>();
309 int64_t value = 100;
310 slideRecognizer->SetListFlingTimeoutTime(value);
311 EXPECT_EQ(slideRecognizer->listFlingTimeOutTime_, value);
312 }
313
314 /**
315 * @tc.name: SceneRecognizer SetListFlingEndTime_001
316 * @tc.desc: test the interface SetListFlingEndTime
317 * @tc.type: FUNC
318 * @tc.require: issuesIAJZVI
319 * @tc.author: fengyang
320 */
321 HWTEST_F(SceneRecognizeTest, SetListFlingEndTime_001, Function | MediumTest | Level0)
322 {
323 auto slideRecognizer = std::make_shared<SlideRecognizer>();
324 int64_t value = 100;
325 slideRecognizer->SetListFlingEndTime(value);
326 EXPECT_EQ(slideRecognizer->listFlingEndTime_, value);
327 }
328
329 /**
330 * @tc.name: SceneRecognizer SetListFlingSpeedLimit_001
331 * @tc.desc: test the interface SetListFlingSpeedLimit
332 * @tc.type: FUNC
333 * @tc.require: issuesIAJZVI
334 * @tc.author: fengyang
335 */
336 HWTEST_F(SceneRecognizeTest, SetListFlingSpeedLimit_001, Function | MediumTest | Level0)
337 {
338 auto slideRecognizer = std::make_shared<SlideRecognizer>();
339 int64_t value = 100;
340 slideRecognizer->SetListFlingSpeedLimit(value);
341 EXPECT_EQ(slideRecognizer->listFlingSpeedLimit_, value);
342 }
343
344 /**
345 * @tc.name: SceneRecognizer DispatchResource_001
346 * @tc.desc: test the interface DispatchResource
347 * @tc.type: FUNC
348 * @tc.require: issuesIC5T7D
349 * @tc.author: baiheng
350 */
351 HWTEST_F(SceneRecognizeTest, DispatchResource_001, Function | MediumTest | Level0)
352 {
353 SceneRecognizerMgr::GetInstance().DispatchResource(nullptr);
354 SceneRecognizerMgr::GetInstance().ffrtQueue_ = nullptr;
355 nlohmann::json payload;
356 auto resData = make_shared<ResData>(0, 0, payload);
357 SceneRecognizerMgr::GetInstance().DispatchResource(resData);
358 EXPECT_EQ(SceneRecognizerMgr::GetInstance().ffrtQueue_, nullptr);
359 }
360 } // namespace ResourceSchedule
361 } // namespace OHOS
362