Flutter Linux Embedder
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 "gtest/gtest.h"

Go to the source code of this file.

Functions

 TEST (FlPointerManagerTest, EnterLeave)
 
 TEST (FlPointerManagerTest, EnterEnter)
 
 TEST (FlPointerManagerTest, EnterLeaveLeave)
 
 TEST (FlPointerManagerTest, EnterButtonPress)
 
 TEST (FlPointerManagerTest, NoEnterButtonPress)
 
 TEST (FlPointerManagerTest, ButtonPressButtonRelease)
 
 TEST (FlPointerManagerTest, ButtonPressButtonReleaseThreeButtons)
 
 TEST (FlPointerManagerTest, ButtonPressButtonPressButtonRelease)
 
 TEST (FlPointerManagerTest, ButtonPressButtonReleaseButtonRelease)
 
 TEST (FlPointerManagerTest, NoButtonPressButtonRelease)
 
 TEST (FlPointerManagerTest, Motion)
 
 TEST (FlPointerManagerTest, Drag)
 
 TEST (FlPointerManagerTest, DeviceKind)
 

Function Documentation

◆ TEST() [1/13]

TEST ( FlPointerManagerTest  ,
ButtonPressButtonPressButtonRelease   
)

Definition at line 343 of file fl_pointer_manager_test.cc.

343  {
344  g_autoptr(FlDartProject) project = fl_dart_project_new();
345  g_autoptr(FlEngine) engine = fl_engine_new(project);
346 
347  g_autoptr(GError) error = nullptr;
348  EXPECT_TRUE(fl_engine_start(engine, &error));
349  EXPECT_EQ(error, nullptr);
350 
351  std::vector<FlutterPointerEvent> pointer_events;
352  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
353  SendPointerEvent,
354  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
355  size_t events_count) {
356  for (size_t i = 0; i < events_count; i++) {
357  pointer_events.push_back(events[i]);
358  }
359 
360  return kSuccess;
361  }));
362 
363  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
364  fl_pointer_manager_handle_button_press(
365  manager, 1234, kFlutterPointerDeviceKindMouse, 4.0, 8.0,
366  kFlutterPointerButtonMousePrimary);
367  // Ignore duplicate press
368  fl_pointer_manager_handle_button_press(
369  manager, 1234, kFlutterPointerDeviceKindMouse, 6.0, 10.0,
370  kFlutterPointerButtonMousePrimary);
371  fl_pointer_manager_handle_button_release(
372  manager, 1235, kFlutterPointerDeviceKindMouse, 5.0, 9.0,
373  kFlutterPointerButtonMousePrimary);
374 
375  EXPECT_EQ(pointer_events.size(), 3u);
376 
377  // Ignore first synthetic enter event
378  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
379  EXPECT_EQ(pointer_events[1].x, 4.0);
380  EXPECT_EQ(pointer_events[1].y, 8.0);
381  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
382  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
383  EXPECT_EQ(pointer_events[1].view_id, 42);
384  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
385  EXPECT_EQ(pointer_events[2].x, 5.0);
386  EXPECT_EQ(pointer_events[2].y, 9.0);
387  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
388  EXPECT_EQ(pointer_events[2].buttons, 0);
389  EXPECT_EQ(pointer_events[2].view_id, 42);
390 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), and i.

◆ TEST() [2/13]

TEST ( FlPointerManagerTest  ,
ButtonPressButtonRelease   
)

Definition at line 224 of file fl_pointer_manager_test.cc.

224  {
225  g_autoptr(FlDartProject) project = fl_dart_project_new();
226  g_autoptr(FlEngine) engine = fl_engine_new(project);
227 
228  g_autoptr(GError) error = nullptr;
229  EXPECT_TRUE(fl_engine_start(engine, &error));
230  EXPECT_EQ(error, nullptr);
231 
232  std::vector<FlutterPointerEvent> pointer_events;
233  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
234  SendPointerEvent,
235  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
236  size_t events_count) {
237  for (size_t i = 0; i < events_count; i++) {
238  pointer_events.push_back(events[i]);
239  }
240 
241  return kSuccess;
242  }));
243 
244  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
245  fl_pointer_manager_handle_button_press(
246  manager, 1234, kFlutterPointerDeviceKindMouse, 4.0, 8.0,
247  kFlutterPointerButtonMousePrimary);
248  fl_pointer_manager_handle_button_release(
249  manager, 1235, kFlutterPointerDeviceKindMouse, 5.0, 9.0,
250  kFlutterPointerButtonMousePrimary);
251 
252  EXPECT_EQ(pointer_events.size(), 3u);
253 
254  // Ignore first synthetic enter event
255  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
256  EXPECT_EQ(pointer_events[1].x, 4.0);
257  EXPECT_EQ(pointer_events[1].y, 8.0);
258  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
259  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
260  EXPECT_EQ(pointer_events[1].view_id, 42);
261  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
262  EXPECT_EQ(pointer_events[2].x, 5.0);
263  EXPECT_EQ(pointer_events[2].y, 9.0);
264  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
265  EXPECT_EQ(pointer_events[2].buttons, 0);
266  EXPECT_EQ(pointer_events[2].view_id, 42);
267 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), and i.

◆ TEST() [3/13]

TEST ( FlPointerManagerTest  ,
ButtonPressButtonReleaseButtonRelease   
)

Definition at line 392 of file fl_pointer_manager_test.cc.

392  {
393  g_autoptr(FlDartProject) project = fl_dart_project_new();
394  g_autoptr(FlEngine) engine = fl_engine_new(project);
395 
396  g_autoptr(GError) error = nullptr;
397  EXPECT_TRUE(fl_engine_start(engine, &error));
398  EXPECT_EQ(error, nullptr);
399 
400  std::vector<FlutterPointerEvent> pointer_events;
401  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
402  SendPointerEvent,
403  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
404  size_t events_count) {
405  for (size_t i = 0; i < events_count; i++) {
406  pointer_events.push_back(events[i]);
407  }
408 
409  return kSuccess;
410  }));
411 
412  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
413  fl_pointer_manager_handle_button_press(
414  manager, 1234, kFlutterPointerDeviceKindMouse, 4.0, 8.0,
415  kFlutterPointerButtonMousePrimary);
416  fl_pointer_manager_handle_button_release(
417  manager, 1235, kFlutterPointerDeviceKindMouse, 5.0, 9.0,
418  kFlutterPointerButtonMousePrimary);
419  // Ignore duplicate release
420  fl_pointer_manager_handle_button_release(
421  manager, 1235, kFlutterPointerDeviceKindMouse, 6.0, 10.0,
422  kFlutterPointerButtonMousePrimary);
423 
424  EXPECT_EQ(pointer_events.size(), 3u);
425 
426  // Ignore first synthetic enter event
427  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
428  EXPECT_EQ(pointer_events[1].x, 4.0);
429  EXPECT_EQ(pointer_events[1].y, 8.0);
430  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
431  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
432  EXPECT_EQ(pointer_events[1].view_id, 42);
433  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
434  EXPECT_EQ(pointer_events[2].x, 5.0);
435  EXPECT_EQ(pointer_events[2].y, 9.0);
436  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
437  EXPECT_EQ(pointer_events[2].buttons, 0);
438  EXPECT_EQ(pointer_events[2].view_id, 42);
439 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), and i.

◆ TEST() [4/13]

TEST ( FlPointerManagerTest  ,
ButtonPressButtonReleaseThreeButtons   
)

Definition at line 269 of file fl_pointer_manager_test.cc.

269  {
270  g_autoptr(FlDartProject) project = fl_dart_project_new();
271  g_autoptr(FlEngine) engine = fl_engine_new(project);
272 
273  g_autoptr(GError) error = nullptr;
274  EXPECT_TRUE(fl_engine_start(engine, &error));
275  EXPECT_EQ(error, nullptr);
276 
277  std::vector<FlutterPointerEvent> pointer_events;
278  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
279  SendPointerEvent,
280  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
281  size_t events_count) {
282  for (size_t i = 0; i < events_count; i++) {
283  pointer_events.push_back(events[i]);
284  }
285 
286  return kSuccess;
287  }));
288 
289  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
290  // Press buttons 1-2-3, release 3-2-1
291  fl_pointer_manager_handle_button_press(
292  manager, 1234, kFlutterPointerDeviceKindMouse, 1.0, 2.0,
293  kFlutterPointerButtonMousePrimary);
294  fl_pointer_manager_handle_button_press(
295  manager, 1235, kFlutterPointerDeviceKindMouse, 3.0, 4.0,
296  kFlutterPointerButtonMouseSecondary);
297  fl_pointer_manager_handle_button_press(manager, 1236,
298  kFlutterPointerDeviceKindMouse, 5.0,
299  6.0, kFlutterPointerButtonMouseMiddle);
300  fl_pointer_manager_handle_button_release(
301  manager, 1237, kFlutterPointerDeviceKindMouse, 7.0, 8.0,
302  kFlutterPointerButtonMouseMiddle);
303  fl_pointer_manager_handle_button_release(
304  manager, 1238, kFlutterPointerDeviceKindMouse, 9.0, 10.0,
305  kFlutterPointerButtonMouseSecondary);
306  fl_pointer_manager_handle_button_release(
307  manager, 1239, kFlutterPointerDeviceKindMouse, 11.0, 12.0,
308  kFlutterPointerButtonMousePrimary);
309 
310  EXPECT_EQ(pointer_events.size(), 7u);
311 
312  // Ignore first synthetic enter event
313  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
314  EXPECT_EQ(pointer_events[1].x, 1.0);
315  EXPECT_EQ(pointer_events[1].y, 2.0);
316  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
317  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
318  EXPECT_EQ(pointer_events[2].x, 3.0);
319  EXPECT_EQ(pointer_events[2].y, 4.0);
320  EXPECT_EQ(pointer_events[2].buttons, kFlutterPointerButtonMousePrimary |
321  kFlutterPointerButtonMouseSecondary);
322  EXPECT_EQ(pointer_events[3].timestamp, 1236000u);
323  EXPECT_EQ(pointer_events[3].x, 5.0);
324  EXPECT_EQ(pointer_events[3].y, 6.0);
325  EXPECT_EQ(pointer_events[3].buttons, kFlutterPointerButtonMousePrimary |
326  kFlutterPointerButtonMouseSecondary |
327  kFlutterPointerButtonMouseMiddle);
328  EXPECT_EQ(pointer_events[4].timestamp, 1237000u);
329  EXPECT_EQ(pointer_events[4].x, 7.0);
330  EXPECT_EQ(pointer_events[4].y, 8.0);
331  EXPECT_EQ(pointer_events[4].buttons, kFlutterPointerButtonMousePrimary |
332  kFlutterPointerButtonMouseSecondary);
333  EXPECT_EQ(pointer_events[5].timestamp, 1238000u);
334  EXPECT_EQ(pointer_events[5].x, 9.0);
335  EXPECT_EQ(pointer_events[5].y, 10.0);
336  EXPECT_EQ(pointer_events[5].buttons, kFlutterPointerButtonMousePrimary);
337  EXPECT_EQ(pointer_events[6].timestamp, 1239000u);
338  EXPECT_EQ(pointer_events[6].x, 11.0);
339  EXPECT_EQ(pointer_events[6].y, 12.0);
340  EXPECT_EQ(pointer_events[6].buttons, 0);
341 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), and i.

◆ TEST() [5/13]

TEST ( FlPointerManagerTest  ,
DeviceKind   
)

Definition at line 585 of file fl_pointer_manager_test.cc.

585  {
586  g_autoptr(FlDartProject) project = fl_dart_project_new();
587  g_autoptr(FlEngine) engine = fl_engine_new(project);
588 
589  g_autoptr(GError) error = nullptr;
590  EXPECT_TRUE(fl_engine_start(engine, &error));
591  EXPECT_EQ(error, nullptr);
592 
593  std::vector<FlutterPointerEvent> pointer_events;
594  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
595  SendPointerEvent,
596  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
597  size_t events_count) {
598  for (size_t i = 0; i < events_count; i++) {
599  pointer_events.push_back(events[i]);
600  }
601 
602  return kSuccess;
603  }));
604 
605  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
606  fl_pointer_manager_handle_enter(manager, 1234,
607  kFlutterPointerDeviceKindTrackpad, 1.0, 2.0);
608  fl_pointer_manager_handle_button_press(
609  manager, 1235, kFlutterPointerDeviceKindTrackpad, 1.0, 2.0,
610  kFlutterPointerButtonMousePrimary);
611  fl_pointer_manager_handle_motion(manager, 1238,
612  kFlutterPointerDeviceKindTrackpad, 3.0, 4.0);
613  fl_pointer_manager_handle_button_release(
614  manager, 1237, kFlutterPointerDeviceKindTrackpad, 3.0, 4.0,
615  kFlutterPointerButtonMousePrimary);
616  fl_pointer_manager_handle_leave(manager, 1235,
617  kFlutterPointerDeviceKindTrackpad, 3.0, 4.0);
618 
619  EXPECT_EQ(pointer_events.size(), 5u);
620 
621  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindTrackpad);
622  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindTrackpad);
623  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindTrackpad);
624  EXPECT_EQ(pointer_events[3].device_kind, kFlutterPointerDeviceKindTrackpad);
625  EXPECT_EQ(pointer_events[4].device_kind, kFlutterPointerDeviceKindTrackpad);
626 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), 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(), and i.

◆ TEST() [6/13]

TEST ( FlPointerManagerTest  ,
Drag   
)

Definition at line 521 of file fl_pointer_manager_test.cc.

521  {
522  g_autoptr(FlDartProject) project = fl_dart_project_new();
523  g_autoptr(FlEngine) engine = fl_engine_new(project);
524 
525  g_autoptr(GError) error = nullptr;
526  EXPECT_TRUE(fl_engine_start(engine, &error));
527  EXPECT_EQ(error, nullptr);
528 
529  std::vector<FlutterPointerEvent> pointer_events;
530  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
531  SendPointerEvent,
532  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
533  size_t events_count) {
534  for (size_t i = 0; i < events_count; i++) {
535  pointer_events.push_back(events[i]);
536  }
537 
538  return kSuccess;
539  }));
540 
541  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
542  fl_pointer_manager_handle_motion(manager, 1234,
543  kFlutterPointerDeviceKindMouse, 1.0, 2.0);
544  fl_pointer_manager_handle_button_press(
545  manager, 1235, kFlutterPointerDeviceKindMouse, 3.0, 4.0,
546  kFlutterPointerButtonMousePrimary);
547  fl_pointer_manager_handle_motion(manager, 1236,
548  kFlutterPointerDeviceKindMouse, 5.0, 6.0);
549  fl_pointer_manager_handle_button_release(
550  manager, 1237, kFlutterPointerDeviceKindMouse, 7.0, 8.0,
551  kFlutterPointerButtonMousePrimary);
552  fl_pointer_manager_handle_motion(manager, 1238,
553  kFlutterPointerDeviceKindMouse, 9.0, 10.0);
554 
555  EXPECT_EQ(pointer_events.size(), 6u);
556 
557  // Ignore first synthetic enter event
558  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
559  EXPECT_EQ(pointer_events[1].x, 1.0);
560  EXPECT_EQ(pointer_events[1].y, 2.0);
561  EXPECT_EQ(pointer_events[1].buttons, 0);
562  EXPECT_EQ(pointer_events[1].view_id, 42);
563  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
564  EXPECT_EQ(pointer_events[2].x, 3.0);
565  EXPECT_EQ(pointer_events[2].y, 4.0);
566  EXPECT_EQ(pointer_events[2].buttons, kFlutterPointerButtonMousePrimary);
567  EXPECT_EQ(pointer_events[2].view_id, 42);
568  EXPECT_EQ(pointer_events[3].timestamp, 1236000u);
569  EXPECT_EQ(pointer_events[3].x, 5.0);
570  EXPECT_EQ(pointer_events[3].y, 6.0);
571  EXPECT_EQ(pointer_events[3].buttons, kFlutterPointerButtonMousePrimary);
572  EXPECT_EQ(pointer_events[3].view_id, 42);
573  EXPECT_EQ(pointer_events[4].timestamp, 1237000u);
574  EXPECT_EQ(pointer_events[4].x, 7.0);
575  EXPECT_EQ(pointer_events[4].y, 8.0);
576  EXPECT_EQ(pointer_events[4].buttons, 0);
577  EXPECT_EQ(pointer_events[4].view_id, 42);
578  EXPECT_EQ(pointer_events[5].timestamp, 1238000u);
579  EXPECT_EQ(pointer_events[5].x, 9.0);
580  EXPECT_EQ(pointer_events[5].y, 10.0);
581  EXPECT_EQ(pointer_events[5].buttons, 0);
582  EXPECT_EQ(pointer_events[5].view_id, 42);
583 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_handle_motion(), fl_pointer_manager_new(), and i.

◆ TEST() [7/13]

TEST ( FlPointerManagerTest  ,
EnterButtonPress   
)

Definition at line 137 of file fl_pointer_manager_test.cc.

137  {
138  g_autoptr(FlDartProject) project = fl_dart_project_new();
139  g_autoptr(FlEngine) engine = fl_engine_new(project);
140 
141  g_autoptr(GError) error = nullptr;
142  EXPECT_TRUE(fl_engine_start(engine, &error));
143  EXPECT_EQ(error, nullptr);
144 
145  std::vector<FlutterPointerEvent> pointer_events;
146  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
147  SendPointerEvent,
148  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
149  size_t events_count) {
150  for (size_t i = 0; i < events_count; i++) {
151  pointer_events.push_back(events[i]);
152  }
153 
154  return kSuccess;
155  }));
156 
157  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
158  fl_pointer_manager_handle_enter(manager, 1234, kFlutterPointerDeviceKindMouse,
159  1.0, 2.0);
160  fl_pointer_manager_handle_button_press(
161  manager, 1235, kFlutterPointerDeviceKindMouse, 4.0, 8.0,
162  kFlutterPointerButtonMousePrimary);
163 
164  EXPECT_EQ(pointer_events.size(), 2u);
165 
166  EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
167  EXPECT_EQ(pointer_events[0].x, 1.0);
168  EXPECT_EQ(pointer_events[0].y, 2.0);
169  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
170  EXPECT_EQ(pointer_events[0].buttons, 0);
171  EXPECT_EQ(pointer_events[0].view_id, 42);
172 
173  EXPECT_EQ(pointer_events[1].timestamp, 1235000u);
174  EXPECT_EQ(pointer_events[1].x, 4.0);
175  EXPECT_EQ(pointer_events[1].y, 8.0);
176  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
177  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
178  EXPECT_EQ(pointer_events[1].view_id, 42);
179 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_handle_enter(), fl_pointer_manager_new(), and i.

◆ TEST() [8/13]

TEST ( FlPointerManagerTest  ,
EnterEnter   
)

Definition at line 54 of file fl_pointer_manager_test.cc.

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

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), fl_pointer_manager_handle_enter(), fl_pointer_manager_new(), and i.

◆ TEST() [9/13]

TEST ( FlPointerManagerTest  ,
EnterLeave   
)

Definition at line 11 of file fl_pointer_manager_test.cc.

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

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), fl_pointer_manager_handle_enter(), fl_pointer_manager_handle_leave(), fl_pointer_manager_new(), and i.

◆ TEST() [10/13]

TEST ( FlPointerManagerTest  ,
EnterLeaveLeave   
)

Definition at line 91 of file fl_pointer_manager_test.cc.

91  {
92  g_autoptr(FlDartProject) project = fl_dart_project_new();
93  g_autoptr(FlEngine) engine = fl_engine_new(project);
94 
95  g_autoptr(GError) error = nullptr;
96  EXPECT_TRUE(fl_engine_start(engine, &error));
97  EXPECT_EQ(error, nullptr);
98 
99  std::vector<FlutterPointerEvent> pointer_events;
100  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
101  SendPointerEvent,
102  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
103  size_t events_count) {
104  for (size_t i = 0; i < events_count; i++) {
105  pointer_events.push_back(events[i]);
106  }
107 
108  return kSuccess;
109  }));
110 
111  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
112  fl_pointer_manager_handle_enter(manager, 1234, kFlutterPointerDeviceKindMouse,
113  1.0, 2.0);
114  fl_pointer_manager_handle_leave(manager, 1235, kFlutterPointerDeviceKindMouse,
115  3.0, 4.0);
116  // Duplicate leave is ignored
117  fl_pointer_manager_handle_leave(manager, 1235, kFlutterPointerDeviceKindMouse,
118  5.0, 6.0);
119 
120  EXPECT_EQ(pointer_events.size(), 2u);
121 
122  EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
123  EXPECT_EQ(pointer_events[0].x, 1.0);
124  EXPECT_EQ(pointer_events[0].y, 2.0);
125  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
126  EXPECT_EQ(pointer_events[0].buttons, 0);
127  EXPECT_EQ(pointer_events[0].view_id, 42);
128 
129  EXPECT_EQ(pointer_events[1].timestamp, 1235000u);
130  EXPECT_EQ(pointer_events[1].x, 3.0);
131  EXPECT_EQ(pointer_events[1].y, 4.0);
132  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
133  EXPECT_EQ(pointer_events[1].buttons, 0);
134  EXPECT_EQ(pointer_events[1].view_id, 42);
135 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), fl_pointer_manager_handle_enter(), fl_pointer_manager_handle_leave(), fl_pointer_manager_new(), and i.

◆ TEST() [11/13]

TEST ( FlPointerManagerTest  ,
Motion   
)

Definition at line 470 of file fl_pointer_manager_test.cc.

470  {
471  g_autoptr(FlDartProject) project = fl_dart_project_new();
472  g_autoptr(FlEngine) engine = fl_engine_new(project);
473 
474  g_autoptr(GError) error = nullptr;
475  EXPECT_TRUE(fl_engine_start(engine, &error));
476  EXPECT_EQ(error, nullptr);
477 
478  std::vector<FlutterPointerEvent> pointer_events;
479  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
480  SendPointerEvent,
481  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
482  size_t events_count) {
483  for (size_t i = 0; i < events_count; i++) {
484  pointer_events.push_back(events[i]);
485  }
486 
487  return kSuccess;
488  }));
489 
490  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
491  fl_pointer_manager_handle_motion(manager, 1234,
492  kFlutterPointerDeviceKindMouse, 1.0, 2.0);
493  fl_pointer_manager_handle_motion(manager, 1235,
494  kFlutterPointerDeviceKindMouse, 3.0, 4.0);
495  fl_pointer_manager_handle_motion(manager, 1236,
496  kFlutterPointerDeviceKindMouse, 5.0, 6.0);
497 
498  EXPECT_EQ(pointer_events.size(), 4u);
499 
500  // Ignore first synthetic enter event
501  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
502  EXPECT_EQ(pointer_events[1].x, 1.0);
503  EXPECT_EQ(pointer_events[1].y, 2.0);
504  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
505  EXPECT_EQ(pointer_events[1].buttons, 0);
506  EXPECT_EQ(pointer_events[1].view_id, 42);
507  EXPECT_EQ(pointer_events[2].timestamp, 1235000u);
508  EXPECT_EQ(pointer_events[2].x, 3.0);
509  EXPECT_EQ(pointer_events[2].y, 4.0);
510  EXPECT_EQ(pointer_events[2].device_kind, kFlutterPointerDeviceKindMouse);
511  EXPECT_EQ(pointer_events[2].buttons, 0);
512  EXPECT_EQ(pointer_events[2].view_id, 42);
513  EXPECT_EQ(pointer_events[3].timestamp, 1236000u);
514  EXPECT_EQ(pointer_events[3].x, 5.0);
515  EXPECT_EQ(pointer_events[3].y, 6.0);
516  EXPECT_EQ(pointer_events[3].device_kind, kFlutterPointerDeviceKindMouse);
517  EXPECT_EQ(pointer_events[3].buttons, 0);
518  EXPECT_EQ(pointer_events[3].view_id, 42);
519 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), fl_pointer_manager_handle_motion(), fl_pointer_manager_new(), and i.

◆ TEST() [12/13]

TEST ( FlPointerManagerTest  ,
NoButtonPressButtonRelease   
)

Definition at line 441 of file fl_pointer_manager_test.cc.

441  {
442  g_autoptr(FlDartProject) project = fl_dart_project_new();
443  g_autoptr(FlEngine) engine = fl_engine_new(project);
444 
445  g_autoptr(GError) error = nullptr;
446  EXPECT_TRUE(fl_engine_start(engine, &error));
447  EXPECT_EQ(error, nullptr);
448 
449  std::vector<FlutterPointerEvent> pointer_events;
450  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
451  SendPointerEvent,
452  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
453  size_t events_count) {
454  for (size_t i = 0; i < events_count; i++) {
455  pointer_events.push_back(events[i]);
456  }
457 
458  return kSuccess;
459  }));
460 
461  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
462  // Release without associated press, will be ignored
463  fl_pointer_manager_handle_button_release(
464  manager, 1235, kFlutterPointerDeviceKindMouse, 5.0, 9.0,
465  kFlutterPointerButtonMousePrimary);
466 
467  EXPECT_EQ(pointer_events.size(), 0u);
468 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), fl_pointer_manager_handle_button_release(), fl_pointer_manager_new(), and i.

◆ TEST() [13/13]

TEST ( FlPointerManagerTest  ,
NoEnterButtonPress   
)

Definition at line 181 of file fl_pointer_manager_test.cc.

181  {
182  g_autoptr(FlDartProject) project = fl_dart_project_new();
183  g_autoptr(FlEngine) engine = fl_engine_new(project);
184 
185  g_autoptr(GError) error = nullptr;
186  EXPECT_TRUE(fl_engine_start(engine, &error));
187  EXPECT_EQ(error, nullptr);
188 
189  std::vector<FlutterPointerEvent> pointer_events;
190  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
191  SendPointerEvent,
192  ([&pointer_events](auto engine, const FlutterPointerEvent* events,
193  size_t events_count) {
194  for (size_t i = 0; i < events_count; i++) {
195  pointer_events.push_back(events[i]);
196  }
197 
198  return kSuccess;
199  }));
200 
201  g_autoptr(FlPointerManager) manager = fl_pointer_manager_new(42, engine);
202  fl_pointer_manager_handle_button_press(
203  manager, 1234, kFlutterPointerDeviceKindMouse, 4.0, 8.0,
204  kFlutterPointerButtonMousePrimary);
205 
206  EXPECT_EQ(pointer_events.size(), 2u);
207 
208  // Synthetic enter events
209  EXPECT_EQ(pointer_events[0].timestamp, 1234000u);
210  EXPECT_EQ(pointer_events[0].x, 4.0);
211  EXPECT_EQ(pointer_events[0].y, 8.0);
212  EXPECT_EQ(pointer_events[0].device_kind, kFlutterPointerDeviceKindMouse);
213  EXPECT_EQ(pointer_events[0].buttons, 0);
214  EXPECT_EQ(pointer_events[0].view_id, 42);
215 
216  EXPECT_EQ(pointer_events[1].timestamp, 1234000u);
217  EXPECT_EQ(pointer_events[1].x, 4.0);
218  EXPECT_EQ(pointer_events[1].y, 8.0);
219  EXPECT_EQ(pointer_events[1].device_kind, kFlutterPointerDeviceKindMouse);
220  EXPECT_EQ(pointer_events[1].buttons, kFlutterPointerButtonMousePrimary);
221  EXPECT_EQ(pointer_events[1].view_id, 42);
222 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), fl_pointer_manager_handle_button_press(), fl_pointer_manager_new(), and i.

fl_engine_get_embedder_api
FlutterEngineProcTable * fl_engine_get_embedder_api(FlEngine *self)
Definition: fl_engine.cc:661
i
int i
Definition: fl_socket_accessible.cc:18
fl_dart_project_new
G_MODULE_EXPORT FlDartProject * fl_dart_project_new()
Definition: fl_dart_project.cc:50
fl_pointer_manager_handle_motion
gboolean fl_pointer_manager_handle_motion(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y)
Definition: fl_pointer_manager.cc:140
fl_pointer_manager_handle_leave
gboolean fl_pointer_manager_handle_leave(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y)
Definition: fl_pointer_manager.cc:179
fl_engine_new
G_MODULE_EXPORT FlEngine * fl_engine_new(FlDartProject *project)
Definition: fl_engine.cc:524
error
const uint8_t uint32_t uint32_t GError ** error
Definition: fl_pixel_buffer_texture_test.cc:40
fl_pointer_manager_handle_enter
gboolean fl_pointer_manager_handle_enter(FlPointerManager *self, guint event_time, FlutterPointerDeviceKind device_kind, gdouble x, gdouble y)
Definition: fl_pointer_manager.cc:162
fl_engine_start
gboolean fl_engine_start(FlEngine *self, GError **error)
Definition: fl_engine.cc:544
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, int64_t button)
Definition: fl_pointer_manager.cc:76
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, int64_t button)
Definition: fl_pointer_manager.cc:109
fl_pointer_manager_new
FlPointerManager * fl_pointer_manager_new(FlutterViewId view_id, FlEngine *engine)
Definition: fl_pointer_manager.cc:65