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 }
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 */
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 EXPECT_NE(continuousAppInstallRecognizer, nullptr);
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 */
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 */
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 EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
151 SceneRecognizerMgr::GetInstance().DispatchResource(ResType::RES_TYPE_SEND_FRAME_EVENT, 0, payload);
152 EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
153 SceneRecognizerMgr::GetInstance().DispatchResource(ResType::RES_TYPE_CLICK_RECOGNIZE,
154 ResType::ClickEventType::TOUCH_EVENT_UP, payload);
155 EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
156 SceneRecognizerMgr::GetInstance().DispatchResource(ResType::RES_TYPE_CLICK_RECOGNIZE,
157 ResType::ClickEventType::TOUCH_EVENT_PULL_UP, payload);
158 EXPECT_NE(SceneRecognizerMgr::GetInstance().sceneRecognizers_.size(), 0);
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 */
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 EXPECT_EQ(systemUpgradeSceneRecognizer->isSystemUpgraded_, true);
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 */
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 */
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 std::string testPid = "2000";
208 payload["clientPid"] = testPid;
209 slideRecognizer->HandleListFlingStart(payload);
210 g_slideState = SlideRecognizeStat::LIST_FLING;
211 slideRecognizer->HandleSlideDetecting(payload);
212 sleep(1);
213 EXPECT_EQ(slideRecognizer->slidePid_, testPid);
214 }
215
216 /**
217 * @tc.name: SceneRecognizer HandleClickEvent_001
218 * @tc.desc: test the interface HandleClickEvent
219 * @tc.type: FUNC
220 * @tc.require: issuesIAJZVI
221 * @tc.author: fengyang
222 */
223 HWTEST_F(SceneRecognizeTest, HandleClickEvent_001, Function | MediumTest | Level0)
224 {
225 auto slideRecognizer = std::make_shared<SlideRecognizer>();
226 std::string testPid = "2000";
227 slideRecognizer->slidePid_ = testPid;
228 int64_t value = ResType::SlideEventStatus::SLIDE_EVENT_ON;
229 nlohmann::json payload;
230 g_slideState = SlideRecognizeStat::SLIDE_NORMAL_DETECTING;
231 slideRecognizer->HandleClickEvent(value, payload);
232 g_slideState = SlideRecognizeStat::SLIDE_NORMAL;
233 slideRecognizer->HandleClickEvent(value, payload);
234 payload["clientPid"] = testPid;
235 payload["up_speed"] = std::to_string(slideRecognizer->listFlingTimeOutTime_ + 1);
236 slideRecognizer->HandleClickEvent(value, payload);
237 slideRecognizer->HandleClickEvent(value, payload);
238 EXPECT_EQ(slideRecognizer->slidePid_, testPid);
239 }
240
241 /**
242 * @tc.name: SceneRecognizer FillRealPidAndUid_001
243 * @tc.desc: test the interface FillRealPidAndUid
244 * @tc.type: FUNC
245 * @tc.require: issuesIAJZVI
246 * @tc.author: fengyang
247 */
248 HWTEST_F(SceneRecognizeTest, FillRealPidAndUid_001, Function | MediumTest | Level0)
249 {
250 auto slideRecognizer = std::make_shared<SlideRecognizer>();
251 nlohmann::json payload;
252 auto result = slideRecognizer->FillRealPidAndUid(payload);
253 EXPECT_EQ(payload, result);
254 }
255
256 /**
257 * @tc.name: SceneRecognizer SetListFlingTimeoutTime_001
258 * @tc.desc: test the interface SetListFlingTimeoutTime
259 * @tc.type: FUNC
260 * @tc.require: issuesIAJZVI
261 * @tc.author: fengyang
262 */
263 HWTEST_F(SceneRecognizeTest, SetListFlingTimeoutTime_001, Function | MediumTest | Level0)
264 {
265 auto slideRecognizer = std::make_shared<SlideRecognizer>();
266 int64_t value = 100;
267 slideRecognizer->SetListFlingTimeoutTime(value);
268 EXPECT_EQ(slideRecognizer->listFlingTimeOutTime_, value);
269 }
270
271 /**
272 * @tc.name: SceneRecognizer SetListFlingEndTime_001
273 * @tc.desc: test the interface SetListFlingEndTime
274 * @tc.type: FUNC
275 * @tc.require: issuesIAJZVI
276 * @tc.author: fengyang
277 */
278 HWTEST_F(SceneRecognizeTest, SetListFlingEndTime_001, Function | MediumTest | Level0)
279 {
280 auto slideRecognizer = std::make_shared<SlideRecognizer>();
281 int64_t value = 100;
282 slideRecognizer->SetListFlingEndTime(value);
283 EXPECT_EQ(slideRecognizer->listFlingEndTime_, value);
284 }
285
286 /**
287 * @tc.name: SceneRecognizer SetListFlingSpeedLimit_001
288 * @tc.desc: test the interface SetListFlingSpeedLimit
289 * @tc.type: FUNC
290 * @tc.require: issuesIAJZVI
291 * @tc.author: fengyang
292 */
293 HWTEST_F(SceneRecognizeTest, SetListFlingSpeedLimit_001, Function | MediumTest | Level0)
294 {
295 auto slideRecognizer = std::make_shared<SlideRecognizer>();
296 int64_t value = 100;
297 slideRecognizer->SetListFlingSpeedLimit(value);
298 EXPECT_EQ(slideRecognizer->listFlingSpeedLimit_, value);
299 }
300
301 /**
302 * @tc.name: SceneRecognizer SetSlideNormalDetectingTime_001
303 * @tc.desc: test the interface SetSlideNormalDetectingTime
304 * @tc.type: FUNC
305 * @tc.require: issuesIAJZVI
306 * @tc.author: fengyang
307 */
308 HWTEST_F(SceneRecognizeTest, SetSlideNormalDetectingTime_001, Function | MediumTest | Level0)
309 {
310 auto slideRecognizer = std::make_shared<SlideRecognizer>();
311 int64_t value = 100;
312 slideRecognizer->SetSlideNormalDetectingTime(value);
313 EXPECT_EQ(slideRecognizer->slideNormalDecectingTime_, value);
314 }
315
316 } // namespace ResourceSchedule
317 } // namespace OHOS
318