Flutter Engine Uber Docs
Docs for the entire Flutter Engine repo.
 
Loading...
Searching...
No Matches
Classes | Functions
fl_pointer_manager_test.cc File Reference
#include "flutter/shell/platform/linux/fl_pointer_manager.h"
#include "flutter/shell/platform/embedder/test_utils/proc_table_replacement.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/testing/linux_test.h"
#include "gtest/gtest.h"

Go to the source code of this file.

Classes

class  FlPointerManagerTest
 

Functions

 TEST_F (FlPointerManagerTest, EnterLeave)
 
 TEST_F (FlPointerManagerTest, EnterEnter)
 
 TEST_F (FlPointerManagerTest, EnterLeaveLeave)
 
 TEST_F (FlPointerManagerTest, EnterButtonPress)
 
 TEST_F (FlPointerManagerTest, NoEnterButtonPress)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonReleasePrimary)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonReleaseSecondary)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonReleaseMiddle)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonReleaseBack)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonReleaseForward)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonReleaseThreeButtons)
 
 TEST_F (FlPointerManagerTest, ButtonPressStylusPrimaryButton)
 
 TEST_F (FlPointerManagerTest, ButtonPressStylusContact)
 
 TEST_F (FlPointerManagerTest, ButtonPressInvertedStylusContact)
 
 TEST_F (FlPointerManagerTest, ButtonPressStylusSecondaryButton)
 
 TEST_F (FlPointerManagerTest, ButtonPressStylusUnknownButton)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonPressButtonRelease)
 
 TEST_F (FlPointerManagerTest, ButtonPressButtonReleaseButtonRelease)
 
 TEST_F (FlPointerManagerTest, NoButtonPressButtonRelease)
 
 TEST_F (FlPointerManagerTest, Motion)
 
 TEST_F (FlPointerManagerTest, Drag)
 
 TEST_F (FlPointerManagerTest, DeviceKind)
 

Function Documentation

◆ TEST_F() [1/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonPressButtonRelease   
)

Definition at line 608 of file fl_pointer_manager_test.cc.

608 {
609 StartEngine();
610
611 std::vector<FlutterPointerEvent> pointer_events;
612 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
613 SendPointerEvent,
614 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
615 size_t events_count) {
616 for (size_t i = 0; i < events_count; i++) {
617 pointer_events.push_back(events[i]);
618 }
619
620 return kSuccess;
621 }));
622
623 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
624 fl_pointer_manager_handle_button_press(manager, 1234,
625 kFlutterPointerDeviceKindMouse, 4.0,
626 8.0, GDK_BUTTON_PRIMARY, 0, 0);
627 // Ignore duplicate press
628 fl_pointer_manager_handle_button_press(manager, 1234,
629 kFlutterPointerDeviceKindMouse, 6.0,
630 10.0, GDK_BUTTON_PRIMARY, 0, 0);
631 fl_pointer_manager_handle_button_release(manager, 1235,
632 kFlutterPointerDeviceKindMouse, 5.0,
633 9.0, GDK_BUTTON_PRIMARY, 0, 0);
634
635 EXPECT_EQ(pointer_events.size(), 3u);
636
637 // Ignore first synthetic enter event
638 EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
639 EXPECT_EQ(pointer_events[1].x, 4.0);
640 EXPECT_EQ(pointer_events[1].y, 8.0);
641 EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
642 EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
643 EXPECT_EQ(pointer_events[1].view_id, 42);
644 EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
645 EXPECT_EQ(pointer_events[2].x, 5.0);
646 EXPECT_EQ(pointer_events[2].y, 9.0);
647 EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
648 EXPECT_EQ(pointer_events[2].buttons, 0);
649 EXPECT_EQ(pointer_events[2].view_id, 42);
650}
x
int32_t x
Definition dl_golden_unittests.cc:482
kFlutterPointerButtonMousePrimary
@ kFlutterPointerButtonMousePrimary
Definition embedder.h:1320
kSuccess
@ kSuccess
Definition embedder.h:73
kFlutterPointerDeviceKindMouse
@ kFlutterPointerDeviceKindMouse
Definition embedder.h:1310
engine
FlutterEngine engine
Definition main.cc:84
g_autoptr
g_autoptr(FlEngine) engine
fl_engine_get_embedder_api
FlutterEngineProcTable * fl_engine_get_embedder_api(FlEngine *self)
Definition fl_engine.cc:920
fl_pointer_manager_new
FlPointerManager * fl_pointer_manager_new(FlutterViewId view_id, FlEngine *engine)
Definition fl_pointer_manager.cc:122
fl_pointer_manager_handle_button_press
gboolean fl_pointer_manager_handle_button_press(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, guint gdk_button, gdouble rotation, gdouble pressure)
Definition fl_pointer_manager.cc:133
fl_pointer_manager_handle_button_release
gboolean fl_pointer_manager_handle_button_release(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, guint gdk_button, gdouble rotation, gdouble pressure)
Definition fl_pointer_manager.cc:173
i
int i
Definition fl_socket_accessible.cc:18
view_id
G_BEGIN_DECLS FlutterViewId view_id
Definition fl_view_accessible.h:49
y
double y
Definition mouse-input-test.cc:82
flutter::manager
it will be possible to load the file into Perfetto s trace viewer use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font manager
Definition switch_defs.h:200
MOCK_ENGINE_PROC
#define MOCK_ENGINE_PROC(proc, mock_impl)
Definition proc_table_replacement.h:19
FlutterEngineProcTable::SendPointerEvent
FlutterEngineSendPointerEventFnPtr SendPointerEvent
Definition embedder.h:3775

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerButtonMousePrimary, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

◆ TEST_F() [2/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonReleaseBack   
)

Definition at line 322 of file fl_pointer_manager_test.cc.

322 {
323 StartEngine();
324
325 std::vector<FlutterPointerEvent> pointer_events;
326 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
327 SendPointerEvent,
328 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
329 size_t events_count) {
330 for (size_t i = 0; i < events_count; i++) {
331 pointer_events.push_back(events[i]);
332 }
333
334 return kSuccess;
335 }));
336
337 // Forward button is 8 (no GDK define).
338 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
339 fl_pointer_manager_handle_button_press(
340 manager, 1234, kFlutterPointerDeviceKindMouse, 4.0, 8.0, 8, 0, 0);
341 fl_pointer_manager_handle_button_release(
342 manager, 1235, kFlutterPointerDeviceKindMouse, 5.0, 9.0, 8, 0, 0);
343
344 EXPECT_EQ(pointer_events.size(), 3u);
345
346 // Ignore first synthetic enter event
347 EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
348 EXPECT_EQ(pointer_events[1].x, 4.0);
349 EXPECT_EQ(pointer_events[1].y, 8.0);
350 EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
351 EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMouseBack);
352 EXPECT_EQ(pointer_events[1].view_id, 42);
353 EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
354 EXPECT_EQ(pointer_events[2].x, 5.0);
355 EXPECT_EQ(pointer_events[2].y, 9.0);
356 EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
357 EXPECT_EQ(pointer_events[2].buttons, 0);
358 EXPECT_EQ(pointer_events[2].view_id, 42);
359}
kFlutterPointerButtonMouseBack
@ kFlutterPointerButtonMouseBack
Definition embedder.h:1323

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerButtonMouseBack, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

◆ TEST_F() [3/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonReleaseButtonRelease   
)

Definition at line 652 of file fl_pointer_manager_test.cc.

652 {
653 StartEngine();
654
655 std::vector<FlutterPointerEvent> pointer_events;
656 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
657 SendPointerEvent,
658 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
659 size_t events_count) {
660 for (size_t i = 0; i < events_count; i++) {
661 pointer_events.push_back(events[i]);
662 }
663
664 return kSuccess;
665 }));
666
667 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
668 fl_pointer_manager_handle_button_press(manager, 1234,
669 kFlutterPointerDeviceKindMouse, 4.0,
670 8.0, GDK_BUTTON_PRIMARY, 0, 0);
671 fl_pointer_manager_handle_button_release(manager, 1235,
672 kFlutterPointerDeviceKindMouse, 5.0,
673 9.0, GDK_BUTTON_PRIMARY, 0, 0);
674 // Ignore duplicate release
675 fl_pointer_manager_handle_button_release(manager, 1235,
676 kFlutterPointerDeviceKindMouse, 6.0,
677 10.0, GDK_BUTTON_PRIMARY, 0, 0);
678
679 EXPECT_EQ(pointer_events.size(), 3u);
680
681 // Ignore first synthetic enter event
682 EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
683 EXPECT_EQ(pointer_events[1].x, 4.0);
684 EXPECT_EQ(pointer_events[1].y, 8.0);
685 EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
686 EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
687 EXPECT_EQ(pointer_events[1].view_id, 42);
688 EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
689 EXPECT_EQ(pointer_events[2].x, 5.0);
690 EXPECT_EQ(pointer_events[2].y, 9.0);
691 EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
692 EXPECT_EQ(pointer_events[2].buttons, 0);
693 EXPECT_EQ(pointer_events[2].view_id, 42);
694}

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerButtonMousePrimary, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

◆ TEST_F() [4/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonReleaseForward   
)

Definition at line 361 of file fl_pointer_manager_test.cc.

361 {
362 StartEngine();
363
364 std::vector<FlutterPointerEvent> pointer_events;
365 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
366 SendPointerEvent,
367 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
368 size_t events_count) {
369 for (size_t i = 0; i < events_count; i++) {
370 pointer_events.push_back(events[i]);
371 }
372
373 return kSuccess;
374 }));
375
376 // Forward button is 9 (no GDK define).
377 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
378 fl_pointer_manager_handle_button_press(
379 manager, 1234, kFlutterPointerDeviceKindMouse, 4.0, 8.0, 9, 0, 0);
380 fl_pointer_manager_handle_button_release(
381 manager, 1235, kFlutterPointerDeviceKindMouse, 5.0, 9.0, 9, 0, 0);
382
383 EXPECT_EQ(pointer_events.size(), 3u);
384
385 // Ignore first synthetic enter event
386 EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
387 EXPECT_EQ(pointer_events[1].x, 4.0);
388 EXPECT_EQ(pointer_events[1].y, 8.0);
389 EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
390 EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMouseForward);
391 EXPECT_EQ(pointer_events[1].view_id, 42);
392 EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
393 EXPECT_EQ(pointer_events[2].x, 5.0);
394 EXPECT_EQ(pointer_events[2].y, 9.0);
395 EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
396 EXPECT_EQ(pointer_events[2].buttons, 0);
397 EXPECT_EQ(pointer_events[2].view_id, 42);
398}
kFlutterPointerButtonMouseForward
@ kFlutterPointerButtonMouseForward
Definition embedder.h:1324

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerButtonMouseForward, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

◆ TEST_F() [5/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonReleaseMiddle   
)

Definition at line 282 of file fl_pointer_manager_test.cc.

282 {
283 StartEngine();
284
285 std::vector<FlutterPointerEvent> pointer_events;
286 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
287 SendPointerEvent,
288 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
289 size_t events_count) {
290 for (size_t i = 0; i < events_count; i++) {
291 pointer_events.push_back(events[i]);
292 }
293
294 return kSuccess;
295 }));
296
297 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
298 fl_pointer_manager_handle_button_press(manager, 1234,
299 kFlutterPointerDeviceKindMouse, 4.0,
300 8.0, GDK_BUTTON_MIDDLE, 0, 0);
301 fl_pointer_manager_handle_button_release(manager, 1235,
302 kFlutterPointerDeviceKindMouse, 5.0,
303 9.0, GDK_BUTTON_MIDDLE, 0, 0);
304
305 EXPECT_EQ(pointer_events.size(), 3u);
306
307 // Ignore first synthetic enter event
308 EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
309 EXPECT_EQ(pointer_events[1].x, 4.0);
310 EXPECT_EQ(pointer_events[1].y, 8.0);
311 EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
312 EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMouseMiddle);
313 EXPECT_EQ(pointer_events[1].view_id, 42);
314 EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
315 EXPECT_EQ(pointer_events[2].x, 5.0);
316 EXPECT_EQ(pointer_events[2].y, 9.0);
317 EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
318 EXPECT_EQ(pointer_events[2].buttons, 0);
319 EXPECT_EQ(pointer_events[2].view_id, 42);
320}
kFlutterPointerButtonMouseMiddle
@ kFlutterPointerButtonMouseMiddle
Definition embedder.h:1322

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerButtonMouseMiddle, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

◆ TEST_F() [6/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonReleasePrimary   
)

Definition at line 202 of file fl_pointer_manager_test.cc.

202 {
203 StartEngine();
204
205 std::vector<FlutterPointerEvent> pointer_events;
206 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
207 SendPointerEvent,
208 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
209 size_t events_count) {
210 for (size_t i = 0; i < events_count; i++) {
211 pointer_events.push_back(events[i]);
212 }
213
214 return kSuccess;
215 }));
216
217 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
218 fl_pointer_manager_handle_button_press(manager, 1234,
219 kFlutterPointerDeviceKindMouse, 4.0,
220 8.0, GDK_BUTTON_PRIMARY, 0, 0);
221 fl_pointer_manager_handle_button_release(manager, 1235,
222 kFlutterPointerDeviceKindMouse, 5.0,
223 9.0, GDK_BUTTON_PRIMARY, 0, 0);
224
225 EXPECT_EQ(pointer_events.size(), 3u);
226
227 // Ignore first synthetic enter event
228 EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
229 EXPECT_EQ(pointer_events[1].x, 4.0);
230 EXPECT_EQ(pointer_events[1].y, 8.0);
231 EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
232 EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
233 EXPECT_EQ(pointer_events[1].view_id, 42);
234 EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
235 EXPECT_EQ(pointer_events[2].x, 5.0);
236 EXPECT_EQ(pointer_events[2].y, 9.0);
237 EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
238 EXPECT_EQ(pointer_events[2].buttons, 0);
239 EXPECT_EQ(pointer_events[2].view_id, 42);
240}

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerButtonMousePrimary, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

◆ TEST_F() [7/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonReleaseSecondary   
)

Definition at line 242 of file fl_pointer_manager_test.cc.

242 {
243 StartEngine();
244
245 std::vector<FlutterPointerEvent> pointer_events;
246 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
247 SendPointerEvent,
248 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
249 size_t events_count) {
250 for (size_t i = 0; i < events_count; i++) {
251 pointer_events.push_back(events[i]);
252 }
253
254 return kSuccess;
255 }));
256
257 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
258 fl_pointer_manager_handle_button_press(manager, 1234,
259 kFlutterPointerDeviceKindMouse, 4.0,
260 8.0, GDK_BUTTON_SECONDARY, 0, 0);
261 fl_pointer_manager_handle_button_release(manager, 1235,
262 kFlutterPointerDeviceKindMouse, 5.0,
263 9.0, GDK_BUTTON_SECONDARY, 0, 0);
264
265 EXPECT_EQ(pointer_events.size(), 3u);
266
267 // Ignore first synthetic enter event
268 EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
269 EXPECT_EQ(pointer_events[1].x, 4.0);
270 EXPECT_EQ(pointer_events[1].y, 8.0);
271 EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
272 EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMouseSecondary);
273 EXPECT_EQ(pointer_events[1].view_id, 42);
274 EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
275 EXPECT_EQ(pointer_events[2].x, 5.0);
276 EXPECT_EQ(pointer_events[2].y, 9.0);
277 EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
278 EXPECT_EQ(pointer_events[2].buttons, 0);
279 EXPECT_EQ(pointer_events[2].view_id, 42);
280}
kFlutterPointerButtonMouseSecondary
@ kFlutterPointerButtonMouseSecondary
Definition embedder.h:1321

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerButtonMouseSecondary, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

◆ TEST_F() [8/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressButtonReleaseThreeButtons   
)

Definition at line 400 of file fl_pointer_manager_test.cc.

400 {
401 StartEngine();
402
403 std::vector<FlutterPointerEvent> pointer_events;
404 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
405 SendPointerEvent,
406 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
407 size_t events_count) {
408 for (size_t i = 0; i < events_count; i++) {
409 pointer_events.push_back(events[i]);
410 }
411
412 return kSuccess;
413 }));
414
415 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
416 // Press buttons 1-2-3, release 3-2-1
417 fl_pointer_manager_handle_button_press(manager, 1234,
418 kFlutterPointerDeviceKindMouse, 1.0,
419 2.0, GDK_BUTTON_PRIMARY, 0, 0);
420 fl_pointer_manager_handle_button_press(manager, 1235,
421 kFlutterPointerDeviceKindMouse, 3.0,
422 4.0, GDK_BUTTON_SECONDARY, 0, 0);
423 fl_pointer_manager_handle_button_press(manager, 1236,
424 kFlutterPointerDeviceKindMouse, 5.0,
425 6.0, GDK_BUTTON_MIDDLE, 0, 0);
426 fl_pointer_manager_handle_button_release(manager, 1237,
427 kFlutterPointerDeviceKindMouse, 7.0,
428 8.0, GDK_BUTTON_MIDDLE, 0, 0);
429 fl_pointer_manager_handle_button_release(manager, 1238,
430 kFlutterPointerDeviceKindMouse, 9.0,
431 10.0, GDK_BUTTON_SECONDARY, 0, 0);
432 fl_pointer_manager_handle_button_release(
433 manager, 1239, kFlutterPointerDeviceKindMouse, 11.0, 12.0,
434 kFlutterPointerButtonMousePrimary, 0, 0);
435
436 EXPECT_EQ(pointer_events.size(), 7u);
437
438 // Ignore first synthetic enter event
439 EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
440 EXPECT_EQ(pointer_events[1].x, 1.0);
441 EXPECT_EQ(pointer_events[1].y, 2.0);
442 EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
443 EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
444 EXPECT_EQ(pointer_events[2].x, 3.0);
445 EXPECT_EQ(pointer_events[2].y, 4.0);
446 EXPECT_EQ(pointer_events[2].buttons, kFlutterPointerButtonMousePrimary |
447 kFlutterPointerButtonMouseSecondary);
448 EXPECT_EQ(pointer_events[3].timestamp, 1236000u);
449 EXPECT_EQ(pointer_events[3].x, 5.0);
450 EXPECT_EQ(pointer_events[3].y, 6.0);
451 EXPECT_EQ(pointer_events[3].buttons, kFlutterPointerButtonMousePrimary |
452 kFlutterPointerButtonMouseSecondary |
453 kFlutterPointerButtonMouseMiddle);
454 EXPECT_EQ(pointer_events[4].timestamp, 1237000u);
455 EXPECT_EQ(pointer_events[4].x, 7.0);
456 EXPECT_EQ(pointer_events[4].y, 8.0);
457 EXPECT_EQ(pointer_events[4].buttons, kFlutterPointerButtonMousePrimary |
458 kFlutterPointerButtonMouseSecondary);
459 EXPECT_EQ(pointer_events[5].timestamp, 1238000u);
460 EXPECT_EQ(pointer_events[5].x, 9.0);
461 EXPECT_EQ(pointer_events[5].y, 10.0);
462 EXPECT_EQ(pointer_events[5].buttons, kFlutterPointerButtonMousePrimary);
463 EXPECT_EQ(pointer_events[6].timestamp, 1239000u);
464 EXPECT_EQ(pointer_events[6].x, 11.0);
465 EXPECT_EQ(pointer_events[6].y, 12.0);
466 EXPECT_EQ(pointer_events[6].buttons, 0);
467}

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerButtonMouseMiddle, kFlutterPointerButtonMousePrimary, kFlutterPointerButtonMouseSecondary, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, x, and y.

◆ TEST_F() [9/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressInvertedStylusContact   
)

Definition at line 527 of file fl_pointer_manager_test.cc.

527 {
528 StartEngine();
529
530 constexpr int64_t kStylusContact = 1 << 0;
531
532 std::vector<FlutterPointerEvent> pointer_events;
533 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
534 SendPointerEvent,
535 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
536 size_t events_count) {
537 for (size_t i = 0; i < events_count; i++) {
538 pointer_events.push_back(events[i]);
539 }
540
541 return kSuccess;
542 }));
543
544 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
545 fl_pointer_manager_handle_button_press(
546 manager, 1234, kFlutterPointerDeviceKindInvertedStylus, 4.0, 8.0,
547 GDK_BUTTON_PRIMARY, 0.0, 0.5);
548
549 EXPECT_EQ(pointer_events.size(), 2u);
550 EXPECT_EQ(pointer_events[1].device_kind,
551 kFlutterPointerDeviceKindInvertedStylus);
552 EXPECT_EQ(pointer_events[1].buttons, kStylusContact);
553}
kFlutterPointerDeviceKindInvertedStylus
@ kFlutterPointerDeviceKindInvertedStylus
Definition embedder.h:1314

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerDeviceKindInvertedStylus, kSuccess, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPointerEvent.

◆ TEST_F() [10/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressStylusContact   
)

Definition at line 500 of file fl_pointer_manager_test.cc.

500 {
501 StartEngine();
502
503 constexpr int64_t kStylusContact = 1 << 0;
504
505 std::vector<FlutterPointerEvent> pointer_events;
506 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
507 SendPointerEvent,
508 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
509 size_t events_count) {
510 for (size_t i = 0; i < events_count; i++) {
511 pointer_events.push_back(events[i]);
512 }
513
514 return kSuccess;
515 }));
516
517 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
518 fl_pointer_manager_handle_button_press(manager, 1234,
519 kFlutterPointerDeviceKindStylus, 4.0,
520 8.0, GDK_BUTTON_PRIMARY, 0.0, 0.5);
521
522 EXPECT_EQ(pointer_events.size(), 2u);
523 EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindStylus);
524 EXPECT_EQ(pointer_events[1].buttons, kStylusContact);
525}
kFlutterPointerDeviceKindStylus
@ kFlutterPointerDeviceKindStylus
Definition embedder.h:1312

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerDeviceKindStylus, kSuccess, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPointerEvent.

◆ TEST_F() [11/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressStylusPrimaryButton   
)

Definition at line 469 of file fl_pointer_manager_test.cc.

469 {
470 StartEngine();
471
472 constexpr int64_t kStylusContact = 1 << 0;
473 constexpr int64_t kStylusPrimary = 1 << 1;
474
475 std::vector<FlutterPointerEvent> pointer_events;
476 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
477 SendPointerEvent,
478 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
479 size_t events_count) {
480 for (size_t i = 0; i < events_count; i++) {
481 pointer_events.push_back(events[i]);
482 }
483
484 return kSuccess;
485 }));
486
487 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
488 fl_pointer_manager_handle_button_press(manager, 1234,
489 kFlutterPointerDeviceKindStylus, 4.0,
490 8.0, GDK_BUTTON_PRIMARY, 0.0, 0.5);
491 fl_pointer_manager_handle_button_press(manager, 1235,
492 kFlutterPointerDeviceKindStylus, 4.0,
493 8.0, GDK_BUTTON_SECONDARY, 0.0, 0.5);
494
495 EXPECT_EQ(pointer_events.size(), 3u);
496 EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindStylus);
497 EXPECT_EQ(pointer_events[2].buttons, kStylusContact | kStylusPrimary);
498}

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerDeviceKindStylus, kSuccess, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPointerEvent.

◆ TEST_F() [12/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressStylusSecondaryButton   
)

Definition at line 555 of file fl_pointer_manager_test.cc.

555 {
556 StartEngine();
557
558 constexpr int64_t kStylusContact = 1 << 0;
559 constexpr int64_t kStylusSecondary = 1 << 2;
560
561 std::vector<FlutterPointerEvent> pointer_events;
562 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
563 SendPointerEvent,
564 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
565 size_t events_count) {
566 for (size_t i = 0; i < events_count; i++) {
567 pointer_events.push_back(events[i]);
568 }
569
570 return kSuccess;
571 }));
572
573 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
574 fl_pointer_manager_handle_button_press(manager, 1234,
575 kFlutterPointerDeviceKindStylus, 4.0,
576 8.0, GDK_BUTTON_PRIMARY, 0.0, 0.5);
577 fl_pointer_manager_handle_button_press(manager, 1235,
578 kFlutterPointerDeviceKindStylus, 4.0,
579 8.0, GDK_BUTTON_MIDDLE, 0.0, 0.5);
580
581 EXPECT_EQ(pointer_events.size(), 3u);
582 EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindStylus);
583 EXPECT_EQ(pointer_events[2].buttons, kStylusContact | kStylusSecondary);
584}

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerDeviceKindStylus, kSuccess, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPointerEvent.

◆ TEST_F() [13/22]

TEST_F ( FlPointerManagerTest  ,
ButtonPressStylusUnknownButton   
)

Definition at line 586 of file fl_pointer_manager_test.cc.

586 {
587 StartEngine();
588
589 std::vector<FlutterPointerEvent> pointer_events;
590 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
591 SendPointerEvent,
592 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
593 size_t events_count) {
594 for (size_t i = 0; i < events_count; i++) {
595 pointer_events.push_back(events[i]);
596 }
597
598 return kSuccess;
599 }));
600
601 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
602 fl_pointer_manager_handle_button_press(
603 manager, 1234, kFlutterPointerDeviceKindStylus, 4.0, 8.0, 8, 0, 0);
604
605 EXPECT_EQ(pointer_events.size(), 0u);
606}

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerDeviceKindStylus, kSuccess, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPointerEvent.

◆ TEST_F() [14/22]

TEST_F ( FlPointerManagerTest  ,
DeviceKind   
)

Definition at line 825 of file fl_pointer_manager_test.cc.

825 {
826 StartEngine();
827
828 std::vector<FlutterPointerEvent> pointer_events;
829 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
830 SendPointerEvent,
831 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
832 size_t events_count) {
833 for (size_t i = 0; i < events_count; i++) {
834 pointer_events.push_back(events[i]);
835 }
836
837 return kSuccess;
838 }));
839
840 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
841 fl_pointer_manager_handle_enter(
842 manager, 1234, kFlutterPointerDeviceKindTrackpad, 1.0, 2.0, 0, 0);
843 fl_pointer_manager_handle_button_press(manager, 1235,
844 kFlutterPointerDeviceKindTrackpad, 1.0,
845 2.0, GDK_BUTTON_PRIMARY, 0, 0);
846 fl_pointer_manager_handle_motion(
847 manager, 1238, kFlutterPointerDeviceKindTrackpad, 3.0, 4.0, 0, 0);
848 fl_pointer_manager_handle_button_release(manager, 1237,
849 kFlutterPointerDeviceKindTrackpad,
850 3.0, 4.0, GDK_BUTTON_PRIMARY, 0, 0);
851 fl_pointer_manager_handle_leave(
852 manager, 1235, kFlutterPointerDeviceKindTrackpad, 3.0, 4.0, 0, 0);
853
854 EXPECT_EQ(pointer_events.size(), 5u);
855
856 EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindTrackpad);
857 EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindTrackpad);
858 EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindTrackpad);
859 EXPECT_EQ(pointer_events[3].device_kind, kFlutterPointerDeviceKindTrackpad);
860 EXPECT_EQ(pointer_events[4].device_kind, kFlutterPointerDeviceKindTrackpad);
861}
kFlutterPointerDeviceKindTrackpad
@ kFlutterPointerDeviceKindTrackpad
Definition embedder.h:1313
fl_pointer_manager_handle_enter
gboolean fl_pointer_manager_handle_enter(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, gdouble rotation, gdouble pressure)
Definition fl_pointer_manager.cc:235
fl_pointer_manager_handle_motion
gboolean fl_pointer_manager_handle_motion(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, gdouble rotation, gdouble pressure)
Definition fl_pointer_manager.cc:211
fl_pointer_manager_handle_leave
gboolean fl_pointer_manager_handle_leave(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y, gdouble rotation, gdouble pressure)
Definition fl_pointer_manager.cc:254

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_handle_enter(), fl_pointer_manager_handle_leave(), fl_pointer_manager_handle_motion(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerDeviceKindTrackpad, kSuccess, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPointerEvent.

◆ TEST_F() [15/22]

TEST_F ( FlPointerManagerTest  ,
Drag   
)

Definition at line 766 of file fl_pointer_manager_test.cc.

766 {
767 StartEngine();
768
769 std::vector<FlutterPointerEvent> pointer_events;
770 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
771 SendPointerEvent,
772 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
773 size_t events_count) {
774 for (size_t i = 0; i < events_count; i++) {
775 pointer_events.push_back(events[i]);
776 }
777
778 return kSuccess;
779 }));
780
781 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
782 fl_pointer_manager_handle_motion(
783 manager, 1234, kFlutterPointerDeviceKindMouse, 1.0, 2.0, 0, 0);
784 fl_pointer_manager_handle_button_press(manager, 1235,
785 kFlutterPointerDeviceKindMouse, 3.0,
786 4.0, GDK_BUTTON_PRIMARY, 0, 0);
787 fl_pointer_manager_handle_motion(
788 manager, 1236, kFlutterPointerDeviceKindMouse, 5.0, 6.0, 0, 0);
789 fl_pointer_manager_handle_button_release(manager, 1237,
790 kFlutterPointerDeviceKindMouse, 7.0,
791 8.0, GDK_BUTTON_PRIMARY, 0, 0);
792 fl_pointer_manager_handle_motion(
793 manager, 1238, kFlutterPointerDeviceKindMouse, 9.0, 10.0, 0, 0);
794
795 EXPECT_EQ(pointer_events.size(), 6u);
796
797 // Ignore first synthetic enter event
798 EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
799 EXPECT_EQ(pointer_events[1].x, 1.0);
800 EXPECT_EQ(pointer_events[1].y, 2.0);
801 EXPECT_EQ(pointer_events[1].buttons, 0);
802 EXPECT_EQ(pointer_events[1].view_id, 42);
803 EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
804 EXPECT_EQ(pointer_events[2].x, 3.0);
805 EXPECT_EQ(pointer_events[2].y, 4.0);
806 EXPECT_EQ(pointer_events[2].buttons, kFlutterPointerButtonMousePrimary);
807 EXPECT_EQ(pointer_events[2].view_id, 42);
808 EXPECT_EQ(pointer_events[3].timestamp, 1236000u);
809 EXPECT_EQ(pointer_events[3].x, 5.0);
810 EXPECT_EQ(pointer_events[3].y, 6.0);
811 EXPECT_EQ(pointer_events[3].buttons, kFlutterPointerButtonMousePrimary);
812 EXPECT_EQ(pointer_events[3].view_id, 42);
813 EXPECT_EQ(pointer_events[4].timestamp, 1237000u);
814 EXPECT_EQ(pointer_events[4].x, 7.0);
815 EXPECT_EQ(pointer_events[4].y, 8.0);
816 EXPECT_EQ(pointer_events[4].buttons, 0);
817 EXPECT_EQ(pointer_events[4].view_id, 42);
818 EXPECT_EQ(pointer_events[5].timestamp, 1238000u);
819 EXPECT_EQ(pointer_events[5].x, 9.0);
820 EXPECT_EQ(pointer_events[5].y, 10.0);
821 EXPECT_EQ(pointer_events[5].buttons, 0);
822 EXPECT_EQ(pointer_events[5].view_id, 42);
823}

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_handle_motion(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerButtonMousePrimary, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

◆ TEST_F() [16/22]

TEST_F ( FlPointerManagerTest  ,
EnterButtonPress   
)

Definition at line 125 of file fl_pointer_manager_test.cc.

125 {
126 StartEngine();
127
128 std::vector<FlutterPointerEvent> pointer_events;
129 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
130 SendPointerEvent,
131 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
132 size_t events_count) {
133 for (size_t i = 0; i < events_count; i++) {
134 pointer_events.push_back(events[i]);
135 }
136
137 return kSuccess;
138 }));
139
140 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
141 fl_pointer_manager_handle_enter(manager, 1234, kFlutterPointerDeviceKindMouse,
142 1.0, 2.0, 0, 0);
143 fl_pointer_manager_handle_button_press(manager, 1235,
144 kFlutterPointerDeviceKindMouse, 4.0,
145 8.0, GDK_BUTTON_PRIMARY, 0, 0);
146
147 EXPECT_EQ(pointer_events.size(), 2u);
148
149 EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
150 EXPECT_EQ(pointer_events[0].x, 1.0);
151 EXPECT_EQ(pointer_events[0].y, 2.0);
152 EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
153 EXPECT_EQ(pointer_events[0].buttons, 0);
154 EXPECT_EQ(pointer_events[0].view_id, 42);
155
156 EXPECT_EQ(pointer_events[1].timestamp, 1235000u);
157 EXPECT_EQ(pointer_events[1].x, 4.0);
158 EXPECT_EQ(pointer_events[1].y, 8.0);
159 EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
160 EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
161 EXPECT_EQ(pointer_events[1].view_id, 42);
162}

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_enter(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerButtonMousePrimary, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

◆ TEST_F() [17/22]

TEST_F ( FlPointerManagerTest  ,
EnterEnter   
)

Definition at line 52 of file fl_pointer_manager_test.cc.

52 {
53 StartEngine();
54
55 std::vector<FlutterPointerEvent> pointer_events;
56 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
57 SendPointerEvent,
58 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
59 size_t events_count) {
60 for (size_t i = 0; i < events_count; i++) {
61 pointer_events.push_back(events[i]);
62 }
63
64 return kSuccess;
65 }));
66
67 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
68 fl_pointer_manager_handle_enter(manager, 1234, kFlutterPointerDeviceKindMouse,
69 1.0, 2.0, 0, 0);
70 // Duplicate enter is ignored
71 fl_pointer_manager_handle_enter(manager, 1235, kFlutterPointerDeviceKindMouse,
72 3.0, 4.0, 0, 0);
73
74 EXPECT_EQ(pointer_events.size(), 1u);
75
76 EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
77 EXPECT_EQ(pointer_events[0].x, 1.0);
78 EXPECT_EQ(pointer_events[0].y, 2.0);
79 EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
80 EXPECT_EQ(pointer_events[0].buttons, 0);
81 EXPECT_EQ(pointer_events[0].view_id, 42);
82}

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_enter(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

◆ TEST_F() [18/22]

TEST_F ( FlPointerManagerTest  ,
EnterLeave   
)

Definition at line 14 of file fl_pointer_manager_test.cc.

14 {
15 StartEngine();
16
17 std::vector<FlutterPointerEvent> pointer_events;
18 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
19 SendPointerEvent,
20 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
21 size_t events_count) {
22 for (size_t i = 0; i < events_count; i++) {
23 pointer_events.push_back(events[i]);
24 }
25
26 return kSuccess;
27 }));
28
29 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
30 fl_pointer_manager_handle_enter(manager, 1234, kFlutterPointerDeviceKindMouse,
31 1.0, 2.0, 0, 0);
32 fl_pointer_manager_handle_leave(manager, 1235, kFlutterPointerDeviceKindMouse,
33 3.0, 4.0, 0, 0);
34
35 EXPECT_EQ(pointer_events.size(), 2u);
36
37 EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
38 EXPECT_EQ(pointer_events[0].x, 1.0);
39 EXPECT_EQ(pointer_events[0].y, 2.0);
40 EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
41 EXPECT_EQ(pointer_events[0].buttons, 0);
42 EXPECT_EQ(pointer_events[0].view_id, 42);
43
44 EXPECT_EQ(pointer_events[1].timestamp, 1235000u);
45 EXPECT_EQ(pointer_events[1].x, 3.0);
46 EXPECT_EQ(pointer_events[1].y, 4.0);
47 EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
48 EXPECT_EQ(pointer_events[1].buttons, 0);
49 EXPECT_EQ(pointer_events[1].view_id, 42);
50}

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_enter(), fl_pointer_manager_handle_leave(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

◆ TEST_F() [19/22]

TEST_F ( FlPointerManagerTest  ,
EnterLeaveLeave   
)

Definition at line 84 of file fl_pointer_manager_test.cc.

84 {
85 StartEngine();
86
87 std::vector<FlutterPointerEvent> pointer_events;
88 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
89 SendPointerEvent,
90 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
91 size_t events_count) {
92 for (size_t i = 0; i < events_count; i++) {
93 pointer_events.push_back(events[i]);
94 }
95
96 return kSuccess;
97 }));
98
99 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
100 fl_pointer_manager_handle_enter(manager, 1234, kFlutterPointerDeviceKindMouse,
101 1.0, 2.0, 0, 0);
102 fl_pointer_manager_handle_leave(manager, 1235, kFlutterPointerDeviceKindMouse,
103 3.0, 4.0, 0, 0);
104 // Duplicate leave is ignored
105 fl_pointer_manager_handle_leave(manager, 1235, kFlutterPointerDeviceKindMouse,
106 5.0, 6.0, 0, 0);
107
108 EXPECT_EQ(pointer_events.size(), 2u);
109
110 EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
111 EXPECT_EQ(pointer_events[0].x, 1.0);
112 EXPECT_EQ(pointer_events[0].y, 2.0);
113 EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
114 EXPECT_EQ(pointer_events[0].buttons, 0);
115 EXPECT_EQ(pointer_events[0].view_id, 42);
116
117 EXPECT_EQ(pointer_events[1].timestamp, 1235000u);
118 EXPECT_EQ(pointer_events[1].x, 3.0);
119 EXPECT_EQ(pointer_events[1].y, 4.0);
120 EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
121 EXPECT_EQ(pointer_events[1].buttons, 0);
122 EXPECT_EQ(pointer_events[1].view_id, 42);
123}

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_enter(), fl_pointer_manager_handle_leave(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

◆ TEST_F() [20/22]

TEST_F ( FlPointerManagerTest  ,
Motion   
)

Definition at line 720 of file fl_pointer_manager_test.cc.

720 {
721 StartEngine();
722
723 std::vector<FlutterPointerEvent> pointer_events;
724 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
725 SendPointerEvent,
726 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
727 size_t events_count) {
728 for (size_t i = 0; i < events_count; i++) {
729 pointer_events.push_back(events[i]);
730 }
731
732 return kSuccess;
733 }));
734
735 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
736 fl_pointer_manager_handle_motion(
737 manager, 1234, kFlutterPointerDeviceKindMouse, 1.0, 2.0, 0, 0);
738 fl_pointer_manager_handle_motion(
739 manager, 1235, kFlutterPointerDeviceKindMouse, 3.0, 4.0, 0, 0);
740 fl_pointer_manager_handle_motion(
741 manager, 1236, kFlutterPointerDeviceKindMouse, 5.0, 6.0, 0, 0);
742
743 EXPECT_EQ(pointer_events.size(), 4u);
744
745 // Ignore first synthetic enter event
746 EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
747 EXPECT_EQ(pointer_events[1].x, 1.0);
748 EXPECT_EQ(pointer_events[1].y, 2.0);
749 EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
750 EXPECT_EQ(pointer_events[1].buttons, 0);
751 EXPECT_EQ(pointer_events[1].view_id, 42);
752 EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
753 EXPECT_EQ(pointer_events[2].x, 3.0);
754 EXPECT_EQ(pointer_events[2].y, 4.0);
755 EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
756 EXPECT_EQ(pointer_events[2].buttons, 0);
757 EXPECT_EQ(pointer_events[2].view_id, 42);
758 EXPECT_EQ(pointer_events[3].timestamp, 1236000u);
759 EXPECT_EQ(pointer_events[3].x, 5.0);
760 EXPECT_EQ(pointer_events[3].y, 6.0);
761 EXPECT_EQ(pointer_events[3].device_kind, kFlutterPointerDeviceKindMouse);
762 EXPECT_EQ(pointer_events[3].buttons, 0);
763 EXPECT_EQ(pointer_events[3].view_id, 42);
764}

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_motion(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

◆ TEST_F() [21/22]

TEST_F ( FlPointerManagerTest  ,
NoButtonPressButtonRelease   
)

Definition at line 696 of file fl_pointer_manager_test.cc.

696 {
697 StartEngine();
698
699 std::vector<FlutterPointerEvent> pointer_events;
700 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
701 SendPointerEvent,
702 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
703 size_t events_count) {
704 for (size_t i = 0; i < events_count; i++) {
705 pointer_events.push_back(events[i]);
706 }
707
708 return kSuccess;
709 }));
710
711 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
712 // Release without associated press, will be ignored
713 fl_pointer_manager_handle_button_release(manager, 1235,
714 kFlutterPointerDeviceKindMouse, 5.0,
715 9.0, GDK_BUTTON_PRIMARY, 0, 0);
716
717 EXPECT_EQ(pointer_events.size(), 0u);
718}

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPointerEvent.

◆ TEST_F() [22/22]

TEST_F ( FlPointerManagerTest  ,
NoEnterButtonPress   
)

Definition at line 164 of file fl_pointer_manager_test.cc.

164 {
165 StartEngine();
166
167 std::vector<FlutterPointerEvent> pointer_events;
168 fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
169 SendPointerEvent,
170 ([&pointer_events](auto engine, const FlutterPointerEvent* events,
171 size_t events_count) {
172 for (size_t i = 0; i < events_count; i++) {
173 pointer_events.push_back(events[i]);
174 }
175
176 return kSuccess;
177 }));
178
179 g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
180 fl_pointer_manager_handle_button_press(manager, 1234,
181 kFlutterPointerDeviceKindMouse, 4.0,
182 8.0, GDK_BUTTON_PRIMARY, 0, 0);
183
184 EXPECT_EQ(pointer_events.size(), 2u);
185
186 // Synthetic enter events
187 EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
188 EXPECT_EQ(pointer_events[0].x, 4.0);
189 EXPECT_EQ(pointer_events[0].y, 8.0);
190 EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
191 EXPECT_EQ(pointer_events[0].buttons, 0);
192 EXPECT_EQ(pointer_events[0].view_id, 42);
193
194 EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
195 EXPECT_EQ(pointer_events[1].x, 4.0);
196 EXPECT_EQ(pointer_events[1].y, 8.0);
197 EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
198 EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
199 EXPECT_EQ(pointer_events[1].view_id, 42);
200}

References engine, fl_engine_get_embedder_api(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_new(), g_autoptr(), i, kFlutterPointerButtonMousePrimary, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.