1 /*
2 * Copyright (c) 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 <cstdio>
17 #include <fstream>
18 #include <gmock/gmock.h>
19
20 #include "event_filter_handler.h"
21 #include "fingersense_wrapper.h"
22 #include "i_pointer_drawing_manager.h"
23 #include "input_device_manager.h"
24 #include "input_event_handler.h"
25 #include "input_manager_util.h"
26 #include "input_windows_manager.h"
27 #include "libinput_interface.h"
28 #include "mmi_log.h"
29 #include "mock_input_windows_manager.h"
30 #include "pixel_map.h"
31 #include "pointer_drawing_manager.h"
32 #include "proto.h"
33 #include "scene_board_judgement.h"
34 #include "struct_multimodal.h"
35 #include "uds_server.h"
36 #include "util.h"
37 #include "window_info.h"
38
39 #undef MMI_LOG_TAG
40 #define MMI_LOG_TAG "InputWindowsManagerOneTest"
41
42 using namespace OHOS::MMI;
43 using namespace OHOS::Media;
44 using namespace testing;
45 using namespace testing::ext;
46
47 namespace OHOS {
48 MockInputWindowsManager *g_inputWindowManagerInterface;
49
MockInputWindowsManager()50 MockInputWindowsManager::MockInputWindowsManager()
51 {
52 g_inputWindowManagerInterface = this;
53 }
54
~MockInputWindowsManager()55 MockInputWindowsManager::~MockInputWindowsManager()
56 {
57 g_inputWindowManagerInterface = nullptr;
58 }
59
GetInputWindowsManagerInterface()60 static InputWindowsManagerInterface *GetInputWindowsManagerInterface()
61 {
62 return g_inputWindowManagerInterface;
63 }
64
GetWindowAndDisplayInfo(int32_t windowId,int32_t displayId)65 std::optional<WindowInfo> InputWindowsManager::GetWindowAndDisplayInfo(int32_t windowId, int32_t displayId)
66 {
67 if (GetInputWindowsManagerInterface() != nullptr) {
68 return GetInputWindowsManagerInterface()->GetWindowAndDisplayInfo(windowId, displayId);
69 }
70 return std::nullopt;
71 }
72
PrintDisplayInfo(const OLD::DisplayInfo displayInfo)73 void InputWindowsManager::PrintDisplayInfo(const OLD::DisplayInfo displayInfo) {}
74
IsSceneBoardEnabled()75 bool Rosen::SceneBoardJudgement::IsSceneBoardEnabled()
76 {
77 if (GetInputWindowsManagerInterface() != nullptr) {
78 return GetInputWindowsManagerInterface()->IsSceneBoardEnabled();
79 }
80 return false;
81 }
82
83 namespace MMI {
84 namespace {
85 constexpr int32_t CAST_INPUT_DEVICEID {0xAAAAAAFF};
86 constexpr int32_t CAST_SCREEN_DEVICEID {0xAAAAAAFE};
87 constexpr int32_t DEFAULT_POSITION { 0 };
88 } // namespace
89
ReadJsonFile(const std::string & filePath)90 std::string ReadJsonFile(const std::string &filePath)
91 {
92 if (g_inputWindowManagerInterface != nullptr) {
93 return GetInputWindowsManagerInterface()->ReadJsonFile(filePath);
94 }
95 return "";
96 }
97
98 class InputWindowsManagerOneTest : public testing::Test {
99 public:
SetUpTestCase(void)100 static void SetUpTestCase(void) {};
TearDownTestCase(void)101 static void TearDownTestCase(void) {};
SetUp(void)102 void SetUp(void) {};
SetDown(void)103 void SetDown(void) {};
104 };
105
106 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
107 /* *
108 * @tc.name: InputWindowsManagerOneTest_ScreenRotateAdjustDisplayXY_001
109 * @tc.desc: Test the funcation ScreenRotateAdjustDisplayXY
110 * @tc.type: FUNC
111 * @tc.require:
112 */
113 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ScreenRotateAdjustDisplayXY_001, TestSize.Level1)
114 {
115 CALL_TEST_DEBUG;
116 OLD::DisplayInfo info;
117 info.direction = DIRECTION90;
118 info.validWidth = 0;
119 info.validHeight = 0;
120 PhysicalCoordinate coord;
121 coord.x = 1;
122 coord.y = 0;
123 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
124 CursorPosition cursorPosRef;
125 auto it = inputWindowsManager->cursorPosMap_.find(DEFAULT_GROUP_ID);
126 if (it != inputWindowsManager->cursorPosMap_.end()) {
127 cursorPosRef = it->second;
128 }
129 cursorPosRef.direction = Direction::DIRECTION0;
130 NiceMock<MockInputWindowsManager> mockInputWindowsManager;
131 EXPECT_CALL(mockInputWindowsManager, IsSceneBoardEnabled)
132 .WillOnce(Return(false))
133 .WillOnce(Return(false))
134 .WillOnce(Return(true));
135 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ScreenRotateAdjustDisplayXY(info, coord));
136
137 coord.x = 1;
138 coord.y = 0;
139 info.direction = DIRECTION0;
140 cursorPosRef.direction = Direction::DIRECTION180;
141 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ScreenRotateAdjustDisplayXY(info, coord));
142
143 coord.x = 1;
144 coord.y = 0;
145 info.direction = DIRECTION0;
146 cursorPosRef.direction = Direction::DIRECTION90;
147 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ScreenRotateAdjustDisplayXY(info, coord));
148 }
149
150 /* *
151 * @tc.name: InputWindowsManagerOneTest_RotateScreen_001
152 * @tc.desc: Test the funcation RotateScreen
153 * @tc.type: FUNC
154 * @tc.require:
155 */
156 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_RotateScreen_001, TestSize.Level1)
157 {
158 CALL_TEST_DEBUG;
159 OLD::DisplayInfo info;
160 info.direction = DIRECTION0;
161 info.displayDirection = Direction::DIRECTION0;
162 info.validWidth = 0;
163 info.validHeight = 0;
164 PhysicalCoordinate coord;
165 coord.x = 1;
166 coord.y = 0;
167 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
168 CursorPosition cursorPosRef;
169 auto it = inputWindowsManager->cursorPosMap_.find(DEFAULT_GROUP_ID);
170 if (it != inputWindowsManager->cursorPosMap_.end()) {
171 cursorPosRef = it->second;
172 }
173 cursorPosRef.direction = Direction::DIRECTION90;
174 cursorPosRef.displayDirection = Direction::DIRECTION90;
175 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
176 ASSERT_NE(pointerEvent, nullptr);
177 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
178 pointerEvent->SetPointerAction(1);
179 inputWindowsManager->UpdateTargetPointer(pointerEvent);
180 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->RotateScreen(info, coord));
181
182 coord.x = 0;
183 coord.y = 1;
184 cursorPosRef.direction = Direction::DIRECTION270;
185 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->RotateScreen(info, coord));
186
187 coord.x = 0;
188 coord.y = 1;
189 cursorPosRef.direction = Direction::DIRECTION180;
190 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->RotateScreen(info, coord));
191 }
192
193 /* *
194 * @tc.name: InputWindowsManagerOneTest_RotateScreen_002
195 * @tc.desc: Test the funcation RotateScreen
196 * @tc.type: FUNC
197 * @tc.require:
198 */
199 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_RotateScreen_002, TestSize.Level1)
200 {
201 CALL_TEST_DEBUG;
202 OLD::DisplayInfo info;
203 info.direction = DIRECTION0;
204 info.displayDirection = Direction::DIRECTION0;
205 info.validWidth = 0;
206 info.validHeight = 0;
207 PhysicalCoordinate coord;
208 coord.x = 1;
209 coord.y = 0;
210 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
211 CursorPosition cursorPosRef;
212 auto it = inputWindowsManager->cursorPosMap_.find(DEFAULT_GROUP_ID);
213 if (it != inputWindowsManager->cursorPosMap_.end()) {
214 cursorPosRef = it->second;
215 }
216 cursorPosRef.direction = Direction::DIRECTION90;
217 cursorPosRef.displayDirection = Direction::DIRECTION90;
218 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
219 ASSERT_NE(pointerEvent, nullptr);
220 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_UNKNOWN);
221 pointerEvent->SetPointerAction(1);
222 inputWindowsManager->UpdateTargetPointer(pointerEvent);
223 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->RotateScreen(info, coord));
224 }
225
226 /* *
227 * @tc.name: InputWindowsManagerOneTest_TriggerTouchUpOnInvalidAreaEntry_001
228 * @tc.desc: Test the funcation TriggerTouchUpOnInvalidAreaEntry
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_TriggerTouchUpOnInvalidAreaEntry_001, TestSize.Level1)
233 {
234 CALL_TEST_DEBUG;
235 int32_t pointerId = 0;
236 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
237 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
238 ASSERT_NE(pointerEvent, nullptr);
239 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_UNKNOWN);
240 EXPECT_NE(pointerEvent, nullptr);
241 PointerEvent::PointerItem item;
242 item.SetPointerId(pointerId);
243 item.canceled_ = false;
244 item.pressed_ = true;
245 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
246 pointerEvent->pointers_.push_back(item);
247 pointerEvent->SetPointerId(pointerId);
248 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
249 inputWindowsManager->lastPointerEventforGesture_ = pointerEvent;
250 inputWindowsManager->extraData_.appended = true;
251 inputWindowsManager->extraData_.sourceType = PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
252 inputWindowsManager->extraData_.pointerId = pointerId;
253 WindowInfo windowInfo;
254 windowInfo.agentWindowId = 1;
255 NiceMock<MockInputWindowsManager> mockInputWindowsManager;
256 EXPECT_CALL(mockInputWindowsManager, GetWindowAndDisplayInfo)
257 .WillRepeatedly(Return(std::make_optional(windowInfo)));
258 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->TriggerTouchUpOnInvalidAreaEntry(pointerId));
259 }
260
261 /* *
262 * @tc.name: InputWindowsManagerOneTest_TriggerTouchUpOnInvalidAreaEntry_002
263 * @tc.desc: Test the funcation TriggerTouchUpOnInvalidAreaEntry
264 * @tc.type: FUNC
265 * @tc.require:
266 */
267 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_TriggerTouchUpOnInvalidAreaEntry_002, TestSize.Level1)
268 {
269 CALL_TEST_DEBUG;
270 int32_t pointerId = 0;
271 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
272 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
273 ASSERT_NE(pointerEvent, nullptr);
274 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_UNKNOWN);
275 EXPECT_NE(pointerEvent, nullptr);
276 PointerEvent::PointerItem item;
277 item.SetPointerId(pointerId);
278 item.canceled_ = false;
279 item.pressed_ = true;
280 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
281 pointerEvent->pointers_.push_back(item);
282 pointerEvent->SetPointerId(pointerId);
283 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
284 inputWindowsManager->lastPointerEventforGesture_ = pointerEvent;
285 inputWindowsManager->extraData_.appended = true;
286 inputWindowsManager->extraData_.sourceType = PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
287 inputWindowsManager->extraData_.pointerId = pointerId + 1;
288 WindowInfo windowInfo;
289 windowInfo.agentWindowId = 1;
290 NiceMock<MockInputWindowsManager> mockInputWindowsManager;
291 EXPECT_CALL(mockInputWindowsManager, GetWindowAndDisplayInfo).WillRepeatedly(Return(std::nullopt));
292 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->TriggerTouchUpOnInvalidAreaEntry(pointerId));
293 }
294
295 /* *
296 * @tc.name: InputWindowsManagerOneTest_TriggerTouchUpOnInvalidAreaEntry_003
297 * @tc.desc: Test the funcation TriggerTouchUpOnInvalidAreaEntry
298 * @tc.type: FUNC
299 * @tc.require:
300 */
301 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_TriggerTouchUpOnInvalidAreaEntry_003, TestSize.Level1)
302 {
303 CALL_TEST_DEBUG;
304 int32_t pointerId = 0;
305 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
306 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
307 ASSERT_NE(pointerEvent, nullptr);
308 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_UNKNOWN);
309 EXPECT_NE(pointerEvent, nullptr);
310 PointerEvent::PointerItem item;
311 item.SetPointerId(pointerId);
312 item.canceled_ = false;
313 item.pressed_ = false;
314 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
315 pointerEvent->pointers_.push_back(item);
316 pointerEvent->SetPointerId(pointerId);
317 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
318 inputWindowsManager->lastPointerEventforGesture_ = pointerEvent;
319 inputWindowsManager->extraData_.appended = true;
320 inputWindowsManager->extraData_.sourceType = PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
321 inputWindowsManager->extraData_.pointerId = pointerId + 1;
322 WindowInfo windowInfo;
323 windowInfo.agentWindowId = 1;
324 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->TriggerTouchUpOnInvalidAreaEntry(pointerId));
325
326 item.canceled_ = true;
327 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->TriggerTouchUpOnInvalidAreaEntry(pointerId));
328 }
329
330 /* *
331 * @tc.name: InputWindowsManagerOneTest_TouchPointToDisplayPoint_001
332 * @tc.desc: Test the funcation TouchPointToDisplayPoint
333 * @tc.type: FUNC
334 * @tc.require:
335 */
336 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_TouchPointToDisplayPoint_001, TestSize.Level1)
337 {
338 CALL_TEST_DEBUG;
339 int32_t deviceId = 0;
340 libinput_event_touch touch;
341 EventTouch touchInfo;
342 int32_t physicalDisplayId = 0;
343 bool isNeedClear = false;
344 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
345 EXPECT_FALSE(
346 inputWindowsManager->TouchPointToDisplayPoint(deviceId, &touch, touchInfo, physicalDisplayId, isNeedClear));
347 }
348
349 /* *
350 * @tc.name: InputWindowsManagerOneTest_SelectWindowInfo_001
351 * @tc.desc: Test the funcation SelectWindowInfo
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_SelectWindowInfo_001, TestSize.Level1)
356 {
357 CALL_TEST_DEBUG;
358 int32_t logicalX = 0;
359 int32_t logicalY = 0;
360 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
361 ASSERT_NE(pointerEvent, nullptr);
362 pointerEvent->SetTargetDisplayId(-1);
363 pointerEvent->SetTargetWindowId(1);
364 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP);
365 WindowInfo windowInfo;
366 windowInfo.id = 1;
367 windowInfo.windowInputType = WindowInputType::TRANSMIT_ANTI_AXIS_MOVE;
368 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
369 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
370 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
371 it->second.windowsInfo.push_back(windowInfo);
372 }
373 inputWindowsManager->firstBtnDownWindowInfo_.first = -1;
374 std::unique_ptr<Media::PixelMap> pixelMap = nullptr;
375 inputWindowsManager->transparentWins_.insert_or_assign(windowInfo.id, std::move(pixelMap));
376
377 std::optional<WindowInfo> result = inputWindowsManager->SelectWindowInfo(logicalX, logicalY, pointerEvent);
378 EXPECT_FALSE(result.has_value());
379 }
380
381 /* *
382 * @tc.name: InputWindowsManagerOneTest_SelectWindowInfo_002
383 * @tc.desc: Test the funcation SelectWindowInfo
384 * @tc.type: FUNC
385 * @tc.require:
386 */
387 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_SelectWindowInfo_002, TestSize.Level1)
388 {
389 CALL_TEST_DEBUG;
390 int32_t logicalX = 0;
391 int32_t logicalY = 0;
392 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
393 ASSERT_NE(pointerEvent, nullptr);
394 pointerEvent->SetTargetDisplayId(-1);
395 pointerEvent->SetTargetWindowId(1);
396 pointerEvent->SetPointerAction(PointerEvent::NORMAL);
397 pointerEvent->SetDeviceId(CAST_INPUT_DEVICEID);
398 WindowInfo windowInfo;
399 windowInfo.id = 1;
400 windowInfo.windowInputType = WindowInputType::NORMAL;
401 windowInfo.isSkipSelfWhenShowOnVirtualScreen = true;
402 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
403 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
404 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
405 it->second.windowsInfo.push_back(windowInfo);
406 }
407 inputWindowsManager->firstBtnDownWindowInfo_.first = -1;
408 inputWindowsManager->isOpenPrivacyProtectionserver_ = true;
409 inputWindowsManager->privacyProtection_.isOpen = true;
410 std::unique_ptr<Media::PixelMap> pixelMap = nullptr;
411 inputWindowsManager->transparentWins_.insert_or_assign(windowInfo.id, std::move(pixelMap));
412
413 std::optional<WindowInfo> result = inputWindowsManager->SelectWindowInfo(logicalX, logicalY, pointerEvent);
414 EXPECT_FALSE(result.has_value());
415 }
416
417 /* *
418 * @tc.name: InputWindowsManagerOneTest_SelectWindowInfo_003
419 * @tc.desc: Test the funcation SelectWindowInfo
420 * @tc.type: FUNC
421 * @tc.require:
422 */
423 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_SelectWindowInfo_003, TestSize.Level1)
424 {
425 CALL_TEST_DEBUG;
426 int32_t logicalX = 10;
427 int32_t logicalY = 20;
428 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
429 ASSERT_NE(pointerEvent, nullptr);
430 pointerEvent->SetTargetDisplayId(-1);
431 pointerEvent->SetTargetWindowId(1);
432 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP);
433 pointerEvent->SetDeviceId(CAST_INPUT_DEVICEID);
434 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE;
435 WindowInfo windowInfo;
436 windowInfo.id = 1;
437 windowInfo.flags = 0;
438 windowInfo.pointerHotAreas = {
439 {0, 0, 30, 40}
440 };
441 windowInfo.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
442 windowInfo.isSkipSelfWhenShowOnVirtualScreen = true;
443 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
444 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
445 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
446 it->second.windowsInfo.push_back(windowInfo);
447 }
448 inputWindowsManager->firstBtnDownWindowInfo_.first = -1;
449 inputWindowsManager->isOpenPrivacyProtectionserver_ = true;
450 inputWindowsManager->privacyProtection_.isOpen = false;
451 inputWindowsManager->extraData_.appended = true;
452 inputWindowsManager->extraData_.sourceType = PointerEvent::SOURCE_TYPE_MOUSE;
453 std::unique_ptr<Media::PixelMap> pixelMap = nullptr;
454 inputWindowsManager->transparentWins_.insert_or_assign(windowInfo.id, std::move(pixelMap));
455
456 std::optional<WindowInfo> result = inputWindowsManager->SelectWindowInfo(logicalX, logicalY, pointerEvent);
457 EXPECT_FALSE(result.has_value());
458 }
459
460 /* *
461 * @tc.name: InputWindowsManagerOneTest_SelectWindowInfo_004
462 * @tc.desc: Test the funcation SelectWindowInfo
463 * @tc.type: FUNC
464 * @tc.require:
465 */
466 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_SelectWindowInfo_004, TestSize.Level1)
467 {
468 CALL_TEST_DEBUG;
469 int32_t logicalX = 10;
470 int32_t logicalY = 20;
471 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
472 ASSERT_NE(pointerEvent, nullptr);
473 pointerEvent->SetTargetDisplayId(-1);
474 pointerEvent->SetTargetWindowId(1);
475 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP);
476 pointerEvent->SetDeviceId(CAST_INPUT_DEVICEID);
477 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE;
478 WindowInfo windowInfo;
479 windowInfo.id = 1;
480 windowInfo.flags = 0;
481 windowInfo.pointerHotAreas = {
482 {0, 0, 30, 40}
483 };
484 windowInfo.windowInputType = WindowInputType::NORMAL;
485 windowInfo.isSkipSelfWhenShowOnVirtualScreen = true;
486 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
487 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
488 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
489 it->second.windowsInfo.push_back(windowInfo);
490 }
491 inputWindowsManager->firstBtnDownWindowInfo_.first = -1;
492 inputWindowsManager->isOpenPrivacyProtectionserver_ = true;
493 inputWindowsManager->privacyProtection_.isOpen = false;
494 inputWindowsManager->extraData_.appended = true;
495 inputWindowsManager->extraData_.sourceType = PointerEvent::SOURCE_TYPE_MOUSE;
496 std::unique_ptr<Media::PixelMap> pixelMap = nullptr;
497 inputWindowsManager->transparentWins_.insert_or_assign(windowInfo.id, std::move(pixelMap));
498
499 std::optional<WindowInfo> result = inputWindowsManager->SelectWindowInfo(logicalX, logicalY, pointerEvent);
500 EXPECT_TRUE(result.has_value());
501 }
502
503 /* *
504 * @tc.name: InputWindowsManagerOneTest_SelectWindowInfo_005
505 * @tc.desc: Test the funcation SelectWindowInfo
506 * @tc.type: FUNC
507 * @tc.require:
508 */
509 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_SelectWindowInfo_005, TestSize.Level1)
510 {
511 CALL_TEST_DEBUG;
512 int32_t logicalX = 10;
513 int32_t logicalY = 20;
514 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
515 ASSERT_NE(pointerEvent, nullptr);
516 pointerEvent->SetTargetDisplayId(-1);
517 pointerEvent->SetTargetWindowId(-1);
518 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_END);
519 pointerEvent->SetDeviceId(CAST_INPUT_DEVICEID);
520 pointerEvent->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
521 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE;
522 WindowInfo windowInfo;
523 windowInfo.id = 1;
524 windowInfo.flags = 0;
525 windowInfo.pointerHotAreas = {
526 {0, 0, 30, 40}
527 };
528 windowInfo.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
529 windowInfo.isSkipSelfWhenShowOnVirtualScreen = true;
530 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
531 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
532 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
533 it->second.windowsInfo.push_back(windowInfo);
534 }
535 inputWindowsManager->firstBtnDownWindowInfo_.first = -1;
536 inputWindowsManager->isOpenPrivacyProtectionserver_ = true;
537 inputWindowsManager->privacyProtection_.isOpen = false;
538 inputWindowsManager->extraData_.appended = false;
539 inputWindowsManager->extraData_.sourceType = PointerEvent::SOURCE_TYPE_MOUSE;
540 std::unique_ptr<Media::PixelMap> pixelMap = nullptr;
541 inputWindowsManager->transparentWins_.insert_or_assign(windowInfo.id, std::move(pixelMap));
542
543 std::optional<WindowInfo> result = inputWindowsManager->SelectWindowInfo(logicalX, logicalY, pointerEvent);
544 EXPECT_FALSE(result.has_value());
545
546 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
547 pointerEvent->pressedButtons_.insert(1);
548 Rect rect {
549 .x = 100,
550 .y = 100,
551 .width = 300,
552 .height = 300,
553 };
554 WindowInfo winInfo;
555 winInfo.id = 50;
556 winInfo.defaultHotAreas.push_back(rect);
557 windowInfo.uiExtentionWindowInfo.push_back(winInfo);
558 it->second.windowsInfo.clear();
559 it->second.windowsInfo.push_back(windowInfo);
560 std::optional<WindowInfo> result1 = inputWindowsManager->SelectWindowInfo(logicalX, logicalY, pointerEvent);
561 EXPECT_TRUE(result1.has_value());
562 }
563
564 /* *
565 * @tc.name: InputWindowsManagerOneTest_SelectWindowInfo_006
566 * @tc.desc: Test the funcation SelectWindowInfo
567 * @tc.type: FUNC
568 * @tc.require:
569 */
570 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_SelectWindowInfo_006, TestSize.Level1)
571 {
572 CALL_TEST_DEBUG;
573 int32_t logicalX = 10;
574 int32_t logicalY = 20;
575 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
576 ASSERT_NE(pointerEvent, nullptr);
577 pointerEvent->SetTargetDisplayId(-1);
578 pointerEvent->SetTargetWindowId(-1);
579 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
580 pointerEvent->SetDeviceId(CAST_INPUT_DEVICEID);
581 pointerEvent->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
582 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE;
583 WindowInfo windowInfo;
584 windowInfo.id = 1;
585 windowInfo.flags = 0;
586 windowInfo.pointerHotAreas = {
587 {0, 0, 30, 40}
588 };
589 windowInfo.windowInputType = WindowInputType::NORMAL;
590 windowInfo.isSkipSelfWhenShowOnVirtualScreen = true;
591 windowInfo.uiExtentionWindowInfo.clear();
592 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
593 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
594 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
595 it->second.windowsInfo.push_back(windowInfo);
596 }
597 inputWindowsManager->firstBtnDownWindowInfo_.first = -1;
598 inputWindowsManager->isOpenPrivacyProtectionserver_ = true;
599 inputWindowsManager->privacyProtection_.isOpen = false;
600 inputWindowsManager->extraData_.appended = false;
601 inputWindowsManager->extraData_.sourceType = PointerEvent::SOURCE_TYPE_MOUSE;
602 std::unique_ptr<Media::PixelMap> pixelMap = nullptr;
603 inputWindowsManager->transparentWins_.insert_or_assign(windowInfo.id, std::move(pixelMap));
604
605 std::optional<WindowInfo> result = inputWindowsManager->SelectWindowInfo(logicalX, logicalY, pointerEvent);
606 EXPECT_TRUE(result.has_value());
607 }
608
609 /* *
610 * @tc.name: InputWindowsManagerOneTest_SelectWindowInfo_007
611 * @tc.desc: Test the funcation SelectWindowInfo
612 * @tc.type: FUNC
613 * @tc.require:
614 */
615 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_SelectWindowInfo_007, TestSize.Level1)
616 {
617 CALL_TEST_DEBUG;
618 int32_t logicalX = 10;
619 int32_t logicalY = 20;
620 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
621 ASSERT_NE(pointerEvent, nullptr);
622 pointerEvent->SetTargetDisplayId(-1);
623 pointerEvent->SetTargetWindowId(1);
624 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
625 pointerEvent->SetDeviceId(CAST_INPUT_DEVICEID);
626 pointerEvent->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
627 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE;
628 WindowInfo windowInfo;
629 windowInfo.id = 1;
630 windowInfo.flags = 0;
631 windowInfo.pointerHotAreas = {
632 {0, 0, 30, 40}
633 };
634 windowInfo.windowInputType = WindowInputType::NORMAL;
635 windowInfo.isSkipSelfWhenShowOnVirtualScreen = true;
636 windowInfo.uiExtentionWindowInfo.clear();
637 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
638 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
639 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
640 it->second.windowsInfo.push_back(windowInfo);
641 }
642 inputWindowsManager->firstBtnDownWindowInfo_.first = -1;
643 inputWindowsManager->isOpenPrivacyProtectionserver_ = true;
644 inputWindowsManager->privacyProtection_.isOpen = false;
645 inputWindowsManager->extraData_.appended = false;
646 inputWindowsManager->extraData_.sourceType = PointerEvent::SOURCE_TYPE_MOUSE;
647 std::unique_ptr<Media::PixelMap> pixelMap = nullptr;
648 inputWindowsManager->transparentWins_.insert_or_assign(windowInfo.id, std::move(pixelMap));
649
650 std::optional<WindowInfo> result = inputWindowsManager->SelectWindowInfo(logicalX, logicalY, pointerEvent);
651 EXPECT_TRUE(result.has_value());
652 }
653
654 /* *
655 * @tc.name: InputWindowsManagerOneTest_SelectWindowInfo_008
656 * @tc.desc: Test the funcation SelectWindowInfo
657 * @tc.type: FUNC
658 * @tc.require:
659 */
660 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_SelectWindowInfo_008, TestSize.Level1)
661 {
662 CALL_TEST_DEBUG;
663 int32_t logicalX = 10;
664 int32_t logicalY = 20;
665 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
666 ASSERT_NE(pointerEvent, nullptr);
667 pointerEvent->pressedButtons_.insert(1);
668 pointerEvent->SetTargetDisplayId(-1);
669 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_UPDATE);
670 WindowInfo info;
671 info.id = 1;
672 info.windowInputType = WindowInputType::TRANSMIT_ANTI_AXIS_MOVE;
673
674 WindowInfo windowInfo;
675 windowInfo.id = 1;
676 info.uiExtentionWindowInfo.push_back(windowInfo);
677 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
678 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
679 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
680 it->second.windowsInfo.push_back(windowInfo);
681 }
682 inputWindowsManager->extraData_.appended = false;
683 inputWindowsManager->firstBtnDownWindowInfo_.first = 1;
684 WindowInfo beginWindowInfo;
685 beginWindowInfo.id = 1;
686 inputWindowsManager->axisBeginWindowInfo_ = beginWindowInfo;
687 std::optional<WindowInfo> result = inputWindowsManager->SelectWindowInfo(logicalX, logicalY, pointerEvent);
688 EXPECT_TRUE(result.has_value());
689 }
690
691 /* *
692 * @tc.name: InputWindowsManagerOneTest_SelectWindowInfo_009
693 * @tc.desc: Test the funcation SelectWindowInfo
694 * @tc.type: FUNC
695 * @tc.require:
696 */
697 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_SelectWindowInfo_009, TestSize.Level1)
698 {
699 CALL_TEST_DEBUG;
700 int32_t logicalX = 10;
701 int32_t logicalY = 20;
702 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
703 ASSERT_NE(pointerEvent, nullptr);
704 pointerEvent->pressedButtons_.insert(1);
705 pointerEvent->SetTargetDisplayId(1);
706 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_UPDATE);
707 WindowInfo info;
708 info.id = 0;
709 info.windowInputType = WindowInputType::TRANSMIT_ANTI_AXIS_MOVE;
710
711 WindowInfo windowInfo;
712 windowInfo.id = 0;
713 info.uiExtentionWindowInfo.push_back(windowInfo);
714 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
715 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
716 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
717 it->second.windowsInfo.push_back(windowInfo);
718 }
719 inputWindowsManager->extraData_.appended = false;
720 inputWindowsManager->firstBtnDownWindowInfo_.first = 1;
721 inputWindowsManager->firstBtnDownWindowInfo_.second = -1;
722 WindowInfo beginWindowInfo;
723 beginWindowInfo.id = 1;
724 inputWindowsManager->axisBeginWindowInfo_ = beginWindowInfo;
725 std::optional<WindowInfo> result = inputWindowsManager->SelectWindowInfo(logicalX, logicalY, pointerEvent);
726 EXPECT_FALSE(result.has_value());
727 }
728
729 /* *
730 * @tc.name: InputWindowsManagerOneTest_SelectWindowInfo_010
731 * @tc.desc: Test the funcation SelectWindowInfo
732 * @tc.type: FUNC
733 * @tc.require:
734 */
735 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_SelectWindowInfo_010, TestSize.Level1)
736 {
737 CALL_TEST_DEBUG;
738 int32_t logicalX = 10;
739 int32_t logicalY = 20;
740 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
741 ASSERT_NE(pointerEvent, nullptr);
742 pointerEvent->pressedButtons_.insert(1);
743 pointerEvent->SetTargetDisplayId(-1);
744 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
745 WindowInfo info;
746 info.id = 0;
747 info.windowInputType = WindowInputType::TRANSMIT_ANTI_AXIS_MOVE;
748
749 WindowInfo windowInfo;
750 windowInfo.id = -1;
751 info.uiExtentionWindowInfo.push_back(windowInfo);
752 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
753
754 WindowGroupInfo windowGroupInfo;
755 windowGroupInfo.windowsInfo.push_back(info);
756 inputWindowsManager->windowsPerDisplay_.insert(std::make_pair(2, windowGroupInfo));
757
758 inputWindowsManager->extraData_.appended = false;
759 inputWindowsManager->firstBtnDownWindowInfo_.first = 0;
760 inputWindowsManager->firstBtnDownWindowInfo_.second = 2;
761 WindowInfo beginWindowInfo;
762 beginWindowInfo.id = 1;
763 inputWindowsManager->axisBeginWindowInfo_ = beginWindowInfo;
764 std::optional<WindowInfo> result = inputWindowsManager->SelectWindowInfo(logicalX, logicalY, pointerEvent);
765 EXPECT_FALSE(result.has_value());
766
767 inputWindowsManager->firstBtnDownWindowInfo_.first = -1;
768 std::optional<WindowInfo> result1 = inputWindowsManager->SelectWindowInfo(logicalX, logicalY, pointerEvent);
769 EXPECT_FALSE(result1.has_value());
770 }
771 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
772
773 #ifdef OHOS_BUILD_ENABLE_POINTER
774 /* *
775 * @tc.name: InputWindowsManagerOneTest_GetPositionDisplayDirection_001
776 * @tc.desc: Test the funcation GetPositionDisplayDirection
777 * @tc.type: FUNC
778 * @tc.require:
779 */
780 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_GetPositionDisplayDirection_001, TestSize.Level1)
781 {
782 CALL_TEST_DEBUG;
783 int32_t id = -1;
784 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
785 EXPECT_EQ(inputWindowsManager->GetPositionDisplayDirection(id), Direction::DIRECTION0);
786 }
787 #endif // OHOS_BUILD_ENABLE_POINTER
788
789 /* *
790 * @tc.name: InputWindowsManagerOneTest_UpdateCustomStyle_001
791 * @tc.desc: Test the funcation UpdateCustomStyle
792 * @tc.type: FUNC
793 * @tc.require:
794 */
795 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_UpdateCustomStyle_001, TestSize.Level1)
796 {
797 CALL_TEST_DEBUG;
798 int32_t windowId = 0;
799 PointerStyle pointerStyle;
800 pointerStyle.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON;
801 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
802 PointerStyle pointerStyle1;
803 pointerStyle1.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON;
804 pointerStyle1.size = 11;
805 std::map<int32_t, PointerStyle> tmpPointerStyle = {
806 {windowId + 1, pointerStyle1}
807 };
808 inputWindowsManager->pointerStyle_.insert(std::make_pair(1, tmpPointerStyle));
809 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->UpdateCustomStyle(windowId, pointerStyle));
810
811 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->UpdateCustomStyle(windowId, pointerStyle));
812 }
813
814 /* *
815 * @tc.name: InputWindowsManagerOneTest_SkipPrivacyProtectionWindow_001
816 * @tc.desc: Test the funcation SkipPrivacyProtectionWindow
817 * @tc.type: FUNC
818 * @tc.require:
819 */
820 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_SkipPrivacyProtectionWindow_001, TestSize.Level1)
821 {
822 CALL_TEST_DEBUG;
823 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
824 ASSERT_NE(pointerEvent, nullptr);
825 pointerEvent->SetDeviceId(CAST_INPUT_DEVICEID);
826 bool isSkip = true;
827 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
828 inputWindowsManager->isOpenPrivacyProtectionserver_ = false;
829 inputWindowsManager->privacyProtection_.isOpen = true;
830 EXPECT_TRUE(inputWindowsManager->SkipPrivacyProtectionWindow(pointerEvent, isSkip));
831
832 pointerEvent->SetDeviceId(CAST_SCREEN_DEVICEID);
833 isSkip = false;
834 EXPECT_FALSE(inputWindowsManager->SkipPrivacyProtectionWindow(pointerEvent, isSkip));
835
836 inputWindowsManager->privacyProtection_.isOpen = false;
837 EXPECT_FALSE(inputWindowsManager->SkipPrivacyProtectionWindow(pointerEvent, isSkip));
838 }
839
840 #ifdef OHOS_BUILD_ENABLE_ONE_HAND_MODE
841 /* *
842 * @tc.name: InputWindowsManagerOneTest_HandleOneHandMode_001
843 * @tc.desc: Test the funcation HandleOneHandMode
844 * @tc.type: FUNC
845 * @tc.require:
846 */
847 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_HandleOneHandMode_001, TestSize.Level1)
848 {
849 CALL_TEST_DEBUG;
850 OLD::DisplayInfo displayInfo;
851 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
852 ASSERT_NE(pointerEvent, nullptr);
853 PointerEvent::PointerItem pointerItem;
854 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
855 pointerItem.SetDisplayXPos(0.0);
856 pointerItem.SetDisplayYPos(0.0);
857 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE;
858 pointerEvent->SetAutoToVirtualScreen(true);
859 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->HandleOneHandMode(displayInfo, pointerEvent, pointerItem));
860
861 pointerEvent->SetAutoToVirtualScreen(false);
862 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->HandleOneHandMode(displayInfo, pointerEvent, pointerItem));
863 }
864
865 /* *
866 * @tc.name: InputWindowsManagerOneTest_UpdatePointerItemInOneHandMode_001
867 * @tc.desc: Test the funcation UpdatePointerItemInOneHandMode
868 * @tc.type: FUNC
869 * @tc.require:
870 */
871 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_UpdatePointerItemInOneHandMode_001, TestSize.Level1)
872 {
873 CALL_TEST_DEBUG;
874 OLD::DisplayInfo displayInfo;
875 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
876 ASSERT_NE(pointerEvent, nullptr);
877 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
878 PointerEvent::PointerItem item;
879 int32_t pointerId = 0;
880 item.SetPointerId(pointerId);
881 pointerEvent->pointers_.push_back(item);
882 pointerEvent->SetPointerId(pointerId + 1);
883 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->UpdatePointerItemInOneHandMode(displayInfo, pointerEvent));
884
885 pointerEvent->SetPointerId(pointerId);
886 displayInfo.height = 0;
887 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->UpdatePointerItemInOneHandMode(displayInfo, pointerEvent));
888 }
889
890 /* *
891 * @tc.name: InputWindowsManagerOneTest_UpdatePointerItemInOneHandMode_002
892 * @tc.desc: Test the funcation UpdatePointerItemInOneHandMode
893 * @tc.type: FUNC
894 * @tc.require:
895 */
896 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_UpdatePointerItemInOneHandMode_002, TestSize.Level1)
897 {
898 CALL_TEST_DEBUG;
899 OLD::DisplayInfo displayInfo;
900 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
901 ASSERT_NE(pointerEvent, nullptr);
902 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
903 PointerEvent::PointerItem item;
904 int32_t pointerId = 0;
905 item.SetPointerId(pointerId);
906 pointerEvent->pointers_.push_back(item);
907 pointerEvent->SetPointerId(pointerId);
908 displayInfo.height = 1;
909 displayInfo.oneHandY = displayInfo.height;
910 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->UpdatePointerItemInOneHandMode(displayInfo, pointerEvent));
911
912 displayInfo.oneHandY = displayInfo.height + 1;
913 displayInfo.scalePercent = 1;
914 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->UpdatePointerItemInOneHandMode(displayInfo, pointerEvent));
915 }
916 #endif // OHOS_BUILD_ENABLE_ONE_HAND_MODE
917
918 #if defined(OHOS_BUILD_ENABLE_POINTER) || defined(OHOS_BUILD_ENABLE_TOUCH)
919 /* *
920 * @tc.name: InputWindowsManagerOneTest_UpdateTransformDisplayXY_001
921 * @tc.desc: Test the funcation UpdateTransformDisplayXY
922 * @tc.type: FUNC
923 * @tc.require:
924 */
925 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_UpdateTransformDisplayXY_001, TestSize.Level1)
926 {
927 CALL_TEST_DEBUG;
928 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
929 ASSERT_NE(pointerEvent, nullptr);
930 std::vector<WindowInfo> windowsInfo;
931 OLD::DisplayInfo displayInfo;
932 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
933
934 int32_t pointerId = 0;
935 PointerEvent::PointerItem item;
936 item.SetPointerId(pointerId);
937 item.SetDisplayXPos(0.0);
938 item.SetDisplayYPos(0.0);
939 pointerEvent->pointers_.push_back(item);
940 pointerEvent->SetPointerId(pointerId);
941 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE_NAVIGATION;
942 displayInfo.transform.push_back(1.0f);
943 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
944 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->UpdateTransformDisplayXY(pointerEvent, windowsInfo, displayInfo));
945 }
946
947 /* *
948 * @tc.name: InputWindowsManagerOneTest_UpdateTransformDisplayXY_002
949 * @tc.desc: Test the funcation UpdateTransformDisplayXY
950 * @tc.type: FUNC
951 * @tc.require:
952 */
953 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_UpdateTransformDisplayXY_002, TestSize.Level1)
954 {
955 CALL_TEST_DEBUG;
956 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
957 ASSERT_NE(pointerEvent, nullptr);
958 std::vector<WindowInfo> windowsInfo;
959 OLD::DisplayInfo displayInfo;
960 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
961
962 int32_t pointerId = 0;
963 PointerEvent::PointerItem item;
964 item.SetPointerId(pointerId);
965 item.SetDisplayXPos(0.0);
966 item.SetDisplayYPos(0.0);
967 pointerEvent->pointers_.push_back(item);
968 pointerEvent->SetPointerId(pointerId);
969 displayInfo.transform.push_back(1.0f);
970 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_ACCESSIBILITY;
971 pointerEvent->SetZOrder(1.0f);
972 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
973 pointerEvent->SetTargetWindowId(-1);
974 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->UpdateTransformDisplayXY(pointerEvent, windowsInfo, displayInfo));
975 }
976
977 /* *
978 * @tc.name: InputWindowsManagerOneTest_UpdateTransformDisplayXY_003
979 * @tc.desc: Test the funcation UpdateTransformDisplayXY
980 * @tc.type: FUNC
981 * @tc.require:
982 */
983 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_UpdateTransformDisplayXY_003, TestSize.Level1)
984 {
985 CALL_TEST_DEBUG;
986 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
987 ASSERT_NE(pointerEvent, nullptr);
988 std::vector<WindowInfo> windowsInfo;
989 OLD::DisplayInfo displayInfo;
990 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
991
992 int32_t pointerId = 0;
993 PointerEvent::PointerItem item;
994 item.SetPointerId(pointerId);
995 item.SetDisplayXPos(0.0);
996 item.SetDisplayYPos(0.0);
997 pointerEvent->pointers_.push_back(item);
998 pointerEvent->SetPointerId(pointerId);
999 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_ACCESSIBILITY | InputEvent::EVENT_FLAG_SIMULATE_NAVIGATION;
1000 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1001 displayInfo.transform.clear();
1002 pointerEvent->SetTargetWindowId(-1);
1003 pointerEvent->SetZOrder(0.0f);
1004 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->UpdateTransformDisplayXY(pointerEvent, windowsInfo, displayInfo));
1005 }
1006
1007 /* *
1008 * @tc.name: InputWindowsManagerOneTest_UpdateTransformDisplayXY_004
1009 * @tc.desc: Test the funcation UpdateTransformDisplayXY
1010 * @tc.type: FUNC
1011 * @tc.require:
1012 */
1013 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_UpdateTransformDisplayXY_004, TestSize.Level1)
1014 {
1015 CALL_TEST_DEBUG;
1016 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1017 ASSERT_NE(pointerEvent, nullptr);
1018 std::vector<WindowInfo> windowsInfo;
1019 OLD::DisplayInfo displayInfo;
1020 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1021
1022 int32_t pointerId = 0;
1023 PointerEvent::PointerItem item;
1024 item.SetPointerId(pointerId);
1025 item.SetDisplayXPos(0.0);
1026 item.SetDisplayYPos(0.0);
1027 pointerEvent->pointers_.push_back(item);
1028 pointerEvent->SetPointerId(pointerId);
1029 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1030 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_ACCESSIBILITY;
1031 displayInfo.transform.clear();
1032 pointerEvent->SetTargetWindowId(-1);
1033 pointerEvent->SetZOrder(1.0f);
1034 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->UpdateTransformDisplayXY(pointerEvent, windowsInfo, displayInfo));
1035 }
1036
1037 /* *
1038 * @tc.name: InputWindowsManagerOneTest_UpdateTransformDisplayXY_005
1039 * @tc.desc: Test the funcation UpdateTransformDisplayXY
1040 * @tc.type: FUNC
1041 * @tc.require:
1042 */
1043 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_UpdateTransformDisplayXY_005, TestSize.Level1)
1044 {
1045 CALL_TEST_DEBUG;
1046 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1047 ASSERT_NE(pointerEvent, nullptr);
1048 std::vector<WindowInfo> windowsInfo;
1049 OLD::DisplayInfo displayInfo;
1050 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1051
1052 int32_t pointerId = 0;
1053 PointerEvent::PointerItem item;
1054 item.SetPointerId(pointerId);
1055 item.SetDisplayXPos(10.0);
1056 item.SetDisplayYPos(20.0);
1057 pointerEvent->pointers_.push_back(item);
1058 pointerEvent->SetPointerId(pointerId);
1059 displayInfo.transform.push_back(1.0f);
1060 pointerEvent->bitwise_ = 0;
1061 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
1062 WindowInfo info;
1063 info.id = 50;
1064 info.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
1065 Rect rect {
1066 .x = 0,
1067 .y = 0,
1068 .width = 300,
1069 .height = 300,
1070 };
1071 info.defaultHotAreas.push_back(rect);
1072 windowsInfo.push_back(info);
1073 pointerEvent->SetZOrder(0.0f);
1074 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->UpdateTransformDisplayXY(pointerEvent, windowsInfo, displayInfo));
1075 }
1076
1077 /* *
1078 * @tc.name: InputWindowsManagerOneTest_UpdateTransformDisplayXY_006
1079 * @tc.desc: Test the funcation UpdateTransformDisplayXY
1080 * @tc.type: FUNC
1081 * @tc.require:
1082 */
1083 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_UpdateTransformDisplayXY_006, TestSize.Level1)
1084 {
1085 CALL_TEST_DEBUG;
1086 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1087 ASSERT_NE(pointerEvent, nullptr);
1088 std::vector<WindowInfo> windowsInfo;
1089 OLD::DisplayInfo displayInfo;
1090 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1091
1092 int32_t pointerId = 0;
1093 PointerEvent::PointerItem item;
1094 item.SetPointerId(pointerId);
1095 item.SetDisplayXPos(10.0);
1096 item.SetDisplayYPos(20.0);
1097 pointerEvent->pointers_.push_back(item);
1098 pointerEvent->SetPointerId(pointerId);
1099 pointerEvent->SetZOrder(1.0f);
1100 displayInfo.transform.push_back(1.0f);
1101 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_ACCESSIBILITY;
1102 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1103 pointerEvent->SetTargetWindowId(1);
1104 WindowInfo info;
1105 info.id = 0;
1106 info.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
1107 Rect rect {
1108 .x = 0,
1109 .y = 0,
1110 .width = 300,
1111 .height = 300,
1112 };
1113 info.defaultHotAreas.push_back(rect);
1114 windowsInfo.push_back(info);
1115 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->UpdateTransformDisplayXY(pointerEvent, windowsInfo, displayInfo));
1116 }
1117
1118 /* *
1119 * @tc.name: InputWindowsManagerOneTest_DispatchTouch_001
1120 * @tc.desc: Test the funcation DispatchTouch
1121 * @tc.type: FUNC
1122 * @tc.require:
1123 */
1124 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_DispatchTouch_001, TestSize.Level1)
1125 {
1126 CALL_TEST_DEBUG;
1127 int32_t pointerAction = PointerEvent::POINTER_ACTION_PULL_IN_WINDOW;
1128 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1129 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1130 ASSERT_NE(pointerEvent, nullptr);
1131 UDSServer udsServer;
1132 inputWindowsManager->udsServer_ = &udsServer;
1133 inputWindowsManager->lastTouchEvent_ = pointerEvent;
1134 WindowInfo windowInfo;
1135 windowInfo.id = 1;
1136 windowInfo.flags = 0;
1137 windowInfo.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
1138 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
1139 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
1140 it->second.windowsInfo.push_back(windowInfo);
1141 }
1142 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->DispatchTouch(pointerAction));
1143 }
1144
1145 /* *
1146 * @tc.name: InputWindowsManagerOneTest_CalculateAcrossDirection_001
1147 * @tc.desc: Test the funcation CalculateAcrossDirection
1148 * @tc.type: FUNC
1149 * @tc.require:
1150 */
1151 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_CalculateAcrossDirection_001, TestSize.Level1)
1152 {
1153 CALL_TEST_DEBUG;
1154 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1155 OLD::DisplayInfo displayInfo;
1156 Vector2D<double> layout;
1157 displayInfo.x = 1;
1158 displayInfo.y = 1;
1159 displayInfo.validWidth = 2;
1160 displayInfo.validHeight = 1;
1161 layout.x = 2;
1162 layout.y = 2;
1163 EXPECT_EQ(inputWindowsManager->CalculateAcrossDirection(displayInfo, layout), AcrossDirection::DOWNWARDS);
1164 }
1165
1166 /* *
1167 * @tc.name: InputWindowsManagerOneTest_AcrossDisplay_001
1168 * @tc.desc: Test the funcation AcrossDisplay
1169 * @tc.type: FUNC
1170 * @tc.require:
1171 */
1172 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_AcrossDisplay_001, TestSize.Level1)
1173 {
1174 CALL_TEST_DEBUG;
1175 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1176 OLD::DisplayInfo displayInfoDes;
1177 OLD::DisplayInfo displayInfoOri;
1178 Vector2D<double> logical;
1179 Vector2D<double> layout;
1180 AcrossDirection acrossDirection = AcrossDirection::RIGHTWARDS;
1181
1182 displayInfoDes.x = INT32_MAX;
1183 displayInfoDes.validWidth = 1;
1184 EXPECT_FALSE(inputWindowsManager->AcrossDisplay(displayInfoDes, displayInfoOri, logical, layout, acrossDirection));
1185
1186 displayInfoDes.x = 1;
1187 displayInfoDes.y = 1;
1188 displayInfoDes.validHeight = INT32_MAX;
1189 EXPECT_FALSE(inputWindowsManager->AcrossDisplay(displayInfoDes, displayInfoOri, logical, layout, acrossDirection));
1190
1191 displayInfoDes.validHeight = 1;
1192 displayInfoOri.x = 0;
1193 displayInfoOri.y = 0;
1194 displayInfoOri.validWidth = 1;
1195 displayInfoOri.validHeight = 0;
1196
1197 layout.x = 0;
1198 layout.y = 0;
1199 EXPECT_TRUE(inputWindowsManager->AcrossDisplay(displayInfoDes, displayInfoOri, logical, layout, acrossDirection));
1200 }
1201
1202 /* *
1203 * @tc.name: InputWindowsManagerOneTest_FindPhysicalDisplay_001
1204 * @tc.desc: Test the funcation FindPhysicalDisplay
1205 * @tc.type: FUNC
1206 * @tc.require:
1207 */
1208 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_FindPhysicalDisplay_001, TestSize.Level1)
1209 {
1210 CALL_TEST_DEBUG;
1211 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1212
1213 OLD::DisplayInfo displayInfo;
1214 double physicalX = 0.0f;
1215 double physicalY = 0.0f;
1216 int32_t displayId = 0;
1217
1218 OLD::DisplayInfo displayInfo1;
1219 displayInfo1.id = 0;
1220 displayInfo1.dpi = -10;
1221 displayInfo1.uniq = "default0";
1222 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
1223 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
1224 it->second.displaysInfo.push_back(displayInfo1);
1225 }
1226
1227 displayInfo.id = 1;
1228 displayInfo.x = INT32_MAX;
1229 displayInfo.y = 1;
1230 displayInfo.validWidth = INT32_MAX;
1231 displayInfo.validHeight = 1;
1232 displayInfo.direction = DIRECTION0;
1233 displayInfo.displayDirection = DIRECTION0;
1234 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->FindPhysicalDisplay(displayInfo, physicalX, physicalY, displayId));
1235 }
1236
1237 /* *
1238 * @tc.name: InputWindowsManagerOneTest_ReverseRotateDisplayScreen_001
1239 * @tc.desc: Test the funcation ReverseRotateDisplayScreen
1240 * @tc.type: FUNC
1241 * @tc.require:
1242 */
1243 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ReverseRotateDisplayScreen_001, TestSize.Level1)
1244 {
1245 CALL_TEST_DEBUG;
1246 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1247 OLD::DisplayInfo info;
1248 double x = 0.0f;
1249 double y = 0.0f;
1250 Coordinate2D cursorPos = {0.0, 0.0};
1251 info.direction = Direction::DIRECTION90;
1252 info.displayDirection = Direction::DIRECTION0;
1253 info.width = 0;
1254 info.height = 0;
1255 info.validWidth = 0;
1256 info.validHeight = 0;
1257 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ReverseRotateDisplayScreen(info, x, y, cursorPos));
1258 }
1259
1260 /* *
1261 * @tc.name: InputWindowsManagerOneTest_ReverseRotateDisplayScreen_002
1262 * @tc.desc: Test the funcation ReverseRotateDisplayScreen
1263 * @tc.type: FUNC
1264 * @tc.require:
1265 */
1266 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ReverseRotateDisplayScreen_002, TestSize.Level1)
1267 {
1268 CALL_TEST_DEBUG;
1269 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1270 OLD::DisplayInfo info;
1271 double x = 0.0f;
1272 double y = 0.0f;
1273 Coordinate2D cursorPos = {0.0, 0.0};
1274 info.direction = Direction::DIRECTION180;
1275 info.displayDirection = Direction::DIRECTION0;
1276 info.width = 0;
1277 info.height = 0;
1278 info.validWidth = 0;
1279 info.validHeight = 0;
1280 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ReverseRotateDisplayScreen(info, x, y, cursorPos));
1281 }
1282
1283 /* *
1284 * @tc.name: InputWindowsManagerOneTest_ShiftAppMousePointerEvent_001
1285 * @tc.desc: Test the funcation ShiftAppMousePointerEvent
1286 * @tc.type: FUNC
1287 * @tc.require:
1288 */
1289 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ShiftAppMousePointerEvent_001, TestSize.Level1)
1290 {
1291 CALL_TEST_DEBUG;
1292 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1293 ShiftWindowInfo shiftWindowInfo;
1294 bool autoGenDown = false;
1295 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1296 ASSERT_NE(pointerEvent, nullptr);
1297 inputWindowsManager->lastPointerEvent_ = pointerEvent;
1298 EXPECT_EQ(inputWindowsManager->ShiftAppMousePointerEvent(shiftWindowInfo, autoGenDown), RET_ERR);
1299 }
1300 #endif // OHOS_BUILD_ENABLE_POINTER || OHOS_BUILD_ENABLE_TOUCH
1301
1302 /* *
1303 * @tc.name: InputWindowsManagerOneTest_AppendExtraData_001
1304 * @tc.desc: Test the funcation AppendExtraData
1305 * @tc.type: FUNC
1306 * @tc.require:
1307 */
1308 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_AppendExtraData_001, TestSize.Level1)
1309 {
1310 CALL_TEST_DEBUG;
1311 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1312 ExtraData extraData;
1313 extraData.drawCursor = true;
1314 extraData.eventId = 1;
1315 extraData.sourceType = PointerEvent::SOURCE_TYPE_MOUSE;
1316 inputWindowsManager->mouseDownEventId_ = -1;
1317 EXPECT_EQ(inputWindowsManager->AppendExtraData(extraData), RET_ERR);
1318 }
1319
1320 /* *
1321 * @tc.name: InputWindowsManagerOneTest_AppendExtraData_002
1322 * @tc.desc: Test the funcation AppendExtraData
1323 * @tc.type: FUNC
1324 * @tc.require:
1325 */
1326 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_AppendExtraData_002, TestSize.Level1)
1327 {
1328 CALL_TEST_DEBUG;
1329 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1330 ExtraData extraData;
1331 extraData.drawCursor = true;
1332 extraData.eventId = 1;
1333 extraData.sourceType = PointerEvent::SOURCE_TYPE_MOUSE;
1334 inputWindowsManager->mouseDownEventId_ = extraData.eventId + 1;
1335 EXPECT_EQ(inputWindowsManager->AppendExtraData(extraData), RET_ERR);
1336 }
1337
1338 /* *
1339 * @tc.name: InputWindowsManagerOneTest_AppendExtraData_003
1340 * @tc.desc: Test the funcation AppendExtraData
1341 * @tc.type: FUNC
1342 * @tc.require:
1343 */
1344 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_AppendExtraData_003, TestSize.Level1)
1345 {
1346 CALL_TEST_DEBUG;
1347 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1348 ExtraData extraData;
1349 extraData.drawCursor = true;
1350 extraData.eventId = 1;
1351 extraData.sourceType = PointerEvent::SOURCE_TYPE_MOUSE;
1352 inputWindowsManager->mouseDownEventId_ = extraData.eventId;
1353 EXPECT_EQ(inputWindowsManager->AppendExtraData(extraData), RET_OK);
1354
1355 extraData.sourceType = PointerEvent::SOURCE_TYPE_UNKNOWN;
1356 EXPECT_EQ(inputWindowsManager->AppendExtraData(extraData), RET_OK);
1357
1358 extraData.eventId = 0;
1359 EXPECT_EQ(inputWindowsManager->AppendExtraData(extraData), RET_OK);
1360 }
1361
1362 /* *
1363 * @tc.name: InputWindowsManagerOneTest_ParseJson_001
1364 * @tc.desc: Test the funcation ParseJson
1365 * @tc.type: FUNC
1366 * @tc.require:
1367 */
1368 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ParseJson_001, TestSize.Level1)
1369 {
1370 CALL_TEST_DEBUG;
1371 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1372 std::string configFile = "config_file_path";
1373 NiceMock<MockInputWindowsManager> mockInputWindowsManager;
1374 EXPECT_CALL(mockInputWindowsManager, ReadJsonFile)
1375 .WillOnce(Return(""))
1376 .WillOnce(Return("not an object"))
1377 .WillOnce(Return(R"({"whiteList": "not an array"})"))
1378 .WillOnce(Return(R"({"whiteList": [123]})"))
1379 .WillOnce(Return(R"({"whiteList": [{"keyCode": 1}]})"))
1380 .WillOnce(Return(R"({"whiteList": [{"keyCode": "not a number", "pressedKey": 1}]})"));
1381 EXPECT_FALSE(inputWindowsManager->ParseJson(configFile));
1382 EXPECT_FALSE(inputWindowsManager->ParseJson(configFile));
1383 EXPECT_FALSE(inputWindowsManager->ParseJson(configFile));
1384 EXPECT_TRUE(inputWindowsManager->ParseJson(configFile));
1385 EXPECT_TRUE(inputWindowsManager->ParseJson(configFile));
1386 EXPECT_TRUE(inputWindowsManager->ParseJson(configFile));
1387 }
1388
1389 /* *
1390 * @tc.name: InputWindowsManagerOneTest_GetPidByWindowId_001
1391 * @tc.desc: Test the funcation GetPidByWindowId
1392 * @tc.type: FUNC
1393 * @tc.require:
1394 */
1395 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_GetPidByWindowId_001, TestSize.Level1)
1396 {
1397 CALL_TEST_DEBUG;
1398 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1399 int32_t id = 0;
1400 WindowInfo windowInfo;
1401 windowInfo.id = 1;
1402 windowInfo.windowInputType = WindowInputType::TRANSMIT_ANTI_AXIS_MOVE;
1403 WindowInfo winInfo;
1404 winInfo.id = id;
1405 windowInfo.uiExtentionWindowInfo.push_back(winInfo);
1406 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
1407 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
1408 it->second.windowsInfo.push_back(windowInfo);
1409 }
1410 EXPECT_EQ(inputWindowsManager->GetPidByWindowId(id), windowInfo.pid);
1411
1412 id = -1;
1413 EXPECT_EQ(inputWindowsManager->GetPidByWindowId(id), RET_ERR);
1414 }
1415
1416 #ifdef OHOS_BUILD_ENABLE_TOUCH
1417 /* *
1418 * @tc.name: InputWindowsManagerOneTest_CancelTouch_001
1419 * @tc.desc: Test the funcation CancelTouch
1420 * @tc.type: FUNC
1421 * @tc.require:
1422 */
1423 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_CancelTouch_001, TestSize.Level1)
1424 {
1425 CALL_TEST_DEBUG;
1426 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1427 int32_t touch = 1;
1428 WindowInfoEX winInfoEx;
1429 winInfoEx.flag = true;
1430 inputWindowsManager->touchItemDownInfos_.insert(std::make_pair(touch, winInfoEx));
1431 EXPECT_TRUE(inputWindowsManager->CancelTouch(touch));
1432
1433 EXPECT_FALSE(inputWindowsManager->CancelTouch(touch));
1434
1435 inputWindowsManager->touchItemDownInfos_.clear();
1436 EXPECT_FALSE(inputWindowsManager->CancelTouch(touch));
1437 }
1438
1439 /* *
1440 * @tc.name: InputWindowsManagerOneTest_CancelAllTouches_001
1441 * @tc.desc: Test the funcation CancelAllTouches
1442 * @tc.type: FUNC
1443 * @tc.require:
1444 */
1445 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_CancelAllTouches_001, TestSize.Level1)
1446 {
1447 CALL_TEST_DEBUG;
1448 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1449 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1450 ASSERT_NE(pointerEvent, nullptr);
1451 bool isDisplayChanged = true;
1452 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
1453 PointerEvent::PointerItem item;
1454 item.pressed_ = false;
1455 pointerEvent->pointers_.push_back(item);
1456
1457 item.pressed_ = true;
1458 inputWindowsManager->extraData_.appended = true;
1459 inputWindowsManager->extraData_.sourceType = PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
1460 item.pointerId_ = 1;
1461 inputWindowsManager->extraData_.pointerId = item.GetPointerId();
1462 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
1463 pointerEvent->pointers_.push_back(item);
1464 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->CancelAllTouches(pointerEvent, isDisplayChanged));
1465 }
1466
1467 /* *
1468 * @tc.name: InputWindowsManagerOneTest_CancelAllTouches_002
1469 * @tc.desc: Test the funcation CancelAllTouches
1470 * @tc.type: FUNC
1471 * @tc.require:
1472 */
1473 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_CancelAllTouches_002, TestSize.Level1)
1474 {
1475 CALL_TEST_DEBUG;
1476 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1477 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1478 ASSERT_NE(pointerEvent, nullptr);
1479 bool isDisplayChanged = true;
1480 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
1481 PointerEvent::PointerItem item;
1482 item.pressed_ = true;
1483 item.pointerId_ = 1;
1484 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
1485 inputWindowsManager->extraData_.appended = true;
1486 inputWindowsManager->extraData_.sourceType = PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
1487 inputWindowsManager->extraData_.pointerId = item.GetPointerId() + 1;
1488 pointerEvent->pointers_.push_back(item);
1489
1490 item.SetToolType(PointerEvent::TOOL_TYPE_PEN);
1491 inputWindowsManager->extraData_.pointerId = item.GetPointerId() + 1;
1492 pointerEvent->pointers_.push_back(item);
1493
1494 inputWindowsManager->extraData_.sourceType = PointerEvent::SOURCE_TYPE_UNKNOWN;
1495 pointerEvent->pointers_.push_back(item);
1496
1497 inputWindowsManager->extraData_.appended = false;
1498 pointerEvent->pointers_.push_back(item);
1499 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->CancelAllTouches(pointerEvent, isDisplayChanged));
1500 }
1501
1502 /* *
1503 * @tc.name: InputWindowsManagerOneTest_CalcDrawCoordinate_001
1504 * @tc.desc: Test the funcation CalcDrawCoordinate
1505 * @tc.type: FUNC
1506 * @tc.require:
1507 */
1508 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_CalcDrawCoordinate_001, TestSize.Level1)
1509 {
1510 CALL_TEST_DEBUG;
1511 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1512 OLD::DisplayInfo displayInfo;
1513 PointerEvent::PointerItem pointerItem;
1514 pointerItem.rawDisplayX_ = 0;
1515 pointerItem.rawDisplayY_ = 0;
1516 displayInfo.transform.push_back(1.0f);
1517 auto result = inputWindowsManager->CalcDrawCoordinate(displayInfo, pointerItem);
1518 EXPECT_EQ(result.first, 0);
1519 EXPECT_EQ(result.second, 0);
1520 }
1521
1522 /* *
1523 * @tc.name: InputWindowsManagerOneTest_GetWindowGroupInfoByDisplayIdCopy
1524 * @tc.desc: Test the funcation GetWindowGroupInfoByDisplayIdCopy
1525 * @tc.type: FUNC
1526 * @tc.require:
1527 */
1528 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_GetWindowGroupInfoByDisplayIdCopy, TestSize.Level1)
1529 {
1530 CALL_TEST_DEBUG;
1531 InputWindowsManager inputWindowsManager;
1532 WindowGroupInfo windowGroupInfo;
1533 int32_t displayId = 1;
1534 inputWindowsManager.windowsPerDisplay_.insert(std::make_pair(displayId, windowGroupInfo));
1535 inputWindowsManager.GetWindowGroupInfoByDisplayIdCopy(displayId);
1536 inputWindowsManager.windowsPerDisplay_.clear();
1537 inputWindowsManager.GetWindowGroupInfoByDisplayIdCopy(displayId);
1538 inputWindowsManager.windowsPerDisplayMap_.clear();
1539 EXPECT_TRUE(inputWindowsManager.GetWindowGroupInfoByDisplayIdCopy(displayId).empty());
1540 }
1541
1542 /* *
1543 * @tc.name: InputWindowsManagerOneTest_FindTargetDisplayGroupInfo
1544 * @tc.desc: Test the funcation FindTargetDisplayGroupInfo
1545 * @tc.type: FUNC
1546 * @tc.require:
1547 */
1548 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_FindTargetDisplayGroupInfo, TestSize.Level1)
1549 {
1550 CALL_TEST_DEBUG;
1551 InputWindowsManager inputWindowsManager;
1552 WindowGroupInfo windowGroupInfo;
1553 int32_t displayId = 1;
1554 OLD::DisplayInfo displayInfo1;
1555 displayInfo1.id = 0;
1556 displayInfo1.dpi = -10;
1557 displayInfo1.uniq = "default0";
1558 auto it = inputWindowsManager.displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
1559 if (it != inputWindowsManager.displayGroupInfoMap_.end()) {
1560 it->second.displaysInfo.push_back(displayInfo1);
1561 }
1562 inputWindowsManager.windowsPerDisplay_.insert(std::make_pair(displayId, windowGroupInfo));
1563 inputWindowsManager.FindTargetDisplayGroupInfo(0);
1564 displayId = 8;
1565 EXPECT_NO_FATAL_FAILURE(inputWindowsManager.FindTargetDisplayGroupInfo(8));
1566 }
1567
1568 /* *
1569 * @tc.name: InputWindowsManagerOneTest_SetDragFlagByPointer001
1570 * @tc.desc: Test the funcation SetDragFlagByPointer
1571 * @tc.type: FUNC
1572 * @tc.require:
1573 */
1574 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_SetDragFlagByPointer001, TestSize.Level1)
1575 {
1576 CALL_TEST_DEBUG;
1577 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1578 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1579 ASSERT_NE(pointerEvent, nullptr);
1580 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
1581 inputWindowsManager->SetDragFlagByPointer(pointerEvent);
1582 ASSERT_EQ(inputWindowsManager->dragFlag_, true);
1583 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
1584 inputWindowsManager->SetDragFlagByPointer(pointerEvent);
1585 ASSERT_EQ(inputWindowsManager->dragFlag_, false);
1586 }
1587
1588 /* *
1589 * @tc.name: InputWindowsManagerOneTest_ShiftAppTouchPointerEvent001
1590 * @tc.desc: Test the funcation ShiftAppTouchPointerEvent
1591 * @tc.type: FUNC
1592 * @tc.require:
1593 */
1594 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ShiftAppTouchPointerEvent001, TestSize.Level1)
1595 {
1596 CALL_TEST_DEBUG;
1597 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1598 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1599 ASSERT_NE(pointerEvent, nullptr);
1600 ShiftWindowInfo info;
1601 auto ret = inputWindowsManager->ShiftAppTouchPointerEvent(info);
1602 ASSERT_EQ(ret, RET_ERR);
1603 }
1604 #endif // OHOS_BUILD_ENABLE_TOUCH
1605
1606 /* *
1607 * @tc.name: InputWindowsManagerOneTest_PrintHighZorder_001
1608 * @tc.desc: Test the funcation PrintHighZorder
1609 * @tc.type: FUNC
1610 * @tc.require:
1611 */
1612 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_PrintHighZorder_001, TestSize.Level1)
1613 {
1614 CALL_TEST_DEBUG;
1615 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1616 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1617 ASSERT_NE(pointerEvent, nullptr);
1618 WindowInfo windowInfo;
1619 windowInfo.id = 2;
1620 windowInfo.flags = 0;
1621 windowInfo.pointerHotAreas = {
1622 {0, 0, 30, 40}
1623 };
1624 windowInfo.windowInputType = WindowInputType::NORMAL;
1625 std::vector<WindowInfo> windowsInfo = {windowInfo};
1626 pointerEvent->SetZOrder(1.0f);
1627 int32_t pointerAction = PointerEvent::POINTER_ACTION_AXIS_BEGIN;
1628 int32_t targetWindowId = 1;
1629 int32_t logicalX = 1;
1630 int32_t logicalY = 1;
1631 EXPECT_NO_FATAL_FAILURE(
1632 inputWindowsManager->PrintHighZorder(windowsInfo, pointerAction, targetWindowId, logicalX, logicalY));
1633 }
1634
1635 /* *
1636 * @tc.name: InputWindowsManagerOneTest_PrintHighZorder_002
1637 * @tc.desc: Test the funcation PrintHighZorder
1638 * @tc.type: FUNC
1639 * @tc.require:
1640 */
1641 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_PrintHighZorder_002, TestSize.Level1)
1642 {
1643 CALL_TEST_DEBUG;
1644 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1645 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1646 ASSERT_NE(pointerEvent, nullptr);
1647 WindowInfo windowInfo;
1648 windowInfo.id = 1;
1649 windowInfo.flags = 1;
1650 windowInfo.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
1651 std::vector<WindowInfo> windowsInfo = {windowInfo};
1652 pointerEvent->SetZOrder(1.0f);
1653 int32_t pointerAction = PointerEvent::POINTER_ACTION_AXIS_UPDATE;
1654 int32_t targetWindowId = 1;
1655 int32_t logicalX = 1;
1656 int32_t logicalY = 1;
1657 EXPECT_NO_FATAL_FAILURE(
1658 inputWindowsManager->PrintHighZorder(windowsInfo, pointerAction, targetWindowId, logicalX, logicalY));
1659 }
1660
1661 /* *
1662 * @tc.name: InputWindowsManagerOneTest_FindTargetDisplayGroupInfo_001
1663 * @tc.desc: Test the funcation FindTargetDisplayGroupInfo
1664 * @tc.type: FUNC
1665 * @tc.require:
1666 */
1667 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_FindTargetDisplayGroupInfo_001, TestSize.Level1)
1668 {
1669 CALL_TEST_DEBUG;
1670 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1671 OLD::DisplayInfo displayInfo;
1672 displayInfo.id = 0;
1673 int32_t displayId = 0;
1674 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
1675 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
1676 it->second.displaysInfo.push_back(displayInfo);
1677 }
1678 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->FindTargetDisplayGroupInfo(displayId));
1679 displayId = 1;
1680 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->FindTargetDisplayGroupInfo(displayId));
1681 }
1682
1683 /* *
1684 * @tc.name: InputWindowsManagerOneTest_IsPointerOnCenter_001
1685 * @tc.desc: Test the funcation IsPointerOnCenter
1686 * @tc.type: FUNC
1687 * @tc.require:
1688 */
1689 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_IsPointerOnCenter_001, TestSize.Level1)
1690 {
1691 CALL_TEST_DEBUG;
1692 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1693 OLD::DisplayInfo displayInfo;
1694 displayInfo.id = 1;
1695 displayInfo.validWidth = 1;
1696 displayInfo.validHeight = 1;
1697 CursorPosition currentPos;
1698 currentPos.cursorPos.x = 0.5;
1699 currentPos.cursorPos.y = 0.5;
1700 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->IsPointerOnCenter(currentPos, displayInfo));
1701 currentPos.cursorPos.x = 1;
1702 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->IsPointerOnCenter(currentPos, displayInfo));
1703 currentPos.cursorPos.x = 0.5;
1704 currentPos.cursorPos.y = 1;
1705 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->IsPointerOnCenter(currentPos, displayInfo));
1706 }
1707
1708 /* *
1709 * @tc.name: InputWindowsManagerOneTest_ShiftAppMousePointerEvent_002
1710 * @tc.desc: Test the funcation ShiftAppMousePointerEvent
1711 * @tc.type: FUNC
1712 * @tc.require:
1713 */
1714 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ShiftAppMousePointerEvent_002, TestSize.Level1)
1715 {
1716 CALL_TEST_DEBUG;
1717 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1718 ShiftWindowInfo shiftWindowInfo;
1719 bool autoGenDown = false;
1720 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1721 ASSERT_NE(pointerEvent, nullptr);
1722 pointerEvent->pressedButtons_.insert(1);
1723 inputWindowsManager->lastPointerEvent_ = pointerEvent;
1724 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ShiftAppMousePointerEvent(shiftWindowInfo, autoGenDown));
1725 autoGenDown = true;
1726 shiftWindowInfo.x = -1;
1727 shiftWindowInfo.y = -1;
1728 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ShiftAppMousePointerEvent(shiftWindowInfo, autoGenDown));
1729 shiftWindowInfo.x = 1;
1730 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ShiftAppMousePointerEvent(shiftWindowInfo, autoGenDown));
1731 shiftWindowInfo.x = -1;
1732 shiftWindowInfo.y = 1;
1733 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ShiftAppMousePointerEvent(shiftWindowInfo, autoGenDown));
1734 }
1735
1736 /* *
1737 * @tc.name: InputWindowsManagerOneTest_ShiftAppTouchPointerEvent002
1738 * @tc.desc: Test the funcation ShiftAppTouchPointerEvent
1739 * @tc.type: FUNC
1740 * @tc.require:
1741 */
1742 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ShiftAppTouchPointerEvent002, TestSize.Level1)
1743 {
1744 CALL_TEST_DEBUG;
1745 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1746 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1747 ASSERT_NE(pointerEvent, nullptr);
1748 inputWindowsManager->lastTouchEvent_ = pointerEvent;
1749 ShiftWindowInfo shiftWindowInfo;
1750 shiftWindowInfo.fingerId = -1;
1751 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ShiftAppTouchPointerEvent(shiftWindowInfo));
1752 shiftWindowInfo.fingerId = 1;
1753 pointerEvent->pointers_.clear();
1754 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ShiftAppTouchPointerEvent(shiftWindowInfo));
1755 PointerEvent::PointerItem item;
1756 int32_t pointerId = 0;
1757 item.SetPointerId(pointerId);
1758 pointerEvent->pointers_.push_back(item);
1759 item.pressed_ = true;
1760 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ShiftAppTouchPointerEvent(shiftWindowInfo));
1761 }
1762
1763 #ifdef OHOS_BUILD_ENABLE_KEYBOARD
1764 /**
1765 * @tc.name: InputWindowsManagerOneTest_ReissueEvent_005
1766 * @tc.desc: Verify ReissueEvent
1767 * @tc.type: FUNC
1768 * @tc.require:
1769 */
1770 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ReissueEvent_005, TestSize.Level1)
1771 {
1772 CALL_TEST_DEBUG;
1773 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
1774 ASSERT_NE(keyEvent, nullptr);
1775 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1776 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UNKNOWN);
1777 int32_t focusWindowId = -1;
1778 inputWindowsManager->focusWindowId_ = 0;
1779 keyEvent->SetRepeatKey(true);
1780
1781 std::shared_ptr<EventDispatchHandler> handler = std::make_shared<EventDispatchHandler>();
1782 NiceMock<MockInputWindowsManager> mockInputWindowsManager;
1783 UDSServer udServer;
1784 EXPECT_CALL(mockInputWindowsManager, GetEventDispatchHandler).WillRepeatedly(Return(handler));
1785 EXPECT_CALL(mockInputWindowsManager, GetUDSServer).WillRepeatedly(Return(&udServer));
1786 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ReissueEvent(keyEvent, focusWindowId));
1787 }
1788
1789 /**
1790 * @tc.name: InputWindowsManagerOneTest_ReissueEvent_006
1791 * @tc.desc: Verify ReissueEvent
1792 * @tc.type: FUNC
1793 * @tc.require:
1794 */
1795 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ReissueEvent_006, TestSize.Level1)
1796 {
1797 CALL_TEST_DEBUG;
1798 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
1799 ASSERT_NE(keyEvent, nullptr);
1800 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1801 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UNKNOWN);
1802 int32_t focusWindowId = -1;
1803 inputWindowsManager->focusWindowId_ = 0;
1804 keyEvent->SetRepeatKey(true);
1805
1806 std::shared_ptr<EventDispatchHandler> handler = std::make_shared<EventDispatchHandler>();
1807 NiceMock<MockInputWindowsManager> mockInputWindowsManager;
1808 EXPECT_CALL(mockInputWindowsManager, GetEventDispatchHandler).WillRepeatedly(Return(handler));
1809 EXPECT_CALL(mockInputWindowsManager, GetUDSServer).WillRepeatedly(Return(nullptr));
1810 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ReissueEvent(keyEvent, focusWindowId));
1811 }
1812
1813 /**
1814 * @tc.name: InputWindowsManagerOneTest_ReissueEvent_007
1815 * @tc.desc: Verify ReissueEvent
1816 * @tc.type: FUNC
1817 * @tc.require:
1818 */
1819 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ReissueEvent_007, TestSize.Level1)
1820 {
1821 CALL_TEST_DEBUG;
1822 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
1823 ASSERT_NE(keyEvent, nullptr);
1824 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1825 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UNKNOWN);
1826 int32_t focusWindowId = -1;
1827 inputWindowsManager->focusWindowId_ = 0;
1828 keyEvent->SetRepeatKey(true);
1829
1830 NiceMock<MockInputWindowsManager> mockInputWindowsManager;
1831 EXPECT_CALL(mockInputWindowsManager, GetEventDispatchHandler).WillRepeatedly(Return(nullptr));
1832 EXPECT_CALL(mockInputWindowsManager, GetUDSServer).WillRepeatedly(Return(nullptr));
1833 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ReissueEvent(keyEvent, focusWindowId));
1834 }
1835 #endif // OHOS_BUILD_ENABLE_KEYBOARD
1836
1837 /**
1838 * @tc.name: InputWindowsManagerOneTest_UpdateDisplayInfoExtIfNeed01
1839 * @tc.desc: Test UpdateDisplayInfoExtIfNeed
1840 * @tc.type: FUNC
1841 * @tc.require:
1842 */
1843 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_UpdateDisplayInfoExtIfNeed01, TestSize.Level0)
1844 {
1845 CALL_TEST_DEBUG;
1846 InputWindowsManager inputWindowsMgr;
1847 OLD::DisplayGroupInfo displayGroupInfo;
1848 OLD::DisplayInfo displayInfo;
1849 displayGroupInfo.displaysInfo.push_back(displayInfo);
1850 displayGroupInfo.groupId = -1;
1851 bool needUpdateDisplayExt = true;
1852 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.UpdateDisplayInfoExtIfNeed(displayGroupInfo, needUpdateDisplayExt));
1853 }
1854
1855 /**
1856 * @tc.name: InputWindowsManagerOneTest_GetMainScreenDisplayInfo
1857 * @tc.desc: Test GetMainScreenDisplayInfo
1858 * @tc.type: FUNC
1859 * @tc.require:
1860 */
1861 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_GetMainScreenDisplayInfo, TestSize.Level0)
1862 {
1863 CALL_TEST_DEBUG;
1864 InputWindowsManager inputWindowsMgr;
1865 std::vector<OLD::DisplayInfo> displaysInfo;
1866 OLD::DisplayInfo mainScreenDisplayInfo;
1867 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.GetMainScreenDisplayInfo(displaysInfo, mainScreenDisplayInfo));
1868 displaysInfo.push_back(mainScreenDisplayInfo);
1869 displaysInfo.push_back(mainScreenDisplayInfo);
1870 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.GetMainScreenDisplayInfo(displaysInfo, mainScreenDisplayInfo));
1871 }
1872
1873 /**
1874 * @tc.name: InputWindowsManagerOneTest_ResetPointerPosition
1875 * @tc.desc: Test ResetPointerPosition
1876 * @tc.type: FUNC
1877 * @tc.require:
1878 */
1879 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ResetPointerPosition, TestSize.Level0)
1880 {
1881 CALL_TEST_DEBUG;
1882 InputWindowsManager inputWindowsMgr;
1883 OLD::DisplayGroupInfo displayGroupInfo;
1884 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.ResetPointerPosition(displayGroupInfo));
1885 OLD::DisplayInfo currentDisplay;
1886 displayGroupInfo.displaysInfo.push_back(currentDisplay);
1887 displayGroupInfo.displaysInfo.push_back(currentDisplay);
1888 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.ResetPointerPosition(displayGroupInfo));
1889 }
1890
1891 /**
1892 * @tc.name: InputWindowsManagerOneTest_IsPointerOnCenter
1893 * @tc.desc: Test IsPointerOnCenter
1894 * @tc.type: FUNC
1895 * @tc.require:
1896 */
1897 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_IsPointerOnCenter, TestSize.Level0)
1898 {
1899 CALL_TEST_DEBUG;
1900 InputWindowsManager inputWindowsMgr;
1901 OLD::DisplayInfo currentDisplay;
1902 currentDisplay.validHeight = 2;
1903 currentDisplay.validWidth = 2;
1904 CursorPosition currentPos;
1905 currentPos.cursorPos.x = 1;
1906 currentPos.cursorPos.y = 1;
1907 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.IsPointerOnCenter(currentPos, currentDisplay));
1908 currentPos.cursorPos.y = 0;
1909 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.IsPointerOnCenter(currentPos, currentDisplay));
1910 currentPos.cursorPos.x = 0;
1911 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.IsPointerOnCenter(currentPos, currentDisplay));
1912 }
1913
1914 /**
1915 * @tc.name: InputWindowsManagerOneTest_ResetCursorPos
1916 * @tc.desc: Test ResetCursorPos
1917 * @tc.type: FUNC
1918 * @tc.require:
1919 */
1920 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ResetCursorPos, TestSize.Level0)
1921 {
1922 CALL_TEST_DEBUG;
1923 InputWindowsManager inputWindowsMgr;
1924 OLD::DisplayGroupInfo displayGroupInfo;
1925 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.ResetCursorPos(displayGroupInfo));
1926 OLD::DisplayInfo displayInfo;
1927 displayGroupInfo.displaysInfo.push_back(displayInfo);
1928 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.ResetCursorPos(displayGroupInfo));
1929 }
1930
1931 /**
1932 * @tc.name: InputWindowsManagerOneTest_IsPositionOutValidDisplay
1933 * @tc.desc: Test IsPositionOutValidDisplay
1934 * @tc.type: FUNC
1935 * @tc.require:
1936 */
1937 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_IsPositionOutValidDisplay, TestSize.Level0)
1938 {
1939 CALL_TEST_DEBUG;
1940 InputWindowsManager inputWindowsMgr;
1941 OLD::DisplayInfo currentDisplay;
1942 currentDisplay.validHeight = 2;
1943 currentDisplay.validWidth = 2;
1944 currentDisplay.height = 2;
1945 currentDisplay.width = 2;
1946 currentDisplay.offsetX = 0;
1947 currentDisplay.offsetY = 0;
1948 Coordinate2D position;
1949 position.x = 1;
1950 position.y = 1;
1951 currentDisplay.fixedDirection = DIRECTION90;
1952 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.IsPositionOutValidDisplay(position, currentDisplay, true));
1953 currentDisplay.fixedDirection = DIRECTION180;
1954 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.IsPositionOutValidDisplay(position, currentDisplay, true));
1955 currentDisplay.fixedDirection = DIRECTION270;
1956 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.IsPositionOutValidDisplay(position, currentDisplay, true));
1957 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.IsPositionOutValidDisplay(position, currentDisplay, false));
1958 }
1959
1960 /* *
1961 * @tc.name: InputWindowsManagerOneTest_ProcessTouchTracking
1962 * @tc.desc: Test the funcation ProcessTouchTracking
1963 * @tc.type: FUNC
1964 * @tc.require:
1965 */
1966 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ProcessTouchTracking, TestSize.Level1)
1967 {
1968 CALL_TEST_DEBUG;
1969 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
1970 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1971 ASSERT_NE(pointerEvent, nullptr);
1972 PointerEvent::PointerItem pointerItem;
1973 pointerItem.SetDisplayXPos(0.0);
1974 pointerItem.SetDisplayYPos(0.0);
1975 WindowInfo targetWindow;
1976 targetWindow.id = 1;
1977 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_HOVER_MOVE);
1978 pointerEvent->targetWindowId_ = 1;
1979 pointerEvent->pointers_.clear();
1980 pointerItem.SetPointerId(1);
1981 pointerEvent->pointers_.push_back(pointerItem);
1982 EXPECT_EQ(pointerEvent->GetPointerCount(), 1);
1983 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ProcessTouchTracking(pointerEvent, targetWindow));
1984
1985 pointerEvent->SetTargetWindowId(targetWindow.id);
1986 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ProcessTouchTracking(pointerEvent, targetWindow));
1987
1988 targetWindow.id = -1;
1989 pointerEvent->pointers_.clear();
1990 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ProcessTouchTracking(pointerEvent, targetWindow));
1991 }
1992
1993 /* *
1994 * @tc.name: InputWindowsManagerOneTest_ClearMouseHideFlag
1995 * @tc.desc: Test the funcation ClearMouseHideFlag
1996 * @tc.type: FUNC
1997 * @tc.require:
1998 */
1999 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ClearMouseHideFlag, TestSize.Level1)
2000 {
2001 CALL_TEST_DEBUG;
2002 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2003 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2004 ASSERT_NE(pointerEvent, nullptr);
2005 auto eventId = -1;
2006 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
2007 pointerEvent->SetPointerId(eventId);
2008 inputWindowsManager->lastPointerEvent_ = pointerEvent;
2009 EXPECT_EQ(pointerEvent->GetId(), eventId);
2010 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ClearMouseHideFlag(eventId));
2011 eventId = 1;
2012 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ClearMouseHideFlag(eventId));
2013 }
2014
2015 /* *
2016 * @tc.name: InputWindowsManagerOneTest_IsAccessibilityEventWithZorderInjected
2017 * @tc.desc: Test the funcation IsAccessibilityEventWithZorderInjected
2018 * @tc.type: FUNC
2019 * @tc.require:
2020 */
2021 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_IsAccessibilityEventWithZorderInjected, TestSize.Level1)
2022 {
2023 CALL_TEST_DEBUG;
2024 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2025 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2026 ASSERT_NE(pointerEvent, nullptr);
2027 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_HOVER_ENTER);
2028 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE;
2029 pointerEvent->SetZOrder(1.0f);
2030 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->IsAccessibilityEventWithZorderInjected(pointerEvent));
2031 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
2032 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->IsAccessibilityEventWithZorderInjected(pointerEvent));
2033 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_HOVER_ENTER);
2034 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_ACCESSIBILITY;
2035 pointerEvent->SetZOrder(0.0f);
2036 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->IsAccessibilityEventWithZorderInjected(pointerEvent));
2037 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE;
2038 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->IsAccessibilityEventWithZorderInjected(pointerEvent));
2039 }
2040
2041 /**
2042 * @tc.name: InputWindowsManagerTest_SendCancelEventWhenLock
2043 * @tc.desc: Test the funcation SendCancelEventWhenLock
2044 * @tc.type: FUNC
2045 * @tc.require:
2046 */
2047 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerTest_SendCancelEventWhenLock, TestSize.Level1)
2048 {
2049 CALL_TEST_DEBUG;
2050 InputWindowsManager inputWindowsMgr;
2051 inputWindowsMgr.lastTouchEventOnBackGesture_ = PointerEvent::Create();
2052 ASSERT_NE(inputWindowsMgr.lastTouchEventOnBackGesture_, nullptr);
2053 InputHandler->eventNormalizeHandler_ = std::make_shared<EventNormalizeHandler>();
2054 EXPECT_NE(InputHandler->eventNormalizeHandler_, nullptr);
2055 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.SendCancelEventWhenLock());
2056 inputWindowsMgr.lastTouchEventOnBackGesture_->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
2057 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.SendCancelEventWhenLock());
2058 inputWindowsMgr.lastTouchEventOnBackGesture_->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
2059 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.SendCancelEventWhenLock());
2060 inputWindowsMgr.lastTouchEventOnBackGesture_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
2061 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.SendCancelEventWhenLock());
2062 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2063 ASSERT_NE(pointerEvent, nullptr);
2064 WindowInfoEX windowInfoEX;
2065 windowInfoEX.flag = true;
2066 pointerEvent->SetPointerId(1);
2067
2068 inputWindowsMgr.touchItemDownInfos_.insert(std::make_pair(pointerEvent->GetPointerId(), windowInfoEX));
2069 inputWindowsMgr.lastTouchEventOnBackGesture_->SetPointerId(2);
2070 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.SendCancelEventWhenLock());
2071 inputWindowsMgr.lastTouchEventOnBackGesture_->SetPointerId(1);
2072 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.SendCancelEventWhenLock());
2073 }
2074
2075 /* *
2076 * @tc.name: InputWindowsManagerOneTest_ProcessInjectEventGlobalXY
2077 * @tc.desc: Test the funcation ProcessInjectEventGlobalXY
2078 * @tc.type: FUNC
2079 * @tc.require:
2080 */
2081 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ProcessInjectEventGlobalXY, TestSize.Level1)
2082 {
2083 CALL_TEST_DEBUG;
2084 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2085 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2086 PointerEvent::PointerItem pointerItem;
2087 pointerItem.SetGlobalX(DBL_MAX);
2088 pointerItem.SetGlobalY(DBL_MAX);
2089 ASSERT_NE(pointerEvent, nullptr);
2090 pointerEvent->ClearFlag();
2091 int32_t useCoordinate = 0;
2092 auto pointerId = 1;
2093 OLD::DisplayInfo displayInfo;
2094 displayInfo.offsetX = 0;
2095 displayInfo.offsetY = 0;
2096 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
2097 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
2098 it->second.displaysInfo.push_back(displayInfo);
2099 }
2100 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ProcessInjectEventGlobalXY(pointerEvent, useCoordinate));
2101
2102 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE;
2103 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ProcessInjectEventGlobalXY(pointerEvent, useCoordinate));
2104 useCoordinate = 1;
2105 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ProcessInjectEventGlobalXY(pointerEvent, useCoordinate));
2106
2107 pointerItem.SetPointerId(pointerId);
2108 pointerEvent->pointers_.push_back(pointerItem);
2109 EXPECT_EQ(pointerEvent->GetPointerCount(), pointerId);
2110 pointerEvent->SetPointerId(pointerId);
2111 EXPECT_TRUE(pointerEvent->GetPointerItem(pointerId, pointerItem));
2112 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ProcessInjectEventGlobalXY(pointerEvent, useCoordinate));
2113
2114 auto globalValue = 15.00;
2115 pointerEvent->pointers_.clear();
2116 pointerItem.SetGlobalX(globalValue);
2117 pointerEvent->pointers_.push_back(pointerItem);
2118 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ProcessInjectEventGlobalXY(pointerEvent, useCoordinate));
2119
2120 pointerEvent->pointers_.clear();
2121 pointerItem.SetGlobalX(globalValue);
2122 pointerItem.SetGlobalY(globalValue);
2123 pointerEvent->pointers_.push_back(pointerItem);
2124 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ProcessInjectEventGlobalXY(pointerEvent, useCoordinate));
2125
2126 globalValue = -15.00;
2127 pointerEvent->pointers_.clear();
2128 pointerItem.SetGlobalX(globalValue);
2129 pointerEvent->pointers_.push_back(pointerItem);
2130 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ProcessInjectEventGlobalXY(pointerEvent, useCoordinate));
2131 }
2132
2133 /**
2134 * @tc.name: InputWindowsManagerOneTest_GetMainScreenDisplayInfo_001
2135 * @tc.desc: Test GetMainScreenDisplayInfo
2136 * @tc.type: FUNC
2137 * @tc.require:
2138 */
2139 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_GetMainScreenDisplayInfo_001, TestSize.Level0)
2140 {
2141 CALL_TEST_DEBUG;
2142 InputWindowsManager inputWindowsMgr;
2143 std::vector<OLD::DisplayInfo> displaysInfo;
2144 OLD::DisplayInfo mainScreenDisplayInfo;
2145 mainScreenDisplayInfo.id = 100;
2146 mainScreenDisplayInfo.uniq = "uniq";
2147 mainScreenDisplayInfo.validHeight = 2;
2148 mainScreenDisplayInfo.validWidth = 2;
2149 mainScreenDisplayInfo.height = 2;
2150 mainScreenDisplayInfo.width = 2;
2151 mainScreenDisplayInfo.offsetX = 0;
2152 mainScreenDisplayInfo.offsetY = 0;
2153 mainScreenDisplayInfo.displaySourceMode = OHOS::MMI::DisplaySourceMode::SCREEN_MIRROR;
2154 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.GetMainScreenDisplayInfo(displaysInfo, mainScreenDisplayInfo));
2155 displaysInfo.push_back(mainScreenDisplayInfo);
2156 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.GetMainScreenDisplayInfo(displaysInfo, mainScreenDisplayInfo));
2157 displaysInfo.clear();
2158 mainScreenDisplayInfo.displaySourceMode = OHOS::MMI::DisplaySourceMode::SCREEN_MAIN;
2159 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.GetMainScreenDisplayInfo(displaysInfo, mainScreenDisplayInfo));
2160 }
2161
2162 /**
2163 * @tc.name: InputWindowsManagerOneTest_ResetPointerPosition_001
2164 * @tc.desc: Test ResetPointerPosition
2165 * @tc.type: FUNC
2166 * @tc.require:
2167 */
2168 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ResetPointerPosition_001, TestSize.Level0)
2169 {
2170 CALL_TEST_DEBUG;
2171 InputWindowsManager inputWindowsMgr;
2172 OLD::DisplayGroupInfo displayGroupInfo;
2173 OLD::DisplayInfo currentDisplay;
2174 auto it = inputWindowsMgr.displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
2175 if (it != inputWindowsMgr.displayGroupInfoMap_.end()) {
2176 it->second.displaysInfo.push_back(currentDisplay);
2177 }
2178 displayGroupInfo.displaysInfo.push_back(currentDisplay);
2179 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.ResetPointerPosition(displayGroupInfo));
2180 currentDisplay.id = 1;
2181 currentDisplay.width = 500;
2182 currentDisplay.height = 500;
2183 currentDisplay.displayDirection = DIRECTION0;
2184 currentDisplay.displaySourceMode = OHOS::MMI::DisplaySourceMode::SCREEN_MIRROR;
2185 displayGroupInfo.displaysInfo.clear();
2186 it->second.displaysInfo.clear();
2187 displayGroupInfo.displaysInfo.push_back(currentDisplay);
2188 it->second.displaysInfo.push_back(currentDisplay);
2189 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.ResetPointerPosition(displayGroupInfo));
2190 displayGroupInfo.displaysInfo.clear();
2191 it->second.displaysInfo.clear();
2192 CursorPosition cursorPosCur;
2193 cursorPosCur.cursorPos.x = 1;
2194 cursorPosCur.cursorPos.y = 1;
2195 inputWindowsMgr.cursorPosMap_[0] = cursorPosCur;
2196 currentDisplay.displayDirection = DIRECTION90;
2197 currentDisplay.displaySourceMode = OHOS::MMI::DisplaySourceMode::SCREEN_MAIN;
2198 currentDisplay.rsId = 1;
2199 it->second.displaysInfo.push_back(currentDisplay);
2200 currentDisplay.rsId = 0;
2201 displayGroupInfo.displaysInfo.push_back(currentDisplay);
2202 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.ResetPointerPosition(displayGroupInfo));
2203 }
2204
2205 /* *
2206 * @tc.name: InputWindowsManagerOneTest_GetWindowGroupInfoByDisplayIdCopy1
2207 * @tc.desc: Test the funcation GetWindowGroupInfoByDisplayIdCopy
2208 * @tc.type: FUNC
2209 * @tc.require:
2210 */
2211 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_GetWindowGroupInfoByDisplayIdCopy1, TestSize.Level0)
2212 {
2213 CALL_TEST_DEBUG;
2214
2215 int32_t displayId = 1;
2216 int32_t groupId = 1003;
2217
2218 OLD::DisplayInfo displayInfo = {};
2219 displayInfo.id = displayId;
2220
2221 OLD::DisplayGroupInfo displayGroupInfo = {};
2222 displayGroupInfo.groupId = groupId;
2223 displayGroupInfo.displaysInfo.push_back(displayInfo);
2224
2225 InputWindowsManager inputWindowsManager;
2226 inputWindowsManager.displayGroupInfoMap_.insert(std::make_pair(groupId, displayGroupInfo));
2227
2228 WindowGroupInfo windowGroupInfo;
2229 windowGroupInfo.windowsInfo.clear();
2230 inputWindowsManager.windowsPerDisplay_.insert(std::make_pair(displayId, windowGroupInfo));
2231 inputWindowsManager.GetWindowGroupInfoByDisplayIdCopy(displayId);
2232 inputWindowsManager.windowsPerDisplay_.clear();
2233 inputWindowsManager.GetWindowGroupInfoByDisplayIdCopy(displayId);
2234 inputWindowsManager.windowsPerDisplayMap_.clear();
2235 EXPECT_TRUE(inputWindowsManager.GetWindowGroupInfoByDisplayIdCopy(displayId).empty());
2236 }
2237
2238 /**
2239 * @tc.name: InputWindowsManagerOneTest_GetWindowGroupInfoByDisplayId1
2240 * @tc.desc: Test GetWindowGroupInfoByDisplayId
2241 * @tc.type: FUNC
2242 * @tc.require:
2243 */
2244 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_GetWindowGroupInfoByDisplayId1, TestSize.Level0)
2245 {
2246 CALL_TEST_DEBUG;
2247 int32_t displayId = 1;
2248 int32_t groupId = 1003;
2249
2250 OLD::DisplayInfo displayInfo = {};
2251 displayInfo.id = displayId;
2252
2253 OLD::DisplayGroupInfo displayGroupInfo = {};
2254 displayGroupInfo.groupId = groupId;
2255 displayGroupInfo.displaysInfo.push_back(displayInfo);
2256
2257 InputWindowsManager inputWindowsManager;
2258 inputWindowsManager.displayGroupInfoMap_.insert(std::make_pair(groupId, displayGroupInfo));
2259
2260 WindowGroupInfo windowGroupInfo;
2261
2262 inputWindowsManager.windowsPerDisplay_.insert(std::make_pair(displayId, windowGroupInfo));
2263 EXPECT_TRUE(inputWindowsManager.GetWindowGroupInfoByDisplayId(displayId).empty());
2264
2265 WindowInfo windowInfo;
2266 displayId = 2;
2267 windowInfo.id = 1;
2268 windowGroupInfo.windowsInfo.push_back(windowInfo);
2269 inputWindowsManager.windowsPerDisplay_.insert(std::make_pair(displayId, windowGroupInfo));
2270 EXPECT_FALSE(!inputWindowsManager.GetWindowGroupInfoByDisplayId(displayId).empty());
2271 }
2272
2273 /**
2274 * @tc.name: InputWindowsManagerOneTest_GetCancelEventFlag1
2275 * @tc.desc: Test the funcation GetCancelEventFlag
2276 * @tc.type: FUNC
2277 * @tc.require:
2278 */
2279 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_GetCancelEventFlag1, TestSize.Level0)
2280 {
2281 CALL_TEST_DEBUG;
2282 InputWindowsManager inputWindowsManager;
2283 auto pointerEvent = PointerEvent::Create();
2284 ASSERT_NE(pointerEvent, nullptr);
2285 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
2286 pointerEvent->bitwise_ = 0x00000080;
2287 EXPECT_TRUE(inputWindowsManager.GetCancelEventFlag(pointerEvent));
2288 pointerEvent->bitwise_ = 0x00000100;
2289 EXPECT_TRUE(inputWindowsManager.GetCancelEventFlag(pointerEvent));
2290 }
2291
2292 /**
2293 * @tc.name: InputWindowsManagerOneTest_ClearMouseHideFlag001
2294 * @tc.desc: Test ClearMouseHideFlag
2295 * @tc.type: FUNC
2296 * @tc.require:
2297 */
2298 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ClearMouseHideFlag001, TestSize.Level0)
2299 {
2300 CALL_TEST_DEBUG;
2301 InputWindowsManager inputWindowsMgr;
2302 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2303 EXPECT_NE(pointerEvent, nullptr);
2304 inputWindowsMgr.lastPointerEvent_ = pointerEvent;
2305 auto eventId = 100;
2306 inputWindowsMgr.lastPointerEvent_->SetId(eventId);
2307 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.ClearMouseHideFlag(eventId));
2308 eventId = 200;
2309 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.ClearMouseHideFlag(eventId));
2310 }
2311
2312 /**
2313 * @tc.name: InputWindowsManagerOneTest_SendBackCenterPointerEevent
2314 * @tc.desc: Test BypassChainAndDispatchDirectly
2315 * @tc.type: FUNC
2316 * @tc.require:
2317 */
2318 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_SendBackCenterPointerEevent, TestSize.Level0)
2319 {
2320 CALL_TEST_DEBUG;
2321 InputWindowsManager inputWindowsMgr;
2322 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2323 EXPECT_NE(pointerEvent, nullptr);
2324 inputWindowsMgr.lastPointerEvent_ = pointerEvent;
2325 CursorPosition currentPos;
2326 currentPos.cursorPos.x = 1;
2327 currentPos.cursorPos.y = 1;
2328 EXPECT_NO_FATAL_FAILURE(inputWindowsMgr.SendBackCenterPointerEevent(currentPos));
2329 }
2330
2331 /* *
2332 * @tc.name: InputWindowsManagerOneTest_DispatchTouch_002
2333 * @tc.desc: Test the funcation DispatchTouch
2334 * @tc.type: FUNC
2335 * @tc.require:
2336 */
2337 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_DispatchTouch_002, TestSize.Level1)
2338 {
2339 CALL_TEST_DEBUG;
2340 int32_t pointerAction = PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW;
2341 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2342 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2343 ASSERT_NE(pointerEvent, nullptr);
2344 UDSServer udsServer;
2345 inputWindowsManager->udsServer_ = &udsServer;
2346 inputWindowsManager->lastTouchEvent_ = pointerEvent;
2347 auto pointerId = 1;
2348 PointerEvent::PointerItem pointerItem;
2349 pointerItem.SetGlobalX(DBL_MAX);
2350 pointerItem.SetGlobalY(DBL_MAX);
2351 WindowInfo windowInfo;
2352 windowInfo.id = 1;
2353 windowInfo.flags = 0;
2354 windowInfo.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
2355 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
2356 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
2357 it->second.windowsInfo.push_back(windowInfo);
2358 }
2359 inputWindowsManager->lastTouchEvent_->SetPointerId(pointerId);
2360 pointerItem.SetPointerId(pointerId);
2361 inputWindowsManager->lastTouchEvent_->pointers_.push_back(pointerItem);
2362 auto fixedMode = PointerEvent::FixedMode::NORMAL;
2363 inputWindowsManager->lastTouchEvent_->SetFixedMode(fixedMode);
2364 inputWindowsManager->lastTouchWindowInfo_.windowInputType = WindowInputType::MIX_BUTTOM_ANTI_AXIS_MOVE;
2365 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->DispatchTouch(pointerAction));
2366 inputWindowsManager->lastTouchWindowInfo_.windowInputType = WindowInputType::DUALTRIGGER_TOUCH;
2367 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->DispatchTouch(pointerAction));
2368 inputWindowsManager->lastTouchWindowInfo_.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
2369 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->DispatchTouch(pointerAction));
2370
2371 inputWindowsManager->lastTouchWindowInfo_.windowInputType = WindowInputType::NORMAL;
2372 inputWindowsManager->lastTouchWindowInfo_.transform.clear();
2373 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->DispatchTouch(pointerAction));
2374 float pointerChangeAreasCount = 8;
2375 inputWindowsManager->lastTouchWindowInfo_.transform.push_back(pointerChangeAreasCount);
2376 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->DispatchTouch(pointerAction));
2377 }
2378
2379 /* *
2380 * @tc.name: InputWindowsManagerOneTest_ChangeWindowArea
2381 * @tc.desc: Test the funcation ChangeWindowArea
2382 * @tc.type: FUNC
2383 * @tc.require:
2384 */
2385 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ChangeWindowArea, TestSize.Level1)
2386 {
2387 CALL_TEST_DEBUG;
2388 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2389 ASSERT_NE(inputWindowsManager, nullptr);
2390 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2391 ASSERT_NE(pointerEvent, nullptr);
2392 UDSServer udsServer;
2393 inputWindowsManager->udsServer_ = &udsServer;
2394 inputWindowsManager->lastTouchEvent_ = pointerEvent;
2395 auto pointerId = 1;
2396 PointerEvent::PointerItem pointerItem;
2397 pointerItem.SetGlobalX(DBL_MAX);
2398 pointerItem.SetGlobalY(DBL_MAX);
2399 int32_t x = 100;
2400 int32_t y = 200;
2401 WindowInfo windowInfo;
2402 windowInfo.id = 1;
2403 windowInfo.flags = 0;
2404 windowInfo.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
2405 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
2406 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
2407 it->second.windowsInfo.push_back(windowInfo);
2408 }
2409 inputWindowsManager->lastTouchEvent_->SetPointerId(pointerId);
2410 pointerItem.SetPointerId(pointerId);
2411 inputWindowsManager->lastTouchEvent_->pointers_.push_back(pointerItem);
2412 auto fixedMode = PointerEvent::FixedMode::NORMAL;
2413 inputWindowsManager->lastTouchEvent_->SetFixedMode(fixedMode);
2414 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ChangeWindowArea(x, y, windowInfo));
2415 }
2416
2417 /**
2418 * @tc.name: InputWindowsManagerOneTest_SendBackCenterPointerEevent_001
2419 * @tc.desc: Test SendBackCenterPointerEevent
2420 * @tc.type: FUNC
2421 * @tc.require:
2422 */
2423 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_SendBackCenterPointerEevent_001, TestSize.Level0)
2424 {
2425 CALL_TEST_DEBUG;
2426 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2427 ASSERT_NE(pointerEvent, nullptr);
2428 pointerEvent->SetTargetDisplayId(-1);
2429 pointerEvent->SetTargetWindowId(1);
2430 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP);
2431 pointerEvent->SetDeviceId(CAST_INPUT_DEVICEID);
2432 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE;
2433 WindowInfo windowInfo;
2434 windowInfo.id = 1;
2435 windowInfo.flags = 0;
2436 windowInfo.pointerHotAreas = {
2437 {0, 0, 30, 40}
2438 };
2439 windowInfo.windowInputType = WindowInputType::NORMAL;
2440 windowInfo.isSkipSelfWhenShowOnVirtualScreen = true;
2441 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2442 inputWindowsManager->lastTouchEvent_ = pointerEvent;
2443 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
2444 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
2445 it->second.windowsInfo.push_back(windowInfo);
2446 }
2447 inputWindowsManager->firstBtnDownWindowInfo_.first = -1;
2448 inputWindowsManager->isOpenPrivacyProtectionserver_ = true;
2449 inputWindowsManager->privacyProtection_.isOpen = false;
2450 inputWindowsManager->extraData_.appended = true;
2451 inputWindowsManager->extraData_.sourceType = PointerEvent::SOURCE_TYPE_MOUSE;
2452 std::unique_ptr<Media::PixelMap> pixelMap = nullptr;
2453 inputWindowsManager->transparentWins_.insert_or_assign(windowInfo.id, std::move(pixelMap));
2454 CursorPosition currentPos;
2455 currentPos.cursorPos.x = 1;
2456 currentPos.cursorPos.y = 1;
2457 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->SendBackCenterPointerEevent(currentPos));
2458
2459 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
2460 inputWindowsManager->lastTouchEvent_ = pointerEvent;
2461 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->SendBackCenterPointerEevent(currentPos));
2462
2463 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_MOVE);
2464 inputWindowsManager->lastTouchEvent_ = pointerEvent;
2465 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->SendBackCenterPointerEevent(currentPos));
2466 }
2467
2468 /**
2469 * @tc.name: InputWindowsManagerOneTest_HandleWindowPositionChange
2470 * @tc.desc: Test HandleWindowPositionChange
2471 * @tc.type: FUNC
2472 * @tc.require:
2473 */
2474 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_HandleWindowPositionChange, TestSize.Level0)
2475 {
2476 CALL_TEST_DEBUG;
2477 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2478 ASSERT_NE(pointerEvent, nullptr);
2479 OLD::DisplayGroupInfo displayGroupInfo;
2480 displayGroupInfo.focusWindowId = 1;
2481
2482 OLD::DisplayInfo displayInfo1;
2483 displayInfo1.id = 1;
2484 displayInfo1.x = 1;
2485 displayInfo1.y = 1;
2486 displayInfo1.width = 2;
2487 displayInfo1.height = 2;
2488 displayInfo1.dpi = 240;
2489 displayInfo1.name = "pp";
2490 displayInfo1.direction = DIRECTION0;
2491 displayInfo1.displaySourceMode = OHOS::MMI::DisplaySourceMode::SCREEN_MAIN;
2492
2493 OLD::DisplayInfo displayInfo2;
2494 displayInfo2.id = 2;
2495 displayInfo2.x = 1;
2496 displayInfo2.y = 1;
2497 displayInfo2.width = 2;
2498 displayInfo2.height = 2;
2499 displayInfo2.dpi = 240;
2500 displayInfo2.name = "pp";
2501 displayInfo2.uniq = "pp";
2502 displayInfo2.direction = DIRECTION0;
2503 displayInfo2.displaySourceMode = OHOS::MMI::DisplaySourceMode::SCREEN_EXPAND;
2504 displayGroupInfo.displaysInfo.push_back(displayInfo2);
2505 displayGroupInfo.displaysInfo.push_back(displayInfo1);
2506 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2507 pointerEvent->SetTargetDisplayId(-1);
2508 pointerEvent->SetTargetWindowId(1);
2509 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP);
2510 pointerEvent->SetDeviceId(CAST_INPUT_DEVICEID);
2511 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE;
2512 inputWindowsManager->lastTouchEvent_ = pointerEvent;
2513 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->HandleWindowPositionChange(displayGroupInfo));
2514 }
2515
2516 /* *
2517 * @tc.name: InputWindowsManagerOneTest_PrintZorderInfo
2518 * @tc.desc: Test the funcation PrintZorderInfo
2519 * @tc.type: FUNC
2520 * @tc.require:
2521 */
2522 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_PrintZorderInfo, TestSize.Level1)
2523 {
2524 CALL_TEST_DEBUG;
2525 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2526 ASSERT_NE(inputWindowsManager, nullptr);
2527 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2528 ASSERT_NE(pointerEvent, nullptr);
2529 UDSServer udsServer;
2530 inputWindowsManager->udsServer_ = &udsServer;
2531 inputWindowsManager->lastTouchEvent_ = pointerEvent;
2532 auto pointerId = 1;
2533 PointerEvent::PointerItem pointerItem;
2534 pointerItem.SetGlobalX(DBL_MAX);
2535 pointerItem.SetGlobalY(DBL_MAX);
2536 WindowInfo windowInfo;
2537 windowInfo.id = 1;
2538 windowInfo.flags = 0;
2539 windowInfo.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
2540
2541 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
2542 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
2543 it->second.windowsInfo.push_back(windowInfo);
2544 }
2545 inputWindowsManager->lastTouchEvent_->SetPointerId(pointerId);
2546 pointerItem.SetPointerId(pointerId);
2547 inputWindowsManager->lastTouchEvent_->pointers_.push_back(pointerItem);
2548 auto fixedMode = PointerEvent::FixedMode::NORMAL;
2549 inputWindowsManager->lastTouchEvent_->SetFixedMode(fixedMode);
2550 std::string windowPrint;
2551 windowPrint += StringPrintf("highZorder");
2552 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->PrintZorderInfo(windowInfo, windowPrint));
2553 }
2554
2555 /* *
2556 * @tc.name: InputWindowsManagerOneTest_PrintWindowGroupInfo
2557 * @tc.desc: Test the funcation PrintWindowGroupInfo
2558 * @tc.type: FUNC
2559 * @tc.require:
2560 */
2561 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_PrintWindowGroupInfo, TestSize.Level1)
2562 {
2563 CALL_TEST_DEBUG;
2564 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2565 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2566 ASSERT_NE(pointerEvent, nullptr);
2567 UDSServer udsServer;
2568 inputWindowsManager->udsServer_ = &udsServer;
2569 inputWindowsManager->lastTouchEvent_ = pointerEvent;
2570 auto pointerId = 1;
2571 PointerEvent::PointerItem pointerItem;
2572 pointerItem.SetGlobalX(DBL_MAX);
2573 pointerItem.SetGlobalY(DBL_MAX);
2574 WindowInfo windowInfo;
2575 windowInfo.id = 1;
2576 windowInfo.flags = 0;
2577 windowInfo.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
2578
2579 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
2580 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
2581 it->second.windowsInfo.push_back(windowInfo);
2582 }
2583 inputWindowsManager->lastTouchEvent_->SetPointerId(pointerId);
2584 pointerItem.SetPointerId(pointerId);
2585 inputWindowsManager->lastTouchEvent_->pointers_.push_back(pointerItem);
2586 auto fixedMode = PointerEvent::FixedMode::NORMAL;
2587 inputWindowsManager->lastTouchEvent_->SetFixedMode(fixedMode);
2588 WindowGroupInfo windowGroupInfo;
2589 windowGroupInfo.windowsInfo.push_back(windowInfo);
2590 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->PrintWindowGroupInfo(windowGroupInfo));
2591 }
2592
2593 /**
2594 * @tc.name: InputWindowsManagerOneTest_PrintDisplayGroupInfo
2595 * @tc.desc: Test PrintDisplayGroupInfo
2596 * @tc.type: FUNC
2597 * @tc.require:
2598 */
2599 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_PrintDisplayGroupInfo, TestSize.Level0)
2600 {
2601 CALL_TEST_DEBUG;
2602 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2603 ASSERT_NE(pointerEvent, nullptr);
2604 OLD::DisplayGroupInfo displayGroupInfo;
2605 displayGroupInfo.focusWindowId = 1;
2606
2607 OLD::DisplayInfo displayInfo1;
2608 displayInfo1.id = 1;
2609 displayInfo1.x = 1;
2610 displayInfo1.y = 1;
2611 displayInfo1.width = 2;
2612 displayInfo1.height = 2;
2613 displayInfo1.dpi = 240;
2614 displayInfo1.name = "pp";
2615 displayInfo1.direction = DIRECTION0;
2616 displayInfo1.displaySourceMode = OHOS::MMI::DisplaySourceMode::SCREEN_MAIN;
2617
2618 OLD::DisplayInfo displayInfo2;
2619 displayInfo2.id = 2;
2620 displayInfo2.x = 1;
2621 displayInfo2.y = 1;
2622 displayInfo2.width = 2;
2623 displayInfo2.height = 2;
2624 displayInfo2.dpi = 240;
2625 displayInfo2.name = "pp";
2626 displayInfo2.uniq = "pp";
2627 displayInfo2.direction = DIRECTION0;
2628 displayInfo2.displaySourceMode = OHOS::MMI::DisplaySourceMode::SCREEN_EXPAND;
2629 displayGroupInfo.displaysInfo.push_back(displayInfo2);
2630 displayGroupInfo.displaysInfo.push_back(displayInfo1);
2631 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2632 pointerEvent->SetTargetDisplayId(-1);
2633 pointerEvent->SetTargetWindowId(1);
2634 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP);
2635 pointerEvent->SetDeviceId(CAST_INPUT_DEVICEID);
2636 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE;
2637 inputWindowsManager->lastTouchEvent_ = pointerEvent;
2638 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->PrintDisplayGroupInfo(displayGroupInfo));
2639 }
2640
2641 /**
2642 * @tc.name: InputWindowsManagerOneTest_Dump
2643 * @tc.desc: Test the dump function of the input window manager
2644 * @tc.type: FUNC
2645 * @tc.require:
2646 */
2647 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_Dump, TestSize.Level1)
2648 {
2649 CALL_TEST_DEBUG;
2650 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2651 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2652 ASSERT_NE(pointerEvent, nullptr);
2653 UDSServer udsServer;
2654 inputWindowsManager->udsServer_ = &udsServer;
2655 inputWindowsManager->lastTouchEvent_ = pointerEvent;
2656 WindowInfo windowInfo;
2657 windowInfo.id = 1;
2658 windowInfo.flags = 0;
2659 windowInfo.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
2660
2661 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
2662 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
2663 it->second.windowsInfo.push_back(windowInfo);
2664 }
2665 PointerEvent::PointerItem pointerItem;
2666 pointerItem.SetGlobalX(DBL_MAX);
2667 pointerItem.SetGlobalY(DBL_MAX);
2668 int32_t fd = 1;
2669 std::vector<std::string> args;
2670 ASSERT_NO_FATAL_FAILURE(inputWindowsManager->Dump(fd, args));
2671 }
2672
2673 /**
2674 * @tc.name: InputWindowsManagerOneTest_UpdateKeyEventDisplayId
2675 * @tc.desc: Test the funcation UpdateKeyEventDisplayId
2676 * @tc.type: FUNC
2677 * @tc.require:
2678 */
2679 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_UpdateKeyEventDisplayId, TestSize.Level1)
2680 {
2681 CALL_TEST_DEBUG;
2682 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2683 std::shared_ptr<KeyEvent> keyEvent = nullptr;
2684 int32_t focusWindowId = 1;
2685 int32_t groupId = 0;
2686 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->UpdateKeyEventDisplayId(keyEvent, focusWindowId));
2687
2688 WindowInfo windowInfo = {.displayId = 1};
2689 WindowGroupInfo windowGroupInfo = {.focusWindowId = 1, .displayId = 1, .windowsInfo = {windowInfo}};
2690 inputWindowsManager->windowsPerDisplay_.emplace(std::make_pair(1, windowGroupInfo));
2691 keyEvent = KeyEvent::Create();
2692 ASSERT_NE(keyEvent, nullptr);
2693 inputWindowsManager->UpdateKeyEventDisplayId(keyEvent, focusWindowId);
2694 EXPECT_EQ(keyEvent->GetTargetDisplayId(), -1);
2695
2696 OLD::DisplayInfo displayInfo1;
2697 displayInfo1.id = 1;
2698 displayInfo1.x = 1;
2699 displayInfo1.y = 1;
2700 displayInfo1.width = 2;
2701 displayInfo1.height = 2;
2702 displayInfo1.dpi = 240;
2703 displayInfo1.name = "pp";
2704 displayInfo1.direction = DIRECTION0;
2705 displayInfo1.displaySourceMode = OHOS::MMI::DisplaySourceMode::SCREEN_MAIN;
2706 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
2707 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
2708 it->second.displaysInfo.emplace_back(displayInfo1);
2709 }
2710 inputWindowsManager->windowsPerDisplayMap_.clear();
2711 std::map<int32_t, WindowGroupInfo> windowsPerDisplay = {
2712 {focusWindowId + 1, windowGroupInfo}
2713 };
2714 inputWindowsManager->windowsPerDisplayMap_.emplace(0, windowsPerDisplay);
2715 ASSERT_NO_FATAL_FAILURE(inputWindowsManager->UpdateKeyEventDisplayId(keyEvent, focusWindowId, groupId));
2716 EXPECT_EQ(keyEvent->GetTargetDisplayId(), 1);
2717 }
2718
2719 /**
2720 * @tc.name: InputWindowsManagerOneTest_GetWindowInfoById
2721 * @tc.desc: Test GetWindowInfoById
2722 * @tc.type: FUNC
2723 * @tc.require:
2724 */
2725 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_GetWindowInfoById, TestSize.Level1)
2726 {
2727 CALL_TEST_DEBUG;
2728 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2729 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2730 ASSERT_NE(pointerEvent, nullptr);
2731 UDSServer udsServer;
2732 inputWindowsManager->udsServer_ = &udsServer;
2733 inputWindowsManager->lastTouchEvent_ = pointerEvent;
2734 int32_t focusWindowId = 1;
2735 WindowInfo windowInfo;
2736 windowInfo.id = 1;
2737 windowInfo.flags = 0;
2738 windowInfo.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
2739 WindowGroupInfo windowGroupInfo = {.focusWindowId = 1, .displayId = 1, .windowsInfo = {windowInfo}};
2740 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
2741 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
2742 it->second.windowsInfo.push_back(windowInfo);
2743 }
2744 inputWindowsManager->windowsPerDisplayMap_.clear();
2745 std::map<int32_t, WindowGroupInfo> windowsPerDisplay = {
2746 {focusWindowId + 1, windowGroupInfo}
2747 };
2748 inputWindowsManager->windowsPerDisplayMap_.emplace(0, windowsPerDisplay);
2749 PointerEvent::PointerItem pointerItem;
2750 pointerItem.SetGlobalX(DBL_MAX);
2751 pointerItem.SetGlobalY(DBL_MAX);
2752 int32_t windowId = 1;
2753 std::optional<WindowInfo> info = inputWindowsManager->GetWindowInfoById(windowId);
2754 EXPECT_TRUE(info.has_value());
2755 }
2756
2757 /**
2758 * @tc.name: InputWindowsManagerOneTest_NeedTouchTracking
2759 * @tc.desc: Test NeedTouchTracking
2760 * @tc.type: FUNC
2761 * @tc.require:
2762 */
2763 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_NeedTouchTracking, TestSize.Level1)
2764 {
2765 CALL_TEST_DEBUG;
2766 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2767 ASSERT_NE(inputWindowsManager, nullptr);
2768 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2769 ASSERT_NE(pointerEvent, nullptr);
2770 UDSServer udsServer;
2771 inputWindowsManager->udsServer_ = &udsServer;
2772 inputWindowsManager->lastTouchEvent_ = pointerEvent;
2773 auto pointerId = 1;
2774 PointerEvent::PointerItem pointerItem;
2775 pointerItem.SetGlobalX(DBL_MAX);
2776 pointerItem.SetGlobalY(DBL_MAX);
2777 WindowInfo windowInfo;
2778 windowInfo.id = 1;
2779 windowInfo.flags = 0;
2780 windowInfo.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
2781
2782 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
2783 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
2784 it->second.windowsInfo.push_back(windowInfo);
2785 }
2786 inputWindowsManager->lastTouchEvent_->SetPointerId(pointerId);
2787 pointerItem.SetPointerId(pointerId);
2788 inputWindowsManager->lastTouchEvent_->pointers_.push_back(pointerItem);
2789 auto fixedMode = PointerEvent::FixedMode::NORMAL;
2790 inputWindowsManager->lastTouchEvent_->SetFixedMode(fixedMode);
2791 PointerEvent event(InputEvent::EVENT_TYPE_POINTER);
2792 ASSERT_NO_FATAL_FAILURE(inputWindowsManager->NeedTouchTracking(event));
2793
2794 event.AddFlag(OHOS::MMI::InputEvent::EVENT_FLAG_ACCESSIBILITY);
2795 ASSERT_NO_FATAL_FAILURE(inputWindowsManager->NeedTouchTracking(event));
2796
2797 event.SetPointerAction(PointerEvent::POINTER_ACTION_HOVER_MOVE);
2798 ASSERT_NO_FATAL_FAILURE(inputWindowsManager->NeedTouchTracking(event));
2799 }
2800
2801 /**
2802 * @tc.name: InputWindowsManagerOneTest_ProcessTouchTracking_001
2803 * @tc.desc: Test ProcessTouchTracking
2804 * @tc.type: FUNC
2805 * @tc.require:
2806 */
2807 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ProcessTouchTracking_001, TestSize.Level1)
2808 {
2809 CALL_TEST_DEBUG;
2810 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2811 ASSERT_NE(inputWindowsManager, nullptr);
2812 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2813 ASSERT_NE(pointerEvent, nullptr);
2814 UDSServer udsServer;
2815 inputWindowsManager->udsServer_ = &udsServer;
2816 WindowInfo windowInfo;
2817 windowInfo.id = 1;
2818 windowInfo.flags = 0;
2819 windowInfo.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
2820 ASSERT_NO_FATAL_FAILURE(inputWindowsManager->ProcessTouchTracking(pointerEvent, windowInfo));
2821 pointerEvent->AddFlag(OHOS::MMI::InputEvent::EVENT_FLAG_ACCESSIBILITY);
2822 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_HOVER_MOVE);
2823 inputWindowsManager->lastTouchEvent_ = pointerEvent;
2824 ASSERT_NO_FATAL_FAILURE(inputWindowsManager->ProcessTouchTracking(pointerEvent, windowInfo));
2825 int32_t windowId = 1;
2826 pointerEvent->SetTargetWindowId(windowId);
2827 ASSERT_NO_FATAL_FAILURE(inputWindowsManager->ProcessTouchTracking(pointerEvent, windowInfo));
2828 }
2829
2830 /**
2831 * @tc.name: InputWindowsManagerOneTest_ProcessTouchTracking_002
2832 * @tc.desc: Test ProcessTouchTracking
2833 * @tc.type: FUNC
2834 * @tc.require:
2835 */
2836 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ProcessTouchTracking_002, TestSize.Level1)
2837 {
2838 CALL_TEST_DEBUG;
2839 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2840 ASSERT_NE(inputWindowsManager, nullptr);
2841 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2842 ASSERT_NE(pointerEvent, nullptr);
2843 UDSServer udsServer;
2844 inputWindowsManager->udsServer_ = &udsServer;
2845 WindowInfo windowInfo;
2846 windowInfo.id = 1;
2847 windowInfo.flags = 0;
2848 windowInfo.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
2849 pointerEvent->AddFlag(OHOS::MMI::InputEvent::EVENT_FLAG_ACCESSIBILITY);
2850 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_HOVER_MOVE);
2851 inputWindowsManager->lastTouchEvent_ = pointerEvent;
2852 int32_t windowId = 2;
2853 pointerEvent->SetTargetWindowId(windowId);
2854 ASSERT_NO_FATAL_FAILURE(inputWindowsManager->ProcessTouchTracking(pointerEvent, windowInfo));
2855 }
2856
2857 /**
2858 * @tc.name: InputWindowsManagerOneTest_AddActiveWindow
2859 * @tc.desc: Test the function AddActiveWindow
2860 * @tc.type: FUNC
2861 * @tc.require:
2862 */
2863 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_AddActiveWindow, TestSize.Level1)
2864 {
2865 CALL_TEST_DEBUG;
2866 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2867 ASSERT_NE(inputWindowsManager, nullptr);
2868 int32_t windowId = 1;
2869 int32_t pointerId = 0;
2870 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->AddActiveWindow(windowId, pointerId));
2871
2872 WindowInfo windowInfo;
2873 windowInfo.id = 1;
2874 windowInfo.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
2875 auto it = inputWindowsManager->displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
2876 if (it != inputWindowsManager->displayGroupInfoMap_.end()) {
2877 it->second.windowsInfo.push_back(windowInfo);
2878 }
2879 inputWindowsManager->AddActiveWindow(windowId, pointerId);
2880 pointerId = 100;
2881 inputWindowsManager->activeTouchWinTypes_.clear();
2882 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->AddActiveWindow(windowId, pointerId));
2883 }
2884
2885 /* *
2886 * @tc.name: InputWindowsManagerOneTest_UpdateTargetTouchWinIds_001
2887 * @tc.desc: Test the funcation UpdateTargetTouchWinIds
2888 * @tc.type: FUNC
2889 * @tc.require:
2890 */
2891 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_UpdateTargetTouchWinIds_001, TestSize.Level1)
2892 {
2893 CALL_TEST_DEBUG;
2894 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2895 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2896 ASSERT_NE(pointerEvent, nullptr);
2897 WindowInfo winInfo;
2898 int32_t pointerId = 1;
2899 PointerEvent::PointerItem pointerItem;
2900 inputWindowsManager->targetTouchWinIds_[1] = {10, 20, 30};
2901 inputWindowsManager->targetTouchWinIds_[2] = {10, 20, 30};
2902 pointerItem.SetDisplayXPos(0.0);
2903 pointerItem.SetDisplayYPos(0.0);
2904 winInfo.windowInputType = WindowInputType::TRANSMIT_ALL;
2905 inputWindowsManager->UpdateTargetTouchWinIds(winInfo, pointerItem, pointerEvent, pointerId, 1);
2906 winInfo.windowInputType = WindowInputType::TRANSMIT_EXCEPT_MOVE;
2907 inputWindowsManager->UpdateTargetTouchWinIds(winInfo, pointerItem, pointerEvent, pointerId, 1);
2908 EXPECT_TRUE(!inputWindowsManager->targetTouchWinIds_[pointerId].empty());
2909 inputWindowsManager->targetTouchWinIds_.clear();
2910 inputWindowsManager->UpdateTargetTouchWinIds(winInfo, pointerItem, pointerEvent, pointerId, 1);
2911 EXPECT_TRUE(inputWindowsManager->targetTouchWinIds_[pointerId].empty());
2912 }
2913
2914 /* *
2915 * @tc.name: InputWindowsManagerOneTest_ShiftAppSimulateTouchPointerEvent
2916 * @tc.desc: Test the funcation ShiftAppSimulateTouchPointerEvent
2917 * @tc.type: FUNC
2918 * @tc.require:
2919 */
2920 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_ShiftAppSimulateTouchPointerEvent, TestSize.Level1)
2921 {
2922 CALL_TEST_DEBUG;
2923 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2924 ShiftWindowInfo shiftWindowInfo;
2925 shiftWindowInfo.fingerId = 1;
2926 PointerEvent::PointerItem item;
2927 int32_t pointerId = 0;
2928 item.SetPointerId(pointerId);
2929 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2930 ASSERT_NE(pointerEvent, nullptr);
2931 inputWindowsManager->lastTouchEvent_ = pointerEvent;
2932 pointerEvent->pointers_.push_back(item);
2933 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ShiftAppSimulateTouchPointerEvent(shiftWindowInfo));
2934 shiftWindowInfo.fingerId = 0;
2935 item.pressed_ = false;
2936 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ShiftAppSimulateTouchPointerEvent(shiftWindowInfo));
2937 item.pressed_ = true;
2938 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ShiftAppSimulateTouchPointerEvent(shiftWindowInfo));
2939 shiftWindowInfo.x = -1;
2940 shiftWindowInfo.y = -1;
2941 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ShiftAppSimulateTouchPointerEvent(shiftWindowInfo));
2942 shiftWindowInfo.x = 1;
2943 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ShiftAppSimulateTouchPointerEvent(shiftWindowInfo));
2944 shiftWindowInfo.x = -1;
2945 shiftWindowInfo.y = 1;
2946 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->ShiftAppSimulateTouchPointerEvent(shiftWindowInfo));
2947 }
2948
2949 #ifdef OHOS_BUILD_ENABLE_ONE_HAND_MODE
2950 /* *
2951 * @tc.name: InputWindowsManagerOneTest_TouchEnterLeaveEvent
2952 * @tc.desc: Test the funcation TouchEnterLeaveEvent
2953 * @tc.type: FUNC
2954 * @tc.require:
2955 */
2956 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_TouchEnterLeaveEvent, TestSize.Level1)
2957 {
2958 CALL_TEST_DEBUG;
2959 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
2960 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2961 ASSERT_NE(pointerEvent, nullptr);
2962 PointerEvent::PointerItem pointerItem;
2963 pointerItem.SetDisplayXPos(0.0);
2964 pointerItem.SetDisplayYPos(0.0);
2965 auto logicalX = 100;
2966 auto logicalY = 200;
2967 WindowInfo touchWindow;
2968 auto pointerId = 1;
2969 touchWindow.id = 1;
2970 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
2971 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE;
2972 pointerEvent->targetWindowId_ = 1;
2973 pointerEvent->pointers_.clear();
2974 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->TouchEnterLeaveEvent(logicalX, logicalY, pointerEvent, &touchWindow));
2975 pointerItem.SetPointerId(pointerId);
2976 pointerEvent->pointers_.push_back(pointerItem);
2977 EXPECT_EQ(pointerEvent->GetPointerCount(), pointerId);
2978 pointerEvent->SetPointerId(pointerId);
2979 EXPECT_TRUE(pointerEvent->GetPointerItem(pointerId, pointerItem));
2980 touchWindow.windowInputType = WindowInputType::ANTI_MISTAKE_TOUCH;
2981 inputWindowsManager->lastTouchWindowInfo_.id = touchWindow.id;
2982 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->TouchEnterLeaveEvent(logicalX, logicalY, pointerEvent, &touchWindow));
2983
2984 touchWindow.windowInputType = WindowInputType::MIX_LEFT_RIGHT_ANTI_AXIS_MOVE;
2985 inputWindowsManager->lastTouchWindowInfo_.id = 5;
2986 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->TouchEnterLeaveEvent(logicalX, logicalY, pointerEvent, &touchWindow));
2987
2988 inputWindowsManager->lastTouchWindowInfo_.id = -1;
2989 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->TouchEnterLeaveEvent(logicalX, logicalY, pointerEvent, &touchWindow));
2990
2991 inputWindowsManager->lastTouchWindowInfo_.id = 5;
2992 touchWindow.windowInputType = WindowInputType::SLID_TOUCH_WINDOW;
2993 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->TouchEnterLeaveEvent(logicalX, logicalY, pointerEvent, &touchWindow));
2994 }
2995 #endif // OHOS_BUILD_ENABLE_ONE_HAND_MODE
2996
2997 /**
2998 * @tc.name: InputWindowsManagerOneTest_AdjustDisplayRotation_001
2999 * @tc.desc: Test the funcation AdjustDisplayRotation
3000 * @tc.type: FUNC
3001 * @tc.require:
3002 */
3003 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_AdjustDisplayRotation_001, TestSize.Level1)
3004 {
3005 CALL_TEST_DEBUG;
3006 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>();
3007 ASSERT_NE(inputWindowsManager, nullptr);
3008 auto it = inputWindowsManager->cursorPosMap_.find(DEFAULT_GROUP_ID);
3009 if (it != inputWindowsManager->cursorPosMap_.end()) {
3010 it->second.direction = Direction::DIRECTION0;
3011 }
3012 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->AdjustDisplayRotation());
3013 it->second.direction = Direction::DIRECTION90;
3014 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->AdjustDisplayRotation());
3015 it->second.direction = Direction::DIRECTION180;
3016 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->AdjustDisplayRotation());
3017 it->second.direction = Direction::DIRECTION270;
3018 EXPECT_NO_FATAL_FAILURE(inputWindowsManager->AdjustDisplayRotation());
3019 }
3020
3021 /**
3022 * @tc.name: InputWindowsManagerOneTest_FoldScreenRotation_010
3023 * @tc.desc: Test the function FoldScreenRotation
3024 * @tc.type: FUNC
3025 * @tc.require:
3026 */
3027 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_FoldScreenRotation_010, TestSize.Level1)
3028 {
3029 CALL_TEST_DEBUG;
3030 InputWindowsManager inputWindowsManager;
3031 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
3032 ASSERT_NE(pointerEvent, nullptr);
3033 WindowInfoEX winInfoEx;
3034 OLD::DisplayInfo displayInfo;
3035 displayInfo.id = 10;
3036 pointerEvent->bitwise_ = 0x00000080;
3037 pointerEvent->SetPointerId(1);
3038 pointerEvent->SetTargetDisplayId(10);
3039 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
3040 inputWindowsManager.displayGroupInfo_.displaysInfo.push_back(displayInfo);
3041 EXPECT_NO_FATAL_FAILURE(inputWindowsManager.FoldScreenRotation(pointerEvent));
3042 }
3043
3044 /**
3045 * @tc.name: InputWindowsManagerOneTest_FoldScreenRotation_011
3046 * @tc.desc: Test the function FoldScreenRotation
3047 * @tc.type: FUNC
3048 * @tc.require:
3049 */
3050 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_FoldScreenRotation_011, TestSize.Level1)
3051 {
3052 CALL_TEST_DEBUG;
3053 InputWindowsManager inputWindowsManager;
3054 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
3055 ASSERT_NE(pointerEvent, nullptr);
3056 WindowInfoEX winInfoEx;
3057 OLD::DisplayInfo displayInfo;
3058 displayInfo.id = 10;
3059 pointerEvent->bitwise_ = 0x00000080;
3060 pointerEvent->SetPointerId(1);
3061 pointerEvent->SetTargetDisplayId(10);
3062 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
3063 OLD::DisplayGroupInfo displayGroupInfoRef;
3064 auto it = inputWindowsManager.displayGroupInfoMap_.find(DEFAULT_GROUP_ID);
3065 if (it != inputWindowsManager.displayGroupInfoMap_.end()) {
3066 displayGroupInfoRef = it->second;
3067 }
3068 displayGroupInfoRef.displaysInfo.push_back(displayInfo);
3069 EXPECT_NO_FATAL_FAILURE(inputWindowsManager.FoldScreenRotation(pointerEvent));
3070 }
3071
3072 /**
3073 * @tc.name: InputWindowsManagerOneTest_HandleHardWareCursorTest002
3074 * @tc.desc: Test the funcation HandleHardWareCursor
3075 * @tc.type: FUNC
3076 * @tc.require:
3077 */
3078 HWTEST_F(InputWindowsManagerOneTest, InputWindowsManagerOneTest_HandleHardWareCursorTest002, TestSize.Level1)
3079 {
3080 CALL_TEST_DEBUG;
3081 std::shared_ptr<InputWindowsManager> inputWindowsManager =
3082 std::static_pointer_cast<InputWindowsManager>(WIN_MGR);
3083 ASSERT_NE(inputWindowsManager, nullptr);
3084 std::vector<int32_t> result = inputWindowsManager->HandleHardwareCursor(nullptr, 512, 384);
3085 EXPECT_EQ(result[0], DEFAULT_POSITION);
3086 EXPECT_EQ(result[1], DEFAULT_POSITION);
3087 }
3088 } // namespace MMI
3089 } // namespace OHOS
3090