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  */
HWTEST_F(SceneRecognizeTest, AppInstallTest001, Function | MediumTest | Level0)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     SUCCEED();
52     SceneRecognizerMgr::GetInstance().DispatchResource(-1, -1, payload);
53     SUCCEED();
54     SceneRecognizerMgr::GetInstance().DispatchResource(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
55         ResType::AppInstallStatus::APP_INSTALL_END, payload);
56     SUCCEED();
57     SceneRecognizerMgr::GetInstance().DispatchResource(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
58         ResType::AppInstallStatus::APP_INSTALL_END, payload);
59 }
60 
61 /**
62  * @tc.name: ContinuousAppInstallRecognizer AppInstallTest test
63  * @tc.desc: test the interface OnDispatchResource
64  * @tc.type: FUNC
65  * @tc.require: issuesIAJZVI
66  * @tc.author: fengyang
67  */
HWTEST_F(SceneRecognizeTest, AppInstallTest002, Function | MediumTest | Level0)68 HWTEST_F(SceneRecognizeTest, AppInstallTest002, Function | MediumTest | Level0)
69 {
70     auto continuousAppInstallRecognizer = std::make_shared<ContinuousAppInstallRecognizer>();
71     nlohmann::json payload;
72     continuousAppInstallRecognizer->OnDispatchResource(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
73         ResType::AppInstallStatus::APP_INSTALL_END, payload);
74     continuousAppInstallRecognizer->OnDispatchResource(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
75         ResType::AppInstallStatus::APP_INSTALL_END, payload);
76     continuousAppInstallRecognizer->OnDispatchResource(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
77         ResType::AppInstallStatus::APP_INSTALL_START, payload);
78     SUCCEED();
79 }
80 
81 /**
82  * @tc.name: SceneRecognizerMgr Bgtask test
83  * @tc.desc: test the interface DispatchResource
84  * @tc.type: FUNC
85  * @tc.require: issueI9S1FA
86  * @tc.author:baiheng
87  */
HWTEST_F(SceneRecognizeTest, BgtaskTest001, Function | MediumTest | Level0)88 HWTEST_F(SceneRecognizeTest, BgtaskTest001, Function | MediumTest | Level0)
89 {
90     auto bgtaskRecognizer = std::make_shared<BackgroundSensitiveTaskOverlappingSceneRecognizer>();
91     nlohmann::json payload;
92     payload["pid"] = "2000";
93     bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_REPORT_SCENE_BOARD,
94         0, payload);
95     EXPECT_EQ(bgtaskRecognizer->sceneboardPid_, 2000);
96     EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, false);
97     payload["pid"] = "3000";
98     bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_APP_STATE_CHANGE,
99         ResType::ProcessStatus::PROCESS_FOREGROUND, payload);
100     EXPECT_EQ(bgtaskRecognizer->foregroundPid_, 3000);
101     EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, false);
102     payload["pid"] = "4000";
103     payload["typeIds"] = { 2 };
104     bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_CONTINUOUS_TASK,
105         ResType::ContinuousTaskStatus::CONTINUOUS_TASK_START, payload);
106     EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, true);
107     payload["pid"] = "2000";
108     bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_APP_STATE_CHANGE,
109         ResType::ProcessStatus::PROCESS_FOREGROUND, payload);
110     EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, false);
111     payload["pid"] = "3000";
112     bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_APP_STATE_CHANGE,
113         ResType::ProcessStatus::PROCESS_FOREGROUND, payload);
114     EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, true);
115     payload["pid"] = "4000";
116     payload["typeIds"] = { 1 };
117     bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_CONTINUOUS_TASK,
118         ResType::ContinuousTaskStatus::CONTINUOUS_TASK_UPDATE, payload);
119     EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, false);
120     payload["typeIds"] = { 2 };
121     bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_CONTINUOUS_TASK,
122         ResType::ContinuousTaskStatus::CONTINUOUS_TASK_UPDATE, payload);
123     EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, true);
124     bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_CONTINUOUS_TASK,
125         ResType::ContinuousTaskStatus::CONTINUOUS_TASK_END, payload);
126     EXPECT_EQ(bgtaskRecognizer->isInBackgroundPerceivableScene_, false);
127     payload["typeIds"] = { 1, 2 };
128     bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_CONTINUOUS_TASK,
129         ResType::ContinuousTaskStatus::CONTINUOUS_TASK_END, payload);
130     bgtaskRecognizer->OnDispatchResource(ResType::RES_TYPE_CONTINUOUS_TASK,
131         -1, payload);
132     bgtaskRecognizer->HandleForeground(ResType::RES_TYPE_CONTINUOUS_TASK,
133         ResType::ContinuousTaskStatus::CONTINUOUS_TASK_END, payload);
134     SUCCEED();
135 }
136 
137 /**
138  * @tc.name: SceneRecognizerMgr Slide test
139  * @tc.desc: test the interface DispatchResource
140  * @tc.type: FUNC
141  * @tc.require: issuesIAJZVI
142  * @tc.author: fengyang
143  */
HWTEST_F(SceneRecognizeTest, SlideTest001, Function | MediumTest | Level0)144 HWTEST_F(SceneRecognizeTest, SlideTest001, Function | MediumTest | Level0)
145 {
146     nlohmann::json payload;
147     payload["clientPid"] = "2000";
148     SceneRecognizerMgr::GetInstance().DispatchResource(ResType::RES_TYPE_SLIDE_RECOGNIZE,
149         ResType::SlideEventStatus::SLIDE_EVENT_DETECTING, payload);
150     SUCCEED();
151     SceneRecognizerMgr::GetInstance().DispatchResource(ResType::RES_TYPE_SEND_FRAME_EVENT, 0, payload);
152     SUCCEED();
153     SceneRecognizerMgr::GetInstance().DispatchResource(ResType::RES_TYPE_CLICK_RECOGNIZE,
154         ResType::ClickEventType::TOUCH_EVENT_UP, payload);
155     SUCCEED();
156     SceneRecognizerMgr::GetInstance().DispatchResource(ResType::RES_TYPE_CLICK_RECOGNIZE,
157         ResType::ClickEventType::TOUCH_EVENT_PULL_UP, payload);
158     SUCCEED();
159 }
160 
161 /**
162  * @tc.name: SystemUpgradeSceneRecognizer Slide test
163  * @tc.desc: test the interface OnDispatchResource
164  * @tc.type: FUNC
165  * @tc.require: issuesIAJZVI
166  * @tc.author: fengyang
167  */
HWTEST_F(SceneRecognizeTest, SystemUpgradeSceneRecognizer_001, Function | MediumTest | Level0)168 HWTEST_F(SceneRecognizeTest, SystemUpgradeSceneRecognizer_001, Function | MediumTest | Level0)
169 {
170     auto systemUpgradeSceneRecognizer = std::make_shared<SystemUpgradeSceneRecognizer>();
171     systemUpgradeSceneRecognizer->isSystemUpgraded_ = true;
172     int64_t value = 0;
173     nlohmann::json payload;
174     systemUpgradeSceneRecognizer->OnDispatchResource(ResType::RES_TYPE_BOOT_COMPLETED, value, payload);
175     SUCCEED();
176 }
177 
178 /**
179  * @tc.name: SceneRecognizer HandleSlideEvent
180  * @tc.desc: test the interface HandleSlideEvent
181  * @tc.type: FUNC
182  * @tc.require: issuesIAJZVI
183  * @tc.author: fengyang
184  */
HWTEST_F(SceneRecognizeTest, slideRecognizer_001, Function | MediumTest | Level0)185 HWTEST_F(SceneRecognizeTest, slideRecognizer_001, Function | MediumTest | Level0)
186 {
187     auto slideRecognizer = std::make_shared<SlideRecognizer>();
188     int64_t value = ResType::SlideEventStatus::SLIDE_EVENT_ON;
189     nlohmann::json payload;
190     payload["clientPid"] = "2000";
191     slideRecognizer->HandleSlideEvent(value, payload);
192     EXPECT_EQ(g_slideState, SlideRecognizeStat::IDLE);
193 }
194 
195 /**
196  * @tc.name: SceneRecognizer HandleSlideDetecting_001
197  * @tc.desc: test the interface HandleSlideDetecting
198  * @tc.type: FUNC
199  * @tc.require: issuesIAJZVI
200  * @tc.author: fengyang
201  */
HWTEST_F(SceneRecognizeTest, HandleSlideDetecting_001, Function | MediumTest | Level0)202 HWTEST_F(SceneRecognizeTest, HandleSlideDetecting_001, Function | MediumTest | Level0)
203 {
204     auto slideRecognizer = std::make_shared<SlideRecognizer>();
205     nlohmann::json payload;
206     slideRecognizer->HandleSlideDetecting(payload);
207     payload["clientPid"] = "2000";
208     slideRecognizer->HandleListFlingStart(payload);
209     g_slideState = SlideRecognizeStat::LIST_FLING;
210     slideRecognizer->HandleSlideDetecting(payload);
211     SUCCEED();
212 }
213 
214 /**
215  * @tc.name: SceneRecognizer HandleListFlingStart_001
216  * @tc.desc: test the interface HandleListFlingStart
217  * @tc.type: FUNC
218  * @tc.require: issuesIAJZVI
219  * @tc.author: fengyang
220  */
HWTEST_F(SceneRecognizeTest, HandleListFlingStart_001, Function | MediumTest | Level0)221 HWTEST_F(SceneRecognizeTest, HandleListFlingStart_001, Function | MediumTest | Level0)
222 {
223     auto slideRecognizer = std::make_shared<SlideRecognizer>();
224     nlohmann::json payload;
225     payload["clientPid"] = "2000";
226     g_slideState = SlideRecognizeStat::LIST_FLING;
227     slideRecognizer->HandleListFlingStart(payload);
228     slideRecognizer->HandleListFlingStart(payload);
229     SUCCEED();
230 }
231 
232 /**
233  * @tc.name: SceneRecognizer HandleSendFrameEvent_001
234  * @tc.desc: test the interface HandleSendFrameEvent
235  * @tc.type: FUNC
236  * @tc.require: issuesIAJZVI
237  * @tc.author: fengyang
238  */
HWTEST_F(SceneRecognizeTest, HandleSendFrameEvent_001, Function | MediumTest | Level0)239 HWTEST_F(SceneRecognizeTest, HandleSendFrameEvent_001, Function | MediumTest | Level0)
240 {
241     auto slideRecognizer = std::make_shared<SlideRecognizer>();
242     nlohmann::json payload;
243     payload["clientPid"] = "2000";
244     g_slideState = SlideRecognizeStat::SLIDE_NORMAL_DETECTING;
245     slideRecognizer->HandleSendFrameEvent(payload);
246     g_slideState = SlideRecognizeStat::LIST_FLING;
247     slideRecognizer->HandleSendFrameEvent(payload);
248     SUCCEED();
249 }
250 
251 /**
252  * @tc.name: SceneRecognizer HandleClickEvent_001
253  * @tc.desc: test the interface HandleClickEvent
254  * @tc.type: FUNC
255  * @tc.require: issuesIAJZVI
256  * @tc.author: fengyang
257  */
HWTEST_F(SceneRecognizeTest, HandleClickEvent_001, Function | MediumTest | Level0)258 HWTEST_F(SceneRecognizeTest, HandleClickEvent_001, Function | MediumTest | Level0)
259 {
260     auto slideRecognizer = std::make_shared<SlideRecognizer>();
261     int64_t value = ResType::SlideEventStatus::SLIDE_EVENT_ON;
262     nlohmann::json payload;
263     g_slideState = SlideRecognizeStat::SLIDE_NORMAL_DETECTING;
264     slideRecognizer->HandleClickEvent(value, payload);
265     g_slideState = SlideRecognizeStat::SLIDE_NORMAL;
266     slideRecognizer->HandleClickEvent(value, payload);
267     payload["clientPid"] = "2000";
268     payload["up_speed"] = std::to_string(slideRecognizer->listFlingTimeOutTime_ + 1);
269     slideRecognizer->HandleClickEvent(value, payload);
270     slideRecognizer->HandleClickEvent(value, payload);
271     SUCCEED();
272 }
273 
274 /**
275  * @tc.name: SceneRecognizer FillRealPid_001
276  * @tc.desc: test the interface FillRealPid
277  * @tc.type: FUNC
278  * @tc.require: issuesIAJZVI
279  * @tc.author: fengyang
280  */
HWTEST_F(SceneRecognizeTest, FillRealPid_001, Function | MediumTest | Level0)281 HWTEST_F(SceneRecognizeTest, FillRealPid_001, Function | MediumTest | Level0)
282 {
283     auto slideRecognizer = std::make_shared<SlideRecognizer>();
284     nlohmann::json payload;
285     auto result = slideRecognizer->FillRealPid(payload);
286     EXPECT_EQ(payload, result);
287 }
288 
289 /**
290  * @tc.name: SceneRecognizer SetListFlingTimeoutTime_001
291  * @tc.desc: test the interface SetListFlingTimeoutTime
292  * @tc.type: FUNC
293  * @tc.require: issuesIAJZVI
294  * @tc.author: fengyang
295  */
HWTEST_F(SceneRecognizeTest, SetListFlingTimeoutTime_001, Function | MediumTest | Level0)296 HWTEST_F(SceneRecognizeTest, SetListFlingTimeoutTime_001, Function | MediumTest | Level0)
297 {
298     auto slideRecognizer = std::make_shared<SlideRecognizer>();
299     int64_t value = 100;
300     slideRecognizer->SetListFlingTimeoutTime(value);
301     EXPECT_EQ(slideRecognizer->listFlingTimeOutTime_, value);
302 }
303 
304 /**
305  * @tc.name: SceneRecognizer SetListFlingEndTime_001
306  * @tc.desc: test the interface SetListFlingEndTime
307  * @tc.type: FUNC
308  * @tc.require: issuesIAJZVI
309  * @tc.author: fengyang
310  */
HWTEST_F(SceneRecognizeTest, SetListFlingEndTime_001, Function | MediumTest | Level0)311 HWTEST_F(SceneRecognizeTest, SetListFlingEndTime_001, Function | MediumTest | Level0)
312 {
313     auto slideRecognizer = std::make_shared<SlideRecognizer>();
314     int64_t value = 100;
315     slideRecognizer->SetListFlingEndTime(value);
316     EXPECT_EQ(slideRecognizer->listFlingEndTime_, value);
317 }
318 
319 /**
320  * @tc.name: SceneRecognizer SetListFlingSpeedLimit_001
321  * @tc.desc: test the interface SetListFlingSpeedLimit
322  * @tc.type: FUNC
323  * @tc.require: issuesIAJZVI
324  * @tc.author: fengyang
325  */
HWTEST_F(SceneRecognizeTest, SetListFlingSpeedLimit_001, Function | MediumTest | Level0)326 HWTEST_F(SceneRecognizeTest, SetListFlingSpeedLimit_001, Function | MediumTest | Level0)
327 {
328     auto slideRecognizer = std::make_shared<SlideRecognizer>();
329     int64_t value = 100;
330     slideRecognizer->SetListFlingSpeedLimit(value);
331     EXPECT_EQ(slideRecognizer->listFlingSpeedLimit_, value);
332 }
333 
334 /**
335  * @tc.name: SceneRecognizer SetSlideNormalDetectingTime_001
336  * @tc.desc: test the interface SetSlideNormalDetectingTime
337  * @tc.type: FUNC
338  * @tc.require: issuesIAJZVI
339  * @tc.author: fengyang
340  */
HWTEST_F(SceneRecognizeTest, SetSlideNormalDetectingTime_001, Function | MediumTest | Level0)341 HWTEST_F(SceneRecognizeTest, SetSlideNormalDetectingTime_001, Function | MediumTest | Level0)
342 {
343     auto slideRecognizer = std::make_shared<SlideRecognizer>();
344     int64_t value = 100;
345     slideRecognizer->SetSlideNormalDetectingTime(value);
346     EXPECT_EQ(slideRecognizer->slideNormalDecectingTime_, value);
347 }
348 
349 } // namespace ResourceSchedule
350 } // namespace OHOS
351