1 /*
2  * Copyright (c) 2024 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(ResType::RES_TYPE_SCREEN_STATUS,
50         ResType::ScreenStatus::SCREEN_ON, payload);
51     EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
52     SceneRecognizerMgr::GetInstance().DispatchResource(-1, -1, payload);
53     EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
54     SceneRecognizerMgr::GetInstance().DispatchResource(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
55         ResType::AppInstallStatus::APP_INSTALL_END, payload);
56     EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
57     SceneRecognizerMgr::GetInstance().DispatchResource(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
58         ResType::AppInstallStatus::APP_INSTALL_END, payload);
59     EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
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 Slide test
140  * @tc.desc: test the interface DispatchResource
141  * @tc.type: FUNC
142  * @tc.require: issuesIAJZVI
143  * @tc.author: fengyang
144  */
145 HWTEST_F(SceneRecognizeTest, SlideTest001, Function | MediumTest | Level0)
146 {
147     nlohmann::json payload;
148     payload["clientPid"] = "2000";
149     SceneRecognizerMgr::GetInstance().DispatchResource(ResType::RES_TYPE_SLIDE_RECOGNIZE,
150         ResType::SlideEventStatus::SLIDE_EVENT_DETECTING, payload);
151     EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
152     SceneRecognizerMgr::GetInstance().DispatchResource(ResType::RES_TYPE_SEND_FRAME_EVENT, 0, payload);
153     EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
154     SceneRecognizerMgr::GetInstance().DispatchResource(ResType::RES_TYPE_CLICK_RECOGNIZE,
155         ResType::ClickEventType::TOUCH_EVENT_UP, payload);
156     EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
157     SceneRecognizerMgr::GetInstance().DispatchResource(ResType::RES_TYPE_CLICK_RECOGNIZE,
158         ResType::ClickEventType::TOUCH_EVENT_PULL_UP, payload);
159     EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
160 }
161 
162 /**
163  * @tc.name: SystemUpgradeSceneRecognizer Slide test
164  * @tc.desc: test the interface OnDispatchResource
165  * @tc.type: FUNC
166  * @tc.require: issuesIAJZVI
167  * @tc.author: fengyang
168  */
169 HWTEST_F(SceneRecognizeTest, SystemUpgradeSceneRecognizer_001, Function | MediumTest | Level0)
170 {
171     auto systemUpgradeSceneRecognizer = std::make_shared<SystemUpgradeSceneRecognizer>();
172     systemUpgradeSceneRecognizer->isSystemUpgraded_ = true;
173     int64_t value = 0;
174     nlohmann::json payload;
175     systemUpgradeSceneRecognizer->OnDispatchResource(ResType::RES_TYPE_BOOT_COMPLETED, value, payload);
176     EXPECT_EQ(systemUpgradeSceneRecognizer->isSystemUpgraded_, true);
177 }
178 
179 /**
180  * @tc.name: SceneRecognizer HandleSlideEvent
181  * @tc.desc: test the interface HandleSlideEvent
182  * @tc.type: FUNC
183  * @tc.require: issuesIAJZVI
184  * @tc.author: fengyang
185  */
186 HWTEST_F(SceneRecognizeTest, slideRecognizer_001, Function | MediumTest | Level0)
187 {
188     g_slideState = SlideRecognizeStat::LIST_FLING;
189     auto slideRecognizer = std::make_shared<SlideRecognizer>();
190     int64_t value = ResType::SlideEventStatus::SLIDE_EVENT_ON;
191     nlohmann::json payload;
192     payload["clientPid"] = "2000";
193     slideRecognizer->HandleSlideEvent(value, payload);
194     EXPECT_EQ(g_slideState, SlideRecognizeStat::LIST_FLING);
195 }
196 
197 /**
198  * @tc.name: SceneRecognizer HandleSlideDetecting_001
199  * @tc.desc: test the interface HandleSlideDetecting
200  * @tc.type: FUNC
201  * @tc.require: issuesIAJZVI
202  * @tc.author: fengyang
203  */
204 HWTEST_F(SceneRecognizeTest, HandleSlideDetecting_001, Function | MediumTest | Level0)
205 {
206     auto slideRecognizer = std::make_shared<SlideRecognizer>();
207     nlohmann::json payload;
208     slideRecognizer->HandleSlideDetecting(payload);
209     std::string testPid = "2000";
210     payload["clientPid"] = testPid;
211     slideRecognizer->HandleListFlingStart(payload);
212     g_slideState = SlideRecognizeStat::LIST_FLING;
213     slideRecognizer->HandleSlideDetecting(payload);
214     sleep(1);
215     EXPECT_EQ(slideRecognizer->slidePid_, testPid);
216 }
217 
218 /**
219  * @tc.name: SceneRecognizer HandleListFlingStart_001
220  * @tc.desc: test the interface HandleListFlingStart
221  * @tc.type: FUNC
222  * @tc.require: issuesIAJZVI
223  * @tc.author: fengyang
224  */
225 HWTEST_F(SceneRecognizeTest, HandleListFlingStart_001, Function | MediumTest | Level0)
226 {
227     auto slideRecognizer = std::make_shared<SlideRecognizer>();
228     nlohmann::json payload;
229     std::string testPid = "2000";
230     payload["clientPid"] = testPid;
231     g_slideState = SlideRecognizeStat::LIST_FLING;
232     slideRecognizer->HandleListFlingStart(payload);
233     slideRecognizer->HandleListFlingStart(payload);
234     EXPECT_EQ(g_slideState, SlideRecognizeStat::LIST_FLING);
235 }
236 
237 /**
238  * @tc.name: SceneRecognizer HandleSendFrameEvent_001
239  * @tc.desc: test the interface HandleSendFrameEvent
240  * @tc.type: FUNC
241  * @tc.require: issuesIAJZVI
242  * @tc.author: fengyang
243  */
244 HWTEST_F(SceneRecognizeTest, HandleSendFrameEvent_001, Function | MediumTest | Level0)
245 {
246     auto slideRecognizer = std::make_shared<SlideRecognizer>();
247     nlohmann::json payload;
248     payload["clientPid"] = "2000";
249     g_slideState = SlideRecognizeStat::SLIDE_NORMAL_DETECTING;
250     slideRecognizer->HandleSendFrameEvent(payload);
251     g_slideState = SlideRecognizeStat::LIST_FLING;
252     slideRecognizer->HandleSendFrameEvent(payload);
253     EXPECT_EQ(g_slideState, SlideRecognizeStat::LIST_FLING);
254 }
255 
256 /**
257  * @tc.name: SceneRecognizer HandleClickEvent_001
258  * @tc.desc: test the interface HandleClickEvent
259  * @tc.type: FUNC
260  * @tc.require: issuesIAJZVI
261  * @tc.author: fengyang
262  */
263 HWTEST_F(SceneRecognizeTest, HandleClickEvent_001, Function | MediumTest | Level0)
264 {
265     auto slideRecognizer = std::make_shared<SlideRecognizer>();
266     std::string testPid = "2000";
267     slideRecognizer->slidePid_ = testPid;
268     int64_t value = ResType::SlideEventStatus::SLIDE_EVENT_ON;
269     nlohmann::json payload;
270     g_slideState = SlideRecognizeStat::SLIDE_NORMAL_DETECTING;
271     slideRecognizer->HandleClickEvent(value, payload);
272     g_slideState = SlideRecognizeStat::SLIDE_NORMAL;
273     slideRecognizer->HandleClickEvent(value, payload);
274     payload["clientPid"] = testPid;
275     payload["up_speed"] = std::to_string(slideRecognizer->listFlingTimeOutTime_ + 1);
276     slideRecognizer->HandleClickEvent(value, payload);
277     slideRecognizer->HandleClickEvent(value, payload);
278     EXPECT_EQ(slideRecognizer->slidePid_, testPid);
279 }
280 
281 /**
282  * @tc.name: SceneRecognizer FillRealPid_001
283  * @tc.desc: test the interface FillRealPid
284  * @tc.type: FUNC
285  * @tc.require: issuesIAJZVI
286  * @tc.author: fengyang
287  */
288 HWTEST_F(SceneRecognizeTest, FillRealPid_001, Function | MediumTest | Level0)
289 {
290     auto slideRecognizer = std::make_shared<SlideRecognizer>();
291     nlohmann::json payload;
292     auto result = slideRecognizer->FillRealPid(payload);
293     EXPECT_EQ(payload, result);
294 }
295 
296 /**
297  * @tc.name: SceneRecognizer SetListFlingTimeoutTime_001
298  * @tc.desc: test the interface SetListFlingTimeoutTime
299  * @tc.type: FUNC
300  * @tc.require: issuesIAJZVI
301  * @tc.author: fengyang
302  */
303 HWTEST_F(SceneRecognizeTest, SetListFlingTimeoutTime_001, Function | MediumTest | Level0)
304 {
305     auto slideRecognizer = std::make_shared<SlideRecognizer>();
306     int64_t value = 100;
307     slideRecognizer->SetListFlingTimeoutTime(value);
308     EXPECT_EQ(slideRecognizer->listFlingTimeOutTime_, value);
309 }
310 
311 /**
312  * @tc.name: SceneRecognizer SetListFlingEndTime_001
313  * @tc.desc: test the interface SetListFlingEndTime
314  * @tc.type: FUNC
315  * @tc.require: issuesIAJZVI
316  * @tc.author: fengyang
317  */
318 HWTEST_F(SceneRecognizeTest, SetListFlingEndTime_001, Function | MediumTest | Level0)
319 {
320     auto slideRecognizer = std::make_shared<SlideRecognizer>();
321     int64_t value = 100;
322     slideRecognizer->SetListFlingEndTime(value);
323     EXPECT_EQ(slideRecognizer->listFlingEndTime_, value);
324 }
325 
326 /**
327  * @tc.name: SceneRecognizer SetListFlingSpeedLimit_001
328  * @tc.desc: test the interface SetListFlingSpeedLimit
329  * @tc.type: FUNC
330  * @tc.require: issuesIAJZVI
331  * @tc.author: fengyang
332  */
333 HWTEST_F(SceneRecognizeTest, SetListFlingSpeedLimit_001, Function | MediumTest | Level0)
334 {
335     auto slideRecognizer = std::make_shared<SlideRecognizer>();
336     int64_t value = 100;
337     slideRecognizer->SetListFlingSpeedLimit(value);
338     EXPECT_EQ(slideRecognizer->listFlingSpeedLimit_, value);
339 }
340 
341 /**
342  * @tc.name: SceneRecognizer SetSlideNormalDetectingTime_001
343  * @tc.desc: test the interface SetSlideNormalDetectingTime
344  * @tc.type: FUNC
345  * @tc.require: issuesIAJZVI
346  * @tc.author: fengyang
347  */
348 HWTEST_F(SceneRecognizeTest, SetSlideNormalDetectingTime_001, Function | MediumTest | Level0)
349 {
350     auto slideRecognizer = std::make_shared<SlideRecognizer>();
351     int64_t value = 100;
352     slideRecognizer->SetSlideNormalDetectingTime(value);
353     EXPECT_EQ(slideRecognizer->slideNormalDecectingTime_, value);
354 }
355 
356 } // namespace ResourceSchedule
357 } // namespace OHOS
358