1 /*
2 * Copyright (c) 2021-2022 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 <gtest/gtest.h>
17 #include "define_multimodal.h"
18 #include "input_manager.h"
19 #include "key_event.h"
20 #include "multimodal_standardized_event_manager.h"
21 #include "proto.h"
22 #include "pointer_event.h"
23 #include "run_shell_util.h"
24 #include "util.h"
25
26 namespace OHOS {
27 namespace MMI {
28 namespace {
29 using namespace testing::ext;
30 using namespace OHOS::MMI;
31 using namespace OHOS;
32 } // namespace
33 class PointerEventTest : public testing::Test {
34 public:
SetUpTestCase(void)35 static void SetUpTestCase(void) {}
TearDownTestCase(void)36 static void TearDownTestCase(void) {}
37 static std::shared_ptr<PointerEvent> createPointEvent();
38 };
39
createPointEvent()40 std::shared_ptr<PointerEvent> PointerEventTest::createPointEvent()
41 {
42 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
43 int64_t downTime = GetMillisTime();
44 PointerEvent::PointerItem item;
45 item.SetPointerId(0); // test code£¬set the PointerId = 0
46 item.SetGlobalX(823); // test code£¬set the GlobalX = 823
47 item.SetGlobalY(723); // test code£¬set the GlobalY = 723
48 item.SetWidth(0);
49 item.SetHeight(0);
50 item.SetPressure(0); // test code£¬set the Pressure = 5
51 item.SetDeviceId(1); // test code£¬set the DeviceId = 1
52 item.SetDownTime(downTime);
53 pointerEvent->AddPointerItem(item);
54
55 pointerEvent->SetPointerId(0); // test code£¬set the PointerId = 1
56 pointerEvent->SetDeviceId(1);
57 pointerEvent->SetActionTime(downTime);
58 pointerEvent->SetActionStartTime(downTime);
59 pointerEvent->SetTargetDisplayId(0);
60 pointerEvent->SetTargetWindowId(-1);
61 pointerEvent->SetAgentWindowId(-1);
62 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
63 pointerEvent->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
64 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
65 return pointerEvent;
66 }
67
68 /**
69 * @tc.name:PointerEventTest_keyEventAndPointerEvent_001
70 * @tc.desc:Verify ctrl(left) + point event
71 * @tc.type: FUNC
72 * @tc.require: AR000GOACS
73 * @tc.author: yangguang
74 */
75 HWTEST_F(PointerEventTest, PointerEventTest_keyEventAndPointerEvent_001, TestSize.Level1)
76 {
77 RunShellUtil runCommand;
78 std::string log1 = "Pressed keyCode:";
79 std::vector<std::string> beforeRunLogs;
80 ASSERT_TRUE(runCommand.RunShellCommand(log1, beforeRunLogs) == RET_OK);
81
82 std::shared_ptr<PointerEvent> pointerEvent = createPointEvent();
83 // KEYCODE_CTRL_LEFT = 2072
84 std::vector<int32_t> pressedKeys { OHOS::MMI::KeyEvent::KEYCODE_CTRL_LEFT };
85 pointerEvent->SetPressedKeys(pressedKeys);
86 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
87 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
88
89 std::vector<std::string> afterRunLogs;
90 ASSERT_TRUE(runCommand.RunShellCommand(log1, afterRunLogs) == RET_OK);
91 ASSERT_FALSE(afterRunLogs.empty());
92 if (beforeRunLogs.empty()) {
93 EXPECT_TRUE(afterRunLogs.size() > beforeRunLogs.size());
94 EXPECT_TRUE(afterRunLogs.back().find(log1) != afterRunLogs.back().npos);
95 } else {
96 EXPECT_TRUE(std::strcmp(afterRunLogs.back().c_str(), beforeRunLogs.back().c_str()) != 0);
97 }
98 }
99
100 /**
101 * @tc.name:PointerEventTest_keyEventAndPointerEvent_002
102 * @tc.desc:Verify ctrl(right) + point event
103 * @tc.type: FUNC
104 * @tc.require: AR000GOACS
105 * @tc.author: yangguang
106 */
107 HWTEST_F(PointerEventTest, PointerEventTest_keyEventAndPointerEvent_002, TestSize.Level1)
108 {
109 RunShellUtil runCommand;
110 std::string log1 = "Pressed keyCode:";
111 std::vector<std::string> beforeRunLogs;
112 ASSERT_TRUE(runCommand.RunShellCommand(log1, beforeRunLogs) == RET_OK);
113
114 std::shared_ptr<PointerEvent> pointerEvent = createPointEvent();
115 // KEYCODE_CTRL_RIGHT = 2073
116 std::vector<int32_t> pressedKeys { OHOS::MMI::KeyEvent::KEYCODE_CTRL_RIGHT };
117 pointerEvent->SetPressedKeys(pressedKeys);
118 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
119 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
120
121 std::vector<std::string> afterRunLogs;
122 ASSERT_TRUE(runCommand.RunShellCommand(log1, afterRunLogs) == RET_OK);
123 ASSERT_FALSE(afterRunLogs.empty());
124 if (beforeRunLogs.empty()) {
125 EXPECT_TRUE(afterRunLogs.size() > beforeRunLogs.size());
126 EXPECT_TRUE(afterRunLogs.back().find(log1) != afterRunLogs.back().npos);
127 } else {
128 EXPECT_TRUE(std::strcmp(afterRunLogs.back().c_str(), beforeRunLogs.back().c_str()) != 0);
129 }
130 }
131
132 /**
133 * @tc.name:PointerEventTest_keyEventAndPointerEvent_003
134 * @tc.desc:Verify ctrl(left and right) + point event
135 * @tc.type: FUNC
136 * @tc.require: AR000GOACS
137 * @tc.author: yangguang
138 */
139 HWTEST_F(PointerEventTest, PointerEventTest_keyEventAndPointerEvent_003, TestSize.Level1)
140 {
141 RunShellUtil runCommand;
142 std::string log1 = "Pressed keyCode:";
143 std::vector<std::string> beforeRunLogs;
144 ASSERT_TRUE(runCommand.RunShellCommand(log1, beforeRunLogs) == RET_OK);
145
146 std::shared_ptr<PointerEvent> pointerEvent = createPointEvent();
147 // KEYCODE_CTRL_LEFT = 2072, KEYCODE_CTRL_RIGHT = 2073
148 std::vector<int32_t> pressedKeys { OHOS::MMI::KeyEvent::KEYCODE_CTRL_LEFT,
149 OHOS::MMI::KeyEvent::KEYCODE_CTRL_RIGHT };
150 pointerEvent->SetPressedKeys(pressedKeys);
151 InputManager::GetInstance()->SimulateInputEvent(pointerEvent);
152 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
153
154 std::vector<std::string> afterRunLogs;
155 ASSERT_TRUE(runCommand.RunShellCommand(log1, afterRunLogs) == RET_OK);
156 ASSERT_FALSE(afterRunLogs.empty());
157 if (beforeRunLogs.empty()) {
158 EXPECT_TRUE(afterRunLogs.size() > beforeRunLogs.size());
159 EXPECT_TRUE(afterRunLogs.back().find(log1) != afterRunLogs.back().npos);
160 } else {
161 EXPECT_TRUE(std::strcmp(afterRunLogs.back().c_str(), beforeRunLogs.back().c_str()) != 0);
162 }
163 }
164
165 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_001, TestSize.Level1)
166 {
167 auto pointerEvent = PointerEvent::Create();
168 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_UNKNOWN);
169 ASSERT_TRUE(!pointerEvent->IsValid());
170
171 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
172 pointerEvent->SetPointerId(-1);
173 ASSERT_TRUE(!pointerEvent->IsValid());
174
175 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
176 pointerEvent->SetPointerId(0);
177 PointerEvent::PointerItem item1;
178 item1.SetPointerId(0);
179 pointerEvent->AddPointerItem(item1);
180 PointerEvent::PointerItem item2;
181 item2.SetPointerId(0);
182 pointerEvent->AddPointerItem(item2);
183 ASSERT_TRUE(!pointerEvent->IsValid());
184
185 auto pointerEvent1 = PointerEvent::Create();
186 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
187 pointerEvent1->SetPointerId(0);
188 pointerEvent1->SetButtonPressed(PointerEvent::BUTTON_NONE);
189 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
190 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_RIGHT);
191 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_MIDDLE);
192 item1.SetPointerId(0);
193 pointerEvent1->AddPointerItem(item1);
194 ASSERT_TRUE(!pointerEvent1->IsValid());
195 }
196
197 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_002, TestSize.Level1)
198 {
199 auto pointerEvent1 = PointerEvent::Create();
200 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
201 pointerEvent1->SetPointerId(0);
202 pointerEvent1->SetButtonPressed(PointerEvent::BUTTON_NONE);
203 PointerEvent::PointerItem item;
204 item.SetPointerId(0);
205 pointerEvent1->AddPointerItem(item);
206 ASSERT_TRUE(!pointerEvent1->IsValid());
207
208 auto pointerEvent2 = PointerEvent::Create();
209 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
210 pointerEvent2->SetPointerId(0);
211 pointerEvent2->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
212 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
213 item.SetPointerId(0);
214 pointerEvent2->AddPointerItem(item);
215 ASSERT_TRUE(!pointerEvent2->IsValid());
216
217 auto pointerEvent3 = PointerEvent::Create();
218 pointerEvent3->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
219 pointerEvent3->SetPointerId(0);
220 pointerEvent3->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
221 pointerEvent3->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP);
222 pointerEvent3->SetButtonId(PointerEvent::BUTTON_NONE);
223 item.SetPointerId(0);
224 pointerEvent3->AddPointerItem(item);
225 ASSERT_TRUE(!pointerEvent3->IsValid());
226 }
227
228 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_003, TestSize.Level1)
229 {
230 auto pointerEvent1 = PointerEvent::Create();
231 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
232 pointerEvent1->SetPointerId(0);
233 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
234 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
235 pointerEvent1->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
236 PointerEvent::PointerItem item;
237 item.SetPointerId(0);
238 pointerEvent1->AddPointerItem(item);
239 ASSERT_TRUE(!pointerEvent1->IsValid());
240
241 auto pointerEvent2 = PointerEvent::Create();
242 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
243 pointerEvent2->SetPointerId(0);
244 pointerEvent2->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
245 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
246 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
247 item.SetPointerId(-1);
248 pointerEvent2->AddPointerItem(item);
249 ASSERT_TRUE(!pointerEvent2->IsValid());
250 }
251
252 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_004, TestSize.Level1)
253 {
254 auto pointerEvent1 = PointerEvent::Create();
255 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
256 pointerEvent1->SetPointerId(0);
257 pointerEvent1->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
258 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
259 pointerEvent1->SetButtonId(PointerEvent::BUTTON_NONE);
260 PointerEvent::PointerItem item;
261 item.SetPointerId(2);
262 pointerEvent1->AddPointerItem(item);
263 ASSERT_TRUE(!pointerEvent1->IsValid());
264
265 auto pointerEvent2 = PointerEvent::Create();
266 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
267 pointerEvent2->SetPointerId(0);
268 pointerEvent2->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
269 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
270 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
271 item.SetPointerId(0);
272 item.SetDownTime(10010);
273 pointerEvent2->AddPointerItem(item);
274 ASSERT_TRUE(!pointerEvent2->IsValid());
275
276 auto pointerEvent3 = PointerEvent::Create();
277 pointerEvent3->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
278 pointerEvent3->SetPointerId(0);
279 pointerEvent3->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
280 pointerEvent3->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
281 pointerEvent3->SetButtonId(PointerEvent::BUTTON_NONE);
282 item.SetPointerId(0);
283 item.SetDownTime(0);
284 item.SetPressed(true);
285 pointerEvent3->AddPointerItem(item);
286 ASSERT_TRUE(!pointerEvent3->IsValid());
287 }
288
289 HWTEST_F(PointerEventTest, PointerEventTest_CheckMousePointEvent_005, TestSize.Level1)
290 {
291 auto pointerEvent = PointerEvent::Create();
292 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
293 pointerEvent->SetPointerId(0);
294 pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
295 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
296 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
297 PointerEvent::PointerItem item;
298 item.SetPointerId(0);
299 item.SetDownTime(0);
300 item.SetPressed(false);
301 pointerEvent->AddPointerItem(item);
302 ASSERT_TRUE(pointerEvent->IsValid());
303 }
304
305 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_001, TestSize.Level1)
306 {
307 auto pointerEvent = PointerEvent::Create();
308 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
309 pointerEvent->SetPointerId(-1);
310 ASSERT_TRUE(!pointerEvent->IsValid());
311
312 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
313 pointerEvent->SetPointerId(0);
314 pointerEvent->SetButtonPressed(PointerEvent::MOUSE_BUTTON_LEFT);
315 ASSERT_TRUE(!pointerEvent->IsValid());
316
317 auto pointerEvent1 = PointerEvent::Create();
318 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
319 pointerEvent1->SetPointerId(0);
320 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
321 ASSERT_TRUE(!pointerEvent1->IsValid());
322
323 auto pointerEvent2 = PointerEvent::Create();
324 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
325 pointerEvent2->SetPointerId(0);
326 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
327 pointerEvent2->SetButtonId(PointerEvent::MOUSE_BUTTON_LEFT);
328 ASSERT_TRUE(!pointerEvent2->IsValid());
329 }
330
331 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_002, TestSize.Level1)
332 {
333 auto pointerEvent1 = PointerEvent::Create();
334 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
335 pointerEvent1->SetPointerId(0);
336 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
337 pointerEvent1->SetButtonId(PointerEvent::BUTTON_NONE);
338 PointerEvent::PointerItem item;
339 item.SetPointerId(-1);
340 pointerEvent1->AddPointerItem(item);
341 ASSERT_TRUE(!pointerEvent1->IsValid());
342
343 auto pointerEvent2 = PointerEvent::Create();
344 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
345 pointerEvent2->SetPointerId(0);
346 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
347 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
348 item.SetPointerId(0);
349 item.SetDownTime(0);
350 item.SetPressed(false);
351 pointerEvent2->AddPointerItem(item);
352 ASSERT_TRUE(!pointerEvent2->IsValid());
353 }
354
355 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_003, TestSize.Level1)
356 {
357 auto pointerEvent1 = PointerEvent::Create();
358 pointerEvent1->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
359 pointerEvent1->SetPointerId(0);
360 pointerEvent1->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
361 pointerEvent1->SetButtonId(PointerEvent::BUTTON_NONE);
362 PointerEvent::PointerItem item;
363 item.SetPointerId(0);
364 item.SetDownTime(100);
365 item.SetPressed(true);
366 pointerEvent1->AddPointerItem(item);
367 ASSERT_TRUE(!pointerEvent1->IsValid());
368
369 auto pointerEvent2 = PointerEvent::Create();
370 pointerEvent2->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
371 pointerEvent2->SetPointerId(0);
372 pointerEvent2->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
373 pointerEvent2->SetButtonId(PointerEvent::BUTTON_NONE);
374 PointerEvent::PointerItem item1;
375 item1.SetPointerId(0);
376 item1.SetDownTime(100);
377 item1.SetPressed(false);
378 pointerEvent2->AddPointerItem(item1);
379 PointerEvent::PointerItem item2;
380 item2.SetPointerId(0);
381 item2.SetDownTime(100);
382 item2.SetPressed(false);
383 pointerEvent2->AddPointerItem(item2);
384 ASSERT_TRUE(!pointerEvent2->IsValid());
385 }
386
387 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_004, TestSize.Level1)
388 {
389 auto pointerEvent = PointerEvent::Create();
390 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
391 pointerEvent->SetPointerId(0);
392 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
393 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
394 PointerEvent::PointerItem item1;
395 item1.SetPointerId(1);
396 item1.SetDownTime(100);
397 item1.SetPressed(false);
398 pointerEvent->AddPointerItem(item1);
399 PointerEvent::PointerItem item2;
400 item2.SetPointerId(2);
401 item2.SetDownTime(100);
402 item2.SetPressed(false);
403 pointerEvent->AddPointerItem(item2);
404 ASSERT_TRUE(!pointerEvent->IsValid());
405 }
406
407 HWTEST_F(PointerEventTest, PointerEventTest_CheckTouchPointEvent_005, TestSize.Level1)
408 {
409 auto pointerEvent = PointerEvent::Create();
410 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
411 pointerEvent->SetPointerId(0);
412 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
413 pointerEvent->SetButtonId(PointerEvent::BUTTON_NONE);
414 PointerEvent::PointerItem item1;
415 item1.SetPointerId(0);
416 item1.SetDownTime(100);
417 item1.SetPressed(false);
418 pointerEvent->AddPointerItem(item1);
419 PointerEvent::PointerItem item2;
420 item2.SetPointerId(1);
421 item2.SetDownTime(100);
422 item2.SetPressed(false);
423 pointerEvent->AddPointerItem(item2);
424 ASSERT_TRUE(pointerEvent->IsValid());
425 }
426 } // namespace MMI
427 } // namespace OHOS
428