Flutter Linux Embedder
fl_engine_test.cc File Reference
#include "flutter/shell/platform/linux/testing/linux_test.h"
#include "gtest/gtest.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/fl_framebuffer.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_engine.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_json_message_codec.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_string_codec.h"
#include "flutter/shell/platform/linux/testing/mock_epoxy.h"
#include "flutter/shell/platform/linux/testing/mock_renderable.h"

Go to the source code of this file.

Classes

class  FlEngineTest
 

Functions

 TEST_F (FlEngineTest, NotifyDisplayUpdate)
 
 TEST_F (FlEngineTest, ScheduleFrame)
 
 TEST_F (FlEngineTest, WindowMetrics)
 
 TEST_F (FlEngineTest, MousePointer)
 
 TEST_F (FlEngineTest, MousePointerDeviceState)
 
 TEST_F (FlEngineTest, PointerPanZoom)
 
 TEST_F (FlEngineTest, DispatchSemanticsAction)
 
 TEST_F (FlEngineTest, PlatformMessage)
 
 TEST_F (FlEngineTest, PlatformMessageResponse)
 
 TEST_F (FlEngineTest, SettingsHandler)
 
void on_pre_engine_restart_cb (FlEngine *engine, gpointer user_data)
 
 TEST_F (FlEngineTest, OnPreEngineRestart)
 
 TEST_F (FlEngineTest, DartEntrypointArgs)
 
 TEST_F (FlEngineTest, EngineId)
 
 TEST_F (FlEngineTest, UIIsolateDefaultThreadPolicy)
 
 TEST_F (FlEngineTest, UIIsolateOnPlatformTaskRunner)
 
 TEST_F (FlEngineTest, UIIsolateOnSeparateThread)
 
 TEST_F (FlEngineTest, Locales)
 
 TEST_F (FlEngineTest, CLocale)
 
 TEST_F (FlEngineTest, DuplicateLocale)
 
 TEST_F (FlEngineTest, EmptyLocales)
 
static void add_view_cb (GObject *object, GAsyncResult *result, gpointer user_data)
 
 TEST_F (FlEngineTest, AddView)
 
static void add_view_error_cb (GObject *object, GAsyncResult *result, gpointer user_data)
 
 TEST_F (FlEngineTest, AddViewError)
 
static void add_view_engine_error_cb (GObject *object, GAsyncResult *result, gpointer user_data)
 
 TEST_F (FlEngineTest, AddViewEngineError)
 
static void remove_view_cb (GObject *object, GAsyncResult *result, gpointer user_data)
 
 TEST_F (FlEngineTest, RemoveView)
 
static void remove_view_error_cb (GObject *object, GAsyncResult *result, gpointer user_data)
 
 TEST_F (FlEngineTest, RemoveViewError)
 
static void remove_view_engine_error_cb (GObject *object, GAsyncResult *result, gpointer user_data)
 
 TEST_F (FlEngineTest, RemoveViewEngineError)
 
 TEST_F (FlEngineTest, SendKeyEvent)
 
 TEST_F (FlEngineTest, SendKeyEventNotHandled)
 
 TEST_F (FlEngineTest, SendKeyEventError)
 
 TEST_F (FlEngineTest, EnableImpellerDefault)
 
 TEST_F (FlEngineTest, DisableImpeller)
 
 TEST_F (FlEngineTest, EnableFlutterGpuDefault)
 
 TEST_F (FlEngineTest, EnableFlutterGpu)
 
 TEST_F (FlEngineTest, CreateOpenGLBackingStoreWithImpellerMSAA)
 
 TEST_F (FlEngineTest, CreateOpenGLBackingStoreWithImpellerMSAAAndBgraExtension)
 
 TEST_F (FlEngineTest, CreateOpenGLBackingStoreWithImplicitMSAAAndBgraExtension)
 
 TEST_F (FlEngineTest, ChildObjects)
 

Function Documentation

◆ add_view_cb()

static void add_view_cb ( GObject *  object,
GAsyncResult *  result,
gpointer  user_data 
)
static

Definition at line 664 of file fl_engine_test.cc.

666  {
667  g_autoptr(GError) error = nullptr;
668  gboolean r = fl_engine_add_view_finish(FL_ENGINE(object), result, &error);
669  EXPECT_TRUE(r);
670  EXPECT_EQ(error, nullptr);
671 
672  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
673 }
g_autoptr(FlEngine) engine
const char FlTextDirection FlAssertiveness gpointer user_data
gboolean fl_engine_add_view_finish(FlEngine *self, GAsyncResult *result, GError **error)
Definition: fl_engine.cc:1016
const uint8_t uint32_t uint32_t GError ** error

References error, fl_engine_add_view_finish(), g_autoptr(), and user_data.

Referenced by TEST_F().

◆ add_view_engine_error_cb()

static void add_view_engine_error_cb ( GObject *  object,
GAsyncResult *  result,
gpointer  user_data 
)
static

Definition at line 742 of file fl_engine_test.cc.

744  {
745  g_autoptr(GError) error = nullptr;
746  gboolean r = fl_engine_add_view_finish(FL_ENGINE(object), result, &error);
747  EXPECT_FALSE(r);
748  EXPECT_NE(error, nullptr);
749 
750  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
751 }

References error, fl_engine_add_view_finish(), g_autoptr(), and user_data.

Referenced by TEST_F().

◆ add_view_error_cb()

static void add_view_error_cb ( GObject *  object,
GAsyncResult *  result,
gpointer  user_data 
)
static

Definition at line 709 of file fl_engine_test.cc.

711  {
712  g_autoptr(GError) error = nullptr;
713  gboolean r = fl_engine_add_view_finish(FL_ENGINE(object), result, &error);
714  EXPECT_FALSE(r);
715  EXPECT_NE(error, nullptr);
716 
717  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
718 }

References error, fl_engine_add_view_finish(), g_autoptr(), and user_data.

Referenced by TEST_F().

◆ on_pre_engine_restart_cb()

void on_pre_engine_restart_cb ( FlEngine *  engine,
gpointer  user_data 
)

Definition at line 346 of file fl_engine_test.cc.

346  {
347  int* count = reinterpret_cast<int*>(user_data);
348  *count += 1;
349 }

References user_data.

Referenced by TEST_F().

◆ remove_view_cb()

static void remove_view_cb ( GObject *  object,
GAsyncResult *  result,
gpointer  user_data 
)
static

Definition at line 769 of file fl_engine_test.cc.

771  {
772  g_autoptr(GError) error = nullptr;
773  gboolean r = fl_engine_remove_view_finish(FL_ENGINE(object), result, &error);
774  EXPECT_TRUE(r);
775  EXPECT_EQ(error, nullptr);
776 
777  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
778 }
gboolean fl_engine_remove_view_finish(FlEngine *self, GAsyncResult *result, GError **error)
Definition: fl_engine.cc:1056

References error, fl_engine_remove_view_finish(), g_autoptr(), and user_data.

Referenced by TEST_F().

◆ remove_view_engine_error_cb()

static void remove_view_engine_error_cb ( GObject *  object,
GAsyncResult *  result,
gpointer  user_data 
)
static

Definition at line 832 of file fl_engine_test.cc.

834  {
835  g_autoptr(GError) error = nullptr;
836  gboolean r = fl_engine_remove_view_finish(FL_ENGINE(object), result, &error);
837  EXPECT_FALSE(r);
838  EXPECT_NE(error, nullptr);
839 
840  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
841 }

References error, fl_engine_remove_view_finish(), g_autoptr(), and user_data.

Referenced by TEST_F().

◆ remove_view_error_cb()

static void remove_view_error_cb ( GObject *  object,
GAsyncResult *  result,
gpointer  user_data 
)
static

Definition at line 803 of file fl_engine_test.cc.

805  {
806  g_autoptr(GError) error = nullptr;
807  gboolean r = fl_engine_remove_view_finish(FL_ENGINE(object), result, &error);
808  EXPECT_FALSE(r);
809  EXPECT_NE(error, nullptr);
810 
811  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
812 }

References error, fl_engine_remove_view_finish(), g_autoptr(), and user_data.

Referenced by TEST_F().

◆ TEST_F() [1/37]

TEST_F ( FlEngineTest  ,
AddView   
)

Definition at line 675 of file fl_engine_test.cc.

675  {
676  bool called = false;
677  fl_engine_get_embedder_api(engine)->AddView = MOCK_ENGINE_PROC(
678  AddView, ([&called](auto engine, const FlutterAddViewInfo* info) {
679  called = true;
680  EXPECT_EQ(info->view_metrics->width, 123u);
681  EXPECT_EQ(info->view_metrics->height, 456u);
682  EXPECT_TRUE(info->view_metrics->has_constraints);
683  EXPECT_EQ(info->view_metrics->min_width_constraint, 123u);
684  EXPECT_EQ(info->view_metrics->min_height_constraint, 456u);
685  EXPECT_EQ(info->view_metrics->max_width_constraint, 888u);
686  EXPECT_EQ(info->view_metrics->max_height_constraint, 999u);
687  EXPECT_EQ(info->view_metrics->pixel_ratio, 2.0);
688 
689  FlutterAddViewResult result;
690  result.struct_size = sizeof(FlutterAddViewResult);
691  result.added = true;
692  result.user_data = info->user_data;
693  info->add_view_callback(&result);
694 
695  return kSuccess;
696  }));
697 
698  g_autoptr(FlMockRenderable) renderable = fl_mock_renderable_new();
699  FlutterViewId view_id =
700  fl_engine_add_view(engine, FL_RENDERABLE(renderable), 123, 456, 888, 999,
701  2.0, nullptr, add_view_cb, loop);
702  EXPECT_GT(view_id, 0);
703  EXPECT_TRUE(called);
704 
705  // Blocks here until add_view_cb is called.
706  g_main_loop_run(loop);
707 }
FlRenderable * renderable
FlutterEngineProcTable * fl_engine_get_embedder_api(FlEngine *self)
Definition: fl_engine.cc:942
FlutterViewId fl_engine_add_view(FlEngine *self, FlRenderable *renderable, size_t min_width, size_t min_height, size_t max_width, size_t max_height, double pixel_ratio, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_engine.cc:963
static void add_view_cb(GObject *object, GAsyncResult *result, gpointer user_data)
G_BEGIN_DECLS FlutterViewId view_id

References add_view_cb(), fl_engine_add_view(), fl_engine_get_embedder_api(), g_autoptr(), renderable, and view_id.

◆ TEST_F() [2/37]

TEST_F ( FlEngineTest  ,
AddViewEngineError   
)

Definition at line 753 of file fl_engine_test.cc.

753  {
754  fl_engine_get_embedder_api(engine)->AddView = MOCK_ENGINE_PROC(
755  AddView, ([](auto engine, const FlutterAddViewInfo* info) {
756  return kInvalidArguments;
757  }));
758 
759  g_autoptr(FlMockRenderable) renderable = fl_mock_renderable_new();
760  FlutterViewId view_id =
761  fl_engine_add_view(engine, FL_RENDERABLE(renderable), 123, 456, 123, 456,
762  2.0, nullptr, add_view_engine_error_cb, loop);
763  EXPECT_GT(view_id, 0);
764 
765  // Blocks here until remove_view_engine_error_cb is called.
766  g_main_loop_run(loop);
767 }
static void add_view_engine_error_cb(GObject *object, GAsyncResult *result, gpointer user_data)

References add_view_engine_error_cb(), fl_engine_add_view(), fl_engine_get_embedder_api(), g_autoptr(), renderable, and view_id.

◆ TEST_F() [3/37]

TEST_F ( FlEngineTest  ,
AddViewError   
)

Definition at line 720 of file fl_engine_test.cc.

720  {
721  fl_engine_get_embedder_api(engine)->AddView = MOCK_ENGINE_PROC(
722  AddView, ([](auto engine, const FlutterAddViewInfo* info) {
723  FlutterAddViewResult result;
724  result.struct_size = sizeof(FlutterAddViewResult);
725  result.added = false;
726  result.user_data = info->user_data;
727  info->add_view_callback(&result);
728 
729  return kSuccess;
730  }));
731 
732  g_autoptr(FlMockRenderable) renderable = fl_mock_renderable_new();
733  FlutterViewId view_id =
734  fl_engine_add_view(engine, FL_RENDERABLE(renderable), 123, 456, 123, 456,
735  2.0, nullptr, add_view_error_cb, loop);
736  EXPECT_GT(view_id, 0);
737 
738  // Blocks here until add_view_error_cb is called.
739  g_main_loop_run(loop);
740 }
static void add_view_error_cb(GObject *object, GAsyncResult *result, gpointer user_data)

References add_view_error_cb(), fl_engine_add_view(), fl_engine_get_embedder_api(), g_autoptr(), renderable, and view_id.

◆ TEST_F() [4/37]

TEST_F ( FlEngineTest  ,
ChildObjects   
)

Definition at line 1201 of file fl_engine_test.cc.

1201  {
1202  // Check objects exist before engine started.
1203  EXPECT_NE(fl_engine_get_binary_messenger(engine), nullptr);
1204  EXPECT_NE(fl_engine_get_display_monitor(engine), nullptr);
1205  EXPECT_NE(fl_engine_get_task_runner(engine), nullptr);
1206  EXPECT_NE(fl_engine_get_keyboard_manager(engine), nullptr);
1207  EXPECT_NE(fl_engine_get_mouse_cursor_handler(engine), nullptr);
1208 }
FlMouseCursorHandler * fl_engine_get_mouse_cursor_handler(FlEngine *self)
Definition: fl_engine.cc:1638
FlTaskRunner * fl_engine_get_task_runner(FlEngine *self)
Definition: fl_engine.cc:1591
FlKeyboardManager * fl_engine_get_keyboard_manager(FlEngine *self)
Definition: fl_engine.cc:1628
FlDisplayMonitor * fl_engine_get_display_monitor(FlEngine *self)
Definition: fl_engine.cc:756
G_MODULE_EXPORT FlBinaryMessenger * fl_engine_get_binary_messenger(FlEngine *self)
Definition: fl_engine.cc:1585

References fl_engine_get_binary_messenger(), fl_engine_get_display_monitor(), fl_engine_get_keyboard_manager(), fl_engine_get_mouse_cursor_handler(), and fl_engine_get_task_runner().

◆ TEST_F() [5/37]

TEST_F ( FlEngineTest  ,
CLocale   
)

Definition at line 551 of file fl_engine_test.cc.

551  {
552  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
553  g_setenv("LANGUAGE", "C", TRUE);
554 
555  bool called = false;
556  fl_engine_get_embedder_api(engine)->UpdateLocales = MOCK_ENGINE_PROC(
557  UpdateLocales, ([&called](auto engine, const FlutterLocale** locales,
558  size_t locales_count) {
559  called = true;
560 
561  EXPECT_EQ(locales_count, static_cast<size_t>(1));
562 
563  EXPECT_STREQ(locales[0]->language_code, "C");
564  EXPECT_STREQ(locales[0]->country_code, nullptr);
565  EXPECT_STREQ(locales[0]->script_code, nullptr);
566  EXPECT_STREQ(locales[0]->variant_code, nullptr);
567 
568  return kSuccess;
569  }));
570 
571  StartEngine();
572 
573  EXPECT_TRUE(called);
574 
575  if (initial_language) {
576  g_setenv("LANGUAGE", initial_language, TRUE);
577  } else {
578  g_unsetenv("LANGUAGE");
579  }
580 }

References fl_engine_get_embedder_api(), and TRUE.

◆ TEST_F() [6/37]

TEST_F ( FlEngineTest  ,
CreateOpenGLBackingStoreWithImpellerMSAA   
)

Definition at line 1136 of file fl_engine_test.cc.

1136  {
1137  ::testing::NiceMock<flutter::testing::MockEpoxy> epoxy;
1138  ON_CALL(epoxy, epoxy_gl_version).WillByDefault(::testing::Return(30));
1139  ON_CALL(epoxy, epoxy_has_gl_extension(::testing::_))
1140  .WillByDefault(::testing::Return(false));
1141  ON_CALL(epoxy, glGetIntegerv(GL_MAX_SAMPLES, ::testing::_))
1142  .WillByDefault(::testing::SetArgPointee<1>(4));
1143 
1144  EXPECT_CALL(epoxy, glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4,
1145  GL_RGBA8, 800, 600));
1146  EXPECT_CALL(epoxy, glRenderbufferStorageMultisample(
1147  GL_RENDERBUFFER, 4, GL_DEPTH24_STENCIL8, 800, 600));
1148  EXPECT_CALL(epoxy,
1149  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
1150  GL_RENDERBUFFER, ::testing::_));
1151  EXPECT_CALL(epoxy,
1152  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
1153  GL_RENDERBUFFER, ::testing::_));
1154  EXPECT_CALL(epoxy,
1155  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
1156  GL_RENDERBUFFER, ::testing::_));
1157 
1158  test_impeller_backing_store(engine, project, GL_RGBA8,
1159  /*expect_texture=*/false);
1160 }

◆ TEST_F() [7/37]

TEST_F ( FlEngineTest  ,
CreateOpenGLBackingStoreWithImpellerMSAAAndBgraExtension   
)

Definition at line 1162 of file fl_engine_test.cc.

1162  {
1163  ::testing::NiceMock<flutter::testing::MockEpoxy> epoxy;
1164  ON_CALL(epoxy, epoxy_gl_version).WillByDefault(::testing::Return(30));
1165  ON_CALL(epoxy, epoxy_has_gl_extension(::testing::_))
1166  .WillByDefault(::testing::Return(false));
1167  ON_CALL(epoxy, epoxy_has_gl_extension(
1168  ::testing::StrEq("GL_EXT_texture_format_BGRA8888")))
1169  .WillByDefault(::testing::Return(true));
1170  ON_CALL(epoxy, glGetIntegerv(GL_MAX_SAMPLES, ::testing::_))
1171  .WillByDefault(::testing::SetArgPointee<1>(4));
1172 
1173  // GL_EXT_texture_format_BGRA8888 only defines BGRA for textures, not
1174  // renderbuffers. When explicit offscreen MSAA is used without
1175  // GL_EXT_multisampled_render_to_texture, a multisample renderbuffer is
1176  // created which must use GL_RGBA8.
1177  EXPECT_CALL(epoxy, glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4,
1178  GL_RGBA8, 800, 600));
1179  EXPECT_CALL(epoxy, glRenderbufferStorageMultisample(
1180  GL_RENDERBUFFER, 4, GL_DEPTH24_STENCIL8, 800, 600));
1181 
1182  test_impeller_backing_store(engine, project, GL_RGBA8,
1183  /*expect_texture=*/false);
1184 }

◆ TEST_F() [8/37]

TEST_F ( FlEngineTest  ,
CreateOpenGLBackingStoreWithImplicitMSAAAndBgraExtension   
)

Definition at line 1186 of file fl_engine_test.cc.

1186  {
1187  ::testing::NiceMock<flutter::testing::MockEpoxy> epoxy;
1188  ON_CALL(epoxy, epoxy_has_gl_extension(::testing::_))
1189  .WillByDefault(::testing::Return(false));
1190  ON_CALL(epoxy, epoxy_has_gl_extension(
1191  ::testing::StrEq("GL_EXT_texture_format_BGRA8888")))
1192  .WillByDefault(::testing::Return(true));
1193  ON_CALL(epoxy, epoxy_has_gl_extension(
1194  ::testing::StrEq("GL_EXT_multisampled_render_to_texture")))
1195  .WillByDefault(::testing::Return(true));
1196 
1197  test_impeller_backing_store(engine, project, GL_BGRA8_EXT,
1198  /*expect_texture=*/true);
1199 }

◆ TEST_F() [9/37]

TEST_F ( FlEngineTest  ,
DartEntrypointArgs   
)

Definition at line 392 of file fl_engine_test.cc.

392  {
393  GPtrArray* args_array = g_ptr_array_new();
394  g_ptr_array_add(args_array, const_cast<char*>("arg_one"));
395  g_ptr_array_add(args_array, const_cast<char*>("arg_two"));
396  g_ptr_array_add(args_array, const_cast<char*>("arg_three"));
397  g_ptr_array_add(args_array, nullptr);
398  gchar** args = reinterpret_cast<gchar**>(g_ptr_array_free(args_array, false));
399 
401 
402  bool called = false;
403  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
404  Initialize, ([&called, &set_args = args](
405  size_t version, const FlutterRendererConfig* config,
406  const FlutterProjectArgs* args, void* user_data,
407  FLUTTER_API_SYMBOL(FlutterEngine)* engine_out) {
408  called = true;
409  EXPECT_NE(set_args, args->dart_entrypoint_argv);
410  EXPECT_EQ(args->dart_entrypoint_argc, 3);
411 
412  return kSuccess;
413  }));
414  fl_engine_get_embedder_api(engine)->RunInitialized =
415  MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
416 
417  StartEngine();
418 
419  EXPECT_TRUE(called);
420 }
G_MODULE_EXPORT void fl_dart_project_set_dart_entrypoint_arguments(FlDartProject *self, char **argv)
G_BEGIN_DECLS G_MODULE_EXPORT FlValue * args

References args, fl_dart_project_set_dart_entrypoint_arguments(), fl_engine_get_embedder_api(), and user_data.

◆ TEST_F() [10/37]

TEST_F ( FlEngineTest  ,
DisableImpeller   
)

Definition at line 1001 of file fl_engine_test.cc.

1001  {
1002  fl_dart_project_set_enable_impeller(project, FALSE);
1003 
1004  bool called = false;
1005  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
1006  Initialize,
1007  ([&called](size_t version, const FlutterRendererConfig* config,
1008  const FlutterProjectArgs* args, void* user_data,
1009  FLUTTER_API_SYMBOL(FlutterEngine)* engine_out) {
1010  called = true;
1011  bool has_impeller_switch = false;
1012  for (int i = 0; i < args->command_line_argc; i++) {
1013  if (strcmp(args->command_line_argv[i], "--enable-impeller") == 0) {
1014  has_impeller_switch = true;
1015  }
1016  }
1017  EXPECT_FALSE(has_impeller_switch);
1018  return kSuccess;
1019  }));
1020  fl_engine_get_embedder_api(engine)->RunInitialized =
1021  MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
1022 
1023  g_autoptr(GError) error = nullptr;
1024  EXPECT_TRUE(fl_engine_start(engine, &error));
1025  EXPECT_EQ(error, nullptr);
1026  EXPECT_TRUE(called);
1027 }
G_MODULE_EXPORT void fl_dart_project_set_enable_impeller(FlDartProject *project, gboolean enable_impeller)
gboolean fl_engine_start(FlEngine *self, GError **error)
Definition: fl_engine.cc:761

References args, error, fl_dart_project_set_enable_impeller(), fl_engine_get_embedder_api(), fl_engine_start(), g_autoptr(), i, and user_data.

◆ TEST_F() [11/37]

TEST_F ( FlEngineTest  ,
DispatchSemanticsAction   
)

Definition at line 210 of file fl_engine_test.cc.

210  {
211  bool called = false;
212  fl_engine_get_embedder_api(engine)->SendSemanticsAction = MOCK_ENGINE_PROC(
213  SendSemanticsAction,
214  ([&called](auto engine, const FlutterSendSemanticsActionInfo* info) {
215  EXPECT_EQ(info->view_id, static_cast<int64_t>(456));
216  EXPECT_EQ(info->node_id, static_cast<uint64_t>(42));
217  EXPECT_EQ(info->action, kFlutterSemanticsActionTap);
218  EXPECT_EQ(info->data_length, static_cast<size_t>(4));
219  EXPECT_EQ(info->data[0], 't');
220  EXPECT_EQ(info->data[1], 'e');
221  EXPECT_EQ(info->data[2], 's');
222  EXPECT_EQ(info->data[3], 't');
223  called = true;
224 
225  return kSuccess;
226  }));
227 
228  StartEngine();
229  g_autoptr(GBytes) data = g_bytes_new_static("test", 4);
230  fl_engine_dispatch_semantics_action(engine, 456, 42,
231  kFlutterSemanticsActionTap, data);
232 
233  EXPECT_TRUE(called);
234 }
void fl_engine_dispatch_semantics_action(FlEngine *self, FlutterViewId view_id, uint64_t node_id, FlutterSemanticsAction action, GBytes *data)
Definition: fl_engine.cc:1534

References fl_engine_dispatch_semantics_action(), fl_engine_get_embedder_api(), and g_autoptr().

◆ TEST_F() [12/37]

TEST_F ( FlEngineTest  ,
DuplicateLocale   
)

Definition at line 582 of file fl_engine_test.cc.

582  {
583  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
584  g_setenv("LANGUAGE", "en:en", TRUE);
585 
586  bool called = false;
587  fl_engine_get_embedder_api(engine)->UpdateLocales = MOCK_ENGINE_PROC(
588  UpdateLocales, ([&called](auto engine, const FlutterLocale** locales,
589  size_t locales_count) {
590  called = true;
591 
592  EXPECT_EQ(locales_count, static_cast<size_t>(2));
593 
594  EXPECT_STREQ(locales[0]->language_code, "en");
595  EXPECT_STREQ(locales[0]->country_code, nullptr);
596  EXPECT_STREQ(locales[0]->script_code, nullptr);
597  EXPECT_STREQ(locales[0]->variant_code, nullptr);
598 
599  EXPECT_STREQ(locales[1]->language_code, "C");
600  EXPECT_STREQ(locales[1]->country_code, nullptr);
601  EXPECT_STREQ(locales[1]->script_code, nullptr);
602  EXPECT_STREQ(locales[1]->variant_code, nullptr);
603 
604  return kSuccess;
605  }));
606 
607  StartEngine();
608 
609  EXPECT_TRUE(called);
610 
611  if (initial_language) {
612  g_setenv("LANGUAGE", initial_language, TRUE);
613  } else {
614  g_unsetenv("LANGUAGE");
615  }
616 }

References fl_engine_get_embedder_api(), and TRUE.

◆ TEST_F() [13/37]

TEST_F ( FlEngineTest  ,
EmptyLocales   
)

Definition at line 618 of file fl_engine_test.cc.

618  {
619  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
620  g_setenv("LANGUAGE", "de:: :en_US", TRUE);
621 
622  bool called = false;
623  fl_engine_get_embedder_api(engine)->UpdateLocales = MOCK_ENGINE_PROC(
624  UpdateLocales, ([&called](auto engine, const FlutterLocale** locales,
625  size_t locales_count) {
626  called = true;
627 
628  EXPECT_EQ(locales_count, static_cast<size_t>(4));
629 
630  EXPECT_STREQ(locales[0]->language_code, "de");
631  EXPECT_STREQ(locales[0]->country_code, nullptr);
632  EXPECT_STREQ(locales[0]->script_code, nullptr);
633  EXPECT_STREQ(locales[0]->variant_code, nullptr);
634 
635  EXPECT_STREQ(locales[1]->language_code, "en");
636  EXPECT_STREQ(locales[1]->country_code, "US");
637  EXPECT_STREQ(locales[1]->script_code, nullptr);
638  EXPECT_STREQ(locales[1]->variant_code, nullptr);
639 
640  EXPECT_STREQ(locales[2]->language_code, "en");
641  EXPECT_STREQ(locales[2]->country_code, nullptr);
642  EXPECT_STREQ(locales[2]->script_code, nullptr);
643  EXPECT_STREQ(locales[2]->variant_code, nullptr);
644 
645  EXPECT_STREQ(locales[3]->language_code, "C");
646  EXPECT_STREQ(locales[3]->country_code, nullptr);
647  EXPECT_STREQ(locales[3]->script_code, nullptr);
648  EXPECT_STREQ(locales[3]->variant_code, nullptr);
649 
650  return kSuccess;
651  }));
652 
653  StartEngine();
654 
655  EXPECT_TRUE(called);
656 
657  if (initial_language) {
658  g_setenv("LANGUAGE", initial_language, TRUE);
659  } else {
660  g_unsetenv("LANGUAGE");
661  }
662 }

References fl_engine_get_embedder_api(), and TRUE.

◆ TEST_F() [14/37]

TEST_F ( FlEngineTest  ,
EnableFlutterGpu   
)

Definition at line 1053 of file fl_engine_test.cc.

1053  {
1055 
1056  bool called = false;
1057  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
1058  Initialize,
1059  ([&called](size_t version, const FlutterRendererConfig* config,
1060  const FlutterProjectArgs* args, void* user_data,
1061  FLUTTER_API_SYMBOL(FlutterEngine)* engine_out) {
1062  called = true;
1063  bool has_flutter_gpu_switch = false;
1064  for (int i = 0; i < args->command_line_argc; i++) {
1065  if (strcmp(args->command_line_argv[i], "--enable-flutter-gpu") == 0) {
1066  has_flutter_gpu_switch = true;
1067  }
1068  }
1069  EXPECT_TRUE(has_flutter_gpu_switch);
1070  return kSuccess;
1071  }));
1072  fl_engine_get_embedder_api(engine)->RunInitialized =
1073  MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
1074 
1075  g_autoptr(GError) error = nullptr;
1076  EXPECT_TRUE(fl_engine_start(engine, &error));
1077  EXPECT_EQ(error, nullptr);
1078  EXPECT_TRUE(called);
1079 }
G_MODULE_EXPORT void fl_dart_project_set_enable_flutter_gpu(FlDartProject *project, gboolean enable_flutter_gpu)

References args, error, fl_dart_project_set_enable_flutter_gpu(), fl_engine_get_embedder_api(), fl_engine_start(), g_autoptr(), i, TRUE, and user_data.

◆ TEST_F() [15/37]

TEST_F ( FlEngineTest  ,
EnableFlutterGpuDefault   
)

Definition at line 1029 of file fl_engine_test.cc.

1029  {
1030  bool called = false;
1031  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
1032  Initialize,
1033  ([&called](size_t version, const FlutterRendererConfig* config,
1034  const FlutterProjectArgs* args, void* user_data,
1035  FLUTTER_API_SYMBOL(FlutterEngine)* engine_out) {
1036  called = true;
1037  bool has_flutter_gpu_switch = false;
1038  for (int i = 0; i < args->command_line_argc; i++) {
1039  if (strcmp(args->command_line_argv[i], "--enable-flutter-gpu") == 0) {
1040  has_flutter_gpu_switch = true;
1041  }
1042  }
1043  EXPECT_FALSE(has_flutter_gpu_switch);
1044  return kSuccess;
1045  }));
1046  fl_engine_get_embedder_api(engine)->RunInitialized =
1047  MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
1048 
1049  StartEngine();
1050  EXPECT_TRUE(called);
1051 }

References args, fl_engine_get_embedder_api(), i, and user_data.

◆ TEST_F() [16/37]

TEST_F ( FlEngineTest  ,
EnableImpellerDefault   
)

Definition at line 977 of file fl_engine_test.cc.

977  {
978  bool called = false;
979  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
980  Initialize,
981  ([&called](size_t version, const FlutterRendererConfig* config,
982  const FlutterProjectArgs* args, void* user_data,
983  FLUTTER_API_SYMBOL(FlutterEngine)* engine_out) {
984  called = true;
985  bool has_impeller_switch = false;
986  for (int i = 0; i < args->command_line_argc; i++) {
987  if (strcmp(args->command_line_argv[i], "--enable-impeller") == 0) {
988  has_impeller_switch = true;
989  }
990  }
991  EXPECT_TRUE(has_impeller_switch);
992  return kSuccess;
993  }));
994  fl_engine_get_embedder_api(engine)->RunInitialized =
995  MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
996 
997  StartEngine();
998  EXPECT_TRUE(called);
999 }

References args, fl_engine_get_embedder_api(), i, and user_data.

◆ TEST_F() [17/37]

TEST_F ( FlEngineTest  ,
EngineId   
)

Definition at line 422 of file fl_engine_test.cc.

422  {
423  int64_t engine_id;
424  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
425  Initialize,
426  ([&engine_id](size_t version, const FlutterRendererConfig* config,
427  const FlutterProjectArgs* args, void* user_data,
428  FLUTTER_API_SYMBOL(FlutterEngine)* engine_out) {
429  engine_id = args->engine_id;
430  return kSuccess;
431  }));
432  fl_engine_get_embedder_api(engine)->RunInitialized =
433  MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
434 
435  StartEngine();
436  EXPECT_TRUE(engine_id != 0);
437 
438  EXPECT_EQ(fl_engine_for_id(engine_id), engine);
439 }
FlEngine * fl_engine_for_id(int64_t id)
Definition: fl_engine.cc:726

References args, fl_engine_for_id(), fl_engine_get_embedder_api(), and user_data.

◆ TEST_F() [18/37]

TEST_F ( FlEngineTest  ,
Locales   
)

Definition at line 505 of file fl_engine_test.cc.

505  {
506  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
507  g_setenv("LANGUAGE", "de:en_US", TRUE);
508 
509  bool called = false;
510  fl_engine_get_embedder_api(engine)->UpdateLocales = MOCK_ENGINE_PROC(
511  UpdateLocales, ([&called](auto engine, const FlutterLocale** locales,
512  size_t locales_count) {
513  called = true;
514 
515  EXPECT_EQ(locales_count, static_cast<size_t>(4));
516 
517  EXPECT_STREQ(locales[0]->language_code, "de");
518  EXPECT_STREQ(locales[0]->country_code, nullptr);
519  EXPECT_STREQ(locales[0]->script_code, nullptr);
520  EXPECT_STREQ(locales[0]->variant_code, nullptr);
521 
522  EXPECT_STREQ(locales[1]->language_code, "en");
523  EXPECT_STREQ(locales[1]->country_code, "US");
524  EXPECT_STREQ(locales[1]->script_code, nullptr);
525  EXPECT_STREQ(locales[1]->variant_code, nullptr);
526 
527  EXPECT_STREQ(locales[2]->language_code, "en");
528  EXPECT_STREQ(locales[2]->country_code, nullptr);
529  EXPECT_STREQ(locales[2]->script_code, nullptr);
530  EXPECT_STREQ(locales[2]->variant_code, nullptr);
531 
532  EXPECT_STREQ(locales[3]->language_code, "C");
533  EXPECT_STREQ(locales[3]->country_code, nullptr);
534  EXPECT_STREQ(locales[3]->script_code, nullptr);
535  EXPECT_STREQ(locales[3]->variant_code, nullptr);
536 
537  return kSuccess;
538  }));
539 
540  StartEngine();
541 
542  EXPECT_TRUE(called);
543 
544  if (initial_language) {
545  g_setenv("LANGUAGE", initial_language, TRUE);
546  } else {
547  g_unsetenv("LANGUAGE");
548  }
549 }

References fl_engine_get_embedder_api(), and TRUE.

◆ TEST_F() [19/37]

TEST_F ( FlEngineTest  ,
MousePointer   
)

Definition at line 120 of file fl_engine_test.cc.

120  {
121  bool called = false;
122  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
123  SendPointerEvent,
124  ([&called](auto engine, const FlutterPointerEvent* events,
125  size_t events_count) {
126  called = true;
127  EXPECT_EQ(events_count, static_cast<size_t>(1));
128  EXPECT_EQ(events[0].view_id, 1);
129  EXPECT_EQ(events[0].phase, kDown);
130  EXPECT_EQ(events[0].timestamp, static_cast<size_t>(1234567890));
131  EXPECT_EQ(events[0].x, 800);
132  EXPECT_EQ(events[0].y, 600);
133  EXPECT_EQ(events[0].device, static_cast<int32_t>(0));
134  EXPECT_EQ(events[0].signal_kind, kFlutterPointerSignalKindScroll);
135  EXPECT_EQ(events[0].scroll_delta_x, 1.2);
136  EXPECT_EQ(events[0].scroll_delta_y, -3.4);
137  EXPECT_EQ(events[0].device_kind, kFlutterPointerDeviceKindMouse);
138  EXPECT_EQ(events[0].buttons, kFlutterPointerButtonMouseSecondary);
139 
140  return kSuccess;
141  }));
142 
143  StartEngine();
144  fl_engine_send_mouse_pointer_event(engine, 1, kDown, 1234567890, 800, 600,
145  kFlutterPointerDeviceKindMouse, 1.2, -3.4,
146  kFlutterPointerButtonMouseSecondary, 0, 0);
147 
148  EXPECT_TRUE(called);
149 }
void fl_engine_send_mouse_pointer_event(FlEngine *self, FlutterViewId view_id, FlutterPointerPhase phase, size_t timestamp, double x, double y, FlutterPointerDeviceKind device_kind, double scroll_delta_x, double scroll_delta_y, int64_t buttons, double rotation, double pressure)
Definition: fl_engine.cc:1229

References fl_engine_get_embedder_api(), fl_engine_send_mouse_pointer_event(), and view_id.

◆ TEST_F() [20/37]

TEST_F ( FlEngineTest  ,
MousePointerDeviceState   
)

Definition at line 152 of file fl_engine_test.cc.

152  {
153  bool device_state_sent = false;
154  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
155  SendPointerEvent,
156  ([&device_state_sent](auto engine, const FlutterPointerEvent* events,
157  size_t events_count) {
158  device_state_sent = true;
159  EXPECT_EQ(events_count, static_cast<size_t>(1));
160  EXPECT_DOUBLE_EQ(events[0].pressure, 0.5);
161  EXPECT_DOUBLE_EQ(events[0].pressure_min, 0.0);
162  EXPECT_DOUBLE_EQ(events[0].pressure_max, 1.0);
163  EXPECT_DOUBLE_EQ(events[0].rotation, G_PI / 2.0);
164 
165  return kSuccess;
166  }));
167 
168  StartEngine();
170  engine, 1, kDown, 1234567890, 800, 600, kFlutterPointerDeviceKindMouse,
171  1.2, -3.4, kFlutterPointerButtonMouseSecondary, 90.0, 0.5);
172 
173  EXPECT_TRUE(device_state_sent);
174 }

References fl_engine_get_embedder_api(), and fl_engine_send_mouse_pointer_event().

◆ TEST_F() [21/37]

TEST_F ( FlEngineTest  ,
NotifyDisplayUpdate   
)

Definition at line 24 of file fl_engine_test.cc.

24  {
25  StartEngine();
26 
27  bool called = false;
28  fl_engine_get_embedder_api(engine)->NotifyDisplayUpdate = MOCK_ENGINE_PROC(
29  NotifyDisplayUpdate,
30  ([&called](auto engine, FlutterEngineDisplaysUpdateType update_type,
31  const FlutterEngineDisplay* displays, size_t displays_length) {
32  called = true;
33  EXPECT_EQ(update_type, kFlutterEngineDisplaysUpdateTypeStartup);
34  EXPECT_EQ(displays_length, 2u);
35 
36  EXPECT_EQ(displays[0].display_id, 1u);
37  EXPECT_EQ(displays[0].refresh_rate, 60);
38  EXPECT_EQ(displays[0].width, 1024u);
39  EXPECT_EQ(displays[0].height, 768u);
40  EXPECT_EQ(displays[0].device_pixel_ratio, 1.0);
41 
42  EXPECT_EQ(displays[1].display_id, 2u);
43  EXPECT_EQ(displays[1].refresh_rate, 120);
44  EXPECT_EQ(displays[1].width, 3840u);
45  EXPECT_EQ(displays[1].height, 2160u);
46  EXPECT_EQ(displays[1].device_pixel_ratio, 2.0);
47 
48  return kSuccess;
49  }));
50 
51  FlutterEngineDisplay displays[2] = {
52  {
53  .struct_size = sizeof(FlutterEngineDisplay),
54  .display_id = 1,
55  .single_display = false,
56  .refresh_rate = 60.0,
57  .width = 1024,
58  .height = 768,
59  .device_pixel_ratio = 1.0,
60  },
61  {
62  .struct_size = sizeof(FlutterEngineDisplay),
63  .display_id = 2,
64  .single_display = false,
65  .refresh_rate = 120.0,
66  .width = 3840,
67  .height = 2160,
68  .device_pixel_ratio = 2.0,
69  }};
70  fl_engine_notify_display_update(engine, displays, 2);
71 
72  EXPECT_TRUE(called);
73 }
void fl_engine_notify_display_update(FlEngine *self, const FlutterEngineDisplay *displays, size_t displays_length)
Definition: fl_engine.cc:946
const uint8_t uint32_t uint32_t * height
const uint8_t uint32_t * width

References fl_engine_get_embedder_api(), fl_engine_notify_display_update(), height, and width.

◆ TEST_F() [22/37]

TEST_F ( FlEngineTest  ,
OnPreEngineRestart   
)

Definition at line 352 of file fl_engine_test.cc.

352  {
353  OnPreEngineRestartCallback callback;
354  void* callback_user_data;
355 
356  bool called = false;
357  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
358  Initialize, ([&callback, &callback_user_data, &called](
359  size_t version, const FlutterRendererConfig* config,
360  const FlutterProjectArgs* args, void* user_data,
361  FLUTTER_API_SYMBOL(FlutterEngine)* engine_out) {
362  called = true;
363  callback = args->on_pre_engine_restart_callback;
364  callback_user_data = user_data;
365 
366  return kSuccess;
367  }));
368  fl_engine_get_embedder_api(engine)->RunInitialized =
369  MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
370 
371  StartEngine();
372 
373  EXPECT_TRUE(called);
374  EXPECT_NE(callback, nullptr);
375 
376  // The following call has no effect but should not crash.
377  callback(callback_user_data);
378 
379  int count = 0;
380 
381  // Set handler so that:
382  //
383  // * When the engine restarts, count += 1;
384  // * When the engine is freed, count += 10.
385  g_signal_connect(engine, "on-pre-engine-restart",
386  G_CALLBACK(on_pre_engine_restart_cb), &count);
387 
388  callback(callback_user_data);
389  EXPECT_EQ(count, 1);
390 }
void on_pre_engine_restart_cb(FlEngine *engine, gpointer user_data)

References args, fl_engine_get_embedder_api(), on_pre_engine_restart_cb(), and user_data.

◆ TEST_F() [23/37]

TEST_F ( FlEngineTest  ,
PlatformMessage   
)

Definition at line 237 of file fl_engine_test.cc.

237  {
238  bool called = false;
239  FlutterEngineSendPlatformMessageFnPtr old_handler =
240  fl_engine_get_embedder_api(engine)->SendPlatformMessage;
241  fl_engine_get_embedder_api(engine)->SendPlatformMessage = MOCK_ENGINE_PROC(
242  SendPlatformMessage,
243  ([&called, old_handler](auto engine,
244  const FlutterPlatformMessage* message) {
245  if (strcmp(message->channel, "test") != 0) {
246  return old_handler(engine, message);
247  }
248 
249  called = true;
250 
251  EXPECT_EQ(message->message_size, static_cast<size_t>(4));
252  EXPECT_EQ(message->message[0], 't');
253  EXPECT_EQ(message->message[1], 'e');
254  EXPECT_EQ(message->message[2], 's');
255  EXPECT_EQ(message->message[3], 't');
256 
257  return kSuccess;
258  }));
259 
260  StartEngine();
261  g_autoptr(GBytes) message = g_bytes_new_static("test", 4);
262  fl_engine_send_platform_message(engine, "test", message, nullptr, nullptr,
263  nullptr);
264 
265  EXPECT_TRUE(called);
266 }
const char * message
void fl_engine_send_platform_message(FlEngine *self, const gchar *channel, GBytes *message, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_engine.cc:1114

References fl_engine_get_embedder_api(), fl_engine_send_platform_message(), g_autoptr(), and message.

◆ TEST_F() [24/37]

TEST_F ( FlEngineTest  ,
PlatformMessageResponse   
)

Definition at line 269 of file fl_engine_test.cc.

269  {
270  bool called = false;
271  fl_engine_get_embedder_api(engine)->SendPlatformMessageResponse =
272  MOCK_ENGINE_PROC(
273  SendPlatformMessageResponse,
274  ([&called](auto engine,
275  const FlutterPlatformMessageResponseHandle* handle,
276  const uint8_t* data, size_t data_length) {
277  called = true;
278 
279  EXPECT_EQ(
280  handle,
281  reinterpret_cast<const FlutterPlatformMessageResponseHandle*>(
282  42));
283  EXPECT_EQ(data_length, static_cast<size_t>(4));
284  EXPECT_EQ(data[0], 't');
285  EXPECT_EQ(data[1], 'e');
286  EXPECT_EQ(data[2], 's');
287  EXPECT_EQ(data[3], 't');
288 
289  return kSuccess;
290  }));
291 
292  g_autoptr(GError) error = nullptr;
293  StartEngine();
294  g_autoptr(GBytes) response = g_bytes_new_static("test", 4);
296  engine, reinterpret_cast<const FlutterPlatformMessageResponseHandle*>(42),
297  response, &error));
298  EXPECT_EQ(error, nullptr);
299 
300  EXPECT_TRUE(called);
301 }
gboolean fl_engine_send_platform_message_response(FlEngine *self, const FlutterPlatformMessageResponseHandle *handle, GBytes *response, GError **error)
Definition: fl_engine.cc:1082

References error, fl_engine_get_embedder_api(), fl_engine_send_platform_message_response(), and g_autoptr().

◆ TEST_F() [25/37]

TEST_F ( FlEngineTest  ,
PointerPanZoom   
)

Definition at line 177 of file fl_engine_test.cc.

177  {
178  bool called = false;
179  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
180  SendPointerEvent,
181  ([&called](auto engine, const FlutterPointerEvent* events,
182  size_t events_count) {
183  called = true;
184  EXPECT_EQ(events_count, static_cast<size_t>(1));
185  EXPECT_EQ(events[0].view_id, 1);
186  EXPECT_EQ(events[0].phase, kPanZoomUpdate);
187  EXPECT_EQ(events[0].timestamp, static_cast<size_t>(1234567890));
188  EXPECT_EQ(events[0].x, 800);
189  EXPECT_EQ(events[0].y, 600);
190  EXPECT_EQ(events[0].device, static_cast<int32_t>(1));
191  EXPECT_EQ(events[0].signal_kind, kFlutterPointerSignalKindNone);
192  EXPECT_EQ(events[0].pan_x, 1.5);
193  EXPECT_EQ(events[0].pan_y, 2.5);
194  EXPECT_EQ(events[0].scale, 3.5);
195  EXPECT_EQ(events[0].rotation, 4.5);
196  EXPECT_EQ(events[0].device_kind, kFlutterPointerDeviceKindTrackpad);
197  EXPECT_EQ(events[0].buttons, 0);
198 
199  return kSuccess;
200  }));
201 
202  StartEngine();
203  fl_engine_send_pointer_pan_zoom_event(engine, 1, 1234567890, 800, 600,
204  kPanZoomUpdate, 1.5, 2.5, 3.5, 4.5);
205 
206  EXPECT_TRUE(called);
207 }
void fl_engine_send_pointer_pan_zoom_event(FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, FlutterPointerPhase phase, double pan_x, double pan_y, double scale, double rotation)
Definition: fl_engine.cc:1452
G_BEGIN_DECLS FlSubsurface size_t size_t gint scale

References fl_engine_get_embedder_api(), fl_engine_send_pointer_pan_zoom_event(), scale, and view_id.

◆ TEST_F() [26/37]

TEST_F ( FlEngineTest  ,
RemoveView   
)

Definition at line 780 of file fl_engine_test.cc.

780  {
781  bool called = false;
782  fl_engine_get_embedder_api(engine)->RemoveView = MOCK_ENGINE_PROC(
783  RemoveView, ([&called](auto engine, const FlutterRemoveViewInfo* info) {
784  called = true;
785  EXPECT_EQ(info->view_id, 123);
786 
787  FlutterRemoveViewResult result;
788  result.struct_size = sizeof(FlutterRemoveViewResult);
789  result.removed = true;
790  result.user_data = info->user_data;
791  info->remove_view_callback(&result);
792 
793  return kSuccess;
794  }));
795 
796  fl_engine_remove_view(engine, 123, nullptr, remove_view_cb, loop);
797  EXPECT_TRUE(called);
798 
799  // Blocks here until remove_view_cb is called.
800  g_main_loop_run(loop);
801 }
void fl_engine_remove_view(FlEngine *self, FlutterViewId view_id, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_engine.cc:1029
static void remove_view_cb(GObject *object, GAsyncResult *result, gpointer user_data)

References fl_engine_get_embedder_api(), fl_engine_remove_view(), and remove_view_cb().

◆ TEST_F() [27/37]

TEST_F ( FlEngineTest  ,
RemoveViewEngineError   
)

Definition at line 843 of file fl_engine_test.cc.

843  {
844  fl_engine_get_embedder_api(engine)->RemoveView = MOCK_ENGINE_PROC(
845  RemoveView, ([](auto engine, const FlutterRemoveViewInfo* info) {
846  return kInvalidArguments;
847  }));
848 
850  loop);
851 
852  // Blocks here until remove_view_engine_error_cb is called.
853  g_main_loop_run(loop);
854 }
static void remove_view_engine_error_cb(GObject *object, GAsyncResult *result, gpointer user_data)

References fl_engine_get_embedder_api(), fl_engine_remove_view(), and remove_view_engine_error_cb().

◆ TEST_F() [28/37]

TEST_F ( FlEngineTest  ,
RemoveViewError   
)

Definition at line 814 of file fl_engine_test.cc.

814  {
815  fl_engine_get_embedder_api(engine)->RemoveView = MOCK_ENGINE_PROC(
816  RemoveView, ([](auto engine, const FlutterRemoveViewInfo* info) {
817  FlutterRemoveViewResult result;
818  result.struct_size = sizeof(FlutterRemoveViewResult);
819  result.removed = false;
820  result.user_data = info->user_data;
821  info->remove_view_callback(&result);
822 
823  return kSuccess;
824  }));
825 
826  fl_engine_remove_view(engine, 123, nullptr, remove_view_error_cb, loop);
827 
828  // Blocks here until remove_view_error_cb is called.
829  g_main_loop_run(loop);
830 }
static void remove_view_error_cb(GObject *object, GAsyncResult *result, gpointer user_data)

References fl_engine_get_embedder_api(), fl_engine_remove_view(), and remove_view_error_cb().

◆ TEST_F() [29/37]

TEST_F ( FlEngineTest  ,
ScheduleFrame   
)

Definition at line 76 of file fl_engine_test.cc.

76  {
77  StartEngine();
78 
79  bool called = false;
80  fl_engine_get_embedder_api(engine)->ScheduleFrame =
81  MOCK_ENGINE_PROC(ScheduleFrame, ([&called](auto engine) {
82  called = true;
83  return kSuccess;
84  }));
85 
87 
88  EXPECT_TRUE(called);
89 }
void fl_engine_schedule_frame(FlEngine *self)
Definition: fl_engine.cc:1185

References fl_engine_get_embedder_api(), and fl_engine_schedule_frame().

◆ TEST_F() [30/37]

TEST_F ( FlEngineTest  ,
SendKeyEvent   
)

Definition at line 856 of file fl_engine_test.cc.

856  {
857  StartEngine();
858 
859  bool called;
860  fl_engine_get_embedder_api(engine)->SendKeyEvent = MOCK_ENGINE_PROC(
861  SendKeyEvent,
862  ([&called](auto engine, const FlutterKeyEvent* event,
863  FlutterKeyEventCallback callback, void* user_data) {
864  called = true;
865  EXPECT_EQ(event->timestamp, 1234);
866  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
867  EXPECT_EQ(event->physical, static_cast<uint64_t>(42));
868  EXPECT_EQ(event->logical, static_cast<uint64_t>(123));
869  EXPECT_TRUE(event->synthesized);
870  EXPECT_EQ(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
871  callback(TRUE, user_data);
872  return kSuccess;
873  }));
874 
875  FlutterKeyEvent event = {.struct_size = sizeof(FlutterKeyEvent),
876  .timestamp = 1234,
877  .type = kFlutterKeyEventTypeUp,
878  .physical = 42,
879  .logical = 123,
880  .character = nullptr,
881  .synthesized = true,
882  .device_type = kFlutterKeyEventDeviceTypeKeyboard};
884  engine, &event, nullptr,
885  [](GObject* object, GAsyncResult* result, gpointer user_data) {
886  gboolean handled;
887  g_autoptr(GError) error = nullptr;
888  EXPECT_TRUE(fl_engine_send_key_event_finish(FL_ENGINE(object), result,
889  &handled, &error));
890  EXPECT_EQ(error, nullptr);
891  EXPECT_TRUE(handled);
892  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
893  },
894  loop);
895 
896  g_main_loop_run(loop);
897  EXPECT_TRUE(called);
898 }
gboolean fl_engine_send_key_event_finish(FlEngine *self, GAsyncResult *result, gboolean *handled, GError **error)
Definition: fl_engine.cc:1517
void fl_engine_send_key_event(FlEngine *self, const FlutterKeyEvent *event, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_engine.cc:1494

References error, fl_engine_get_embedder_api(), fl_engine_send_key_event(), fl_engine_send_key_event_finish(), g_autoptr(), TRUE, type, and user_data.

◆ TEST_F() [31/37]

TEST_F ( FlEngineTest  ,
SendKeyEventError   
)

Definition at line 938 of file fl_engine_test.cc.

938  {
939  g_autoptr(GError) error = nullptr;
940  // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.Assign)
941  StartEngine();
942 
943  bool called;
944  fl_engine_get_embedder_api(engine)->SendKeyEvent = MOCK_ENGINE_PROC(
945  SendKeyEvent,
946  ([&called](auto engine, const FlutterKeyEvent* event,
947  FlutterKeyEventCallback callback, void* user_data) {
948  called = true;
949  return kInvalidArguments;
950  }));
951 
952  FlutterKeyEvent event = {.struct_size = sizeof(FlutterKeyEvent),
953  .timestamp = 1234,
954  .type = kFlutterKeyEventTypeUp,
955  .physical = 42,
956  .logical = 123,
957  .character = nullptr,
958  .synthesized = true,
959  .device_type = kFlutterKeyEventDeviceTypeKeyboard};
961  engine, &event, nullptr,
962  [](GObject* object, GAsyncResult* result, gpointer user_data) {
963  gboolean handled;
964  g_autoptr(GError) error = nullptr;
965  EXPECT_FALSE(fl_engine_send_key_event_finish(FL_ENGINE(object), result,
966  &handled, &error));
967  EXPECT_NE(error, nullptr);
968  EXPECT_STREQ(error->message, "Failed to send key event");
969  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
970  },
971  loop);
972 
973  g_main_loop_run(loop);
974  EXPECT_TRUE(called);
975 }

References error, fl_engine_get_embedder_api(), fl_engine_send_key_event(), fl_engine_send_key_event_finish(), g_autoptr(), type, and user_data.

◆ TEST_F() [32/37]

TEST_F ( FlEngineTest  ,
SendKeyEventNotHandled   
)

Definition at line 900 of file fl_engine_test.cc.

900  {
901  StartEngine();
902 
903  bool called;
904  fl_engine_get_embedder_api(engine)->SendKeyEvent = MOCK_ENGINE_PROC(
905  SendKeyEvent,
906  ([&called](auto engine, const FlutterKeyEvent* event,
907  FlutterKeyEventCallback callback, void* user_data) {
908  called = true;
909  callback(FALSE, user_data);
910  return kSuccess;
911  }));
912 
913  FlutterKeyEvent event = {.struct_size = sizeof(FlutterKeyEvent),
914  .timestamp = 1234,
915  .type = kFlutterKeyEventTypeUp,
916  .physical = 42,
917  .logical = 123,
918  .character = nullptr,
919  .synthesized = true,
920  .device_type = kFlutterKeyEventDeviceTypeKeyboard};
922  engine, &event, nullptr,
923  [](GObject* object, GAsyncResult* result, gpointer user_data) {
924  gboolean handled;
925  g_autoptr(GError) error = nullptr;
926  EXPECT_TRUE(fl_engine_send_key_event_finish(FL_ENGINE(object), result,
927  &handled, &error));
928  EXPECT_EQ(error, nullptr);
929  EXPECT_FALSE(handled);
930  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
931  },
932  loop);
933 
934  g_main_loop_run(loop);
935  EXPECT_TRUE(called);
936 }

References error, fl_engine_get_embedder_api(), fl_engine_send_key_event(), fl_engine_send_key_event_finish(), g_autoptr(), type, and user_data.

◆ TEST_F() [33/37]

TEST_F ( FlEngineTest  ,
SettingsHandler   
)

Definition at line 304 of file fl_engine_test.cc.

304  {
305  bool called = false;
306  fl_engine_get_embedder_api(engine)->SendPlatformMessage = MOCK_ENGINE_PROC(
307  SendPlatformMessage,
308  ([&called](auto engine, const FlutterPlatformMessage* message) {
309  called = true;
310 
311  EXPECT_STREQ(message->channel, "flutter/settings");
312 
313  g_autoptr(FlJsonMessageCodec) codec = fl_json_message_codec_new();
314  g_autoptr(GBytes) data =
315  g_bytes_new(message->message, message->message_size);
316  g_autoptr(GError) error = nullptr;
318  FL_MESSAGE_CODEC(codec), data, &error);
319  EXPECT_NE(settings, nullptr);
320  EXPECT_EQ(error, nullptr);
321 
322  FlValue* text_scale_factor =
323  fl_value_lookup_string(settings, "textScaleFactor");
324  EXPECT_NE(text_scale_factor, nullptr);
325  EXPECT_EQ(fl_value_get_type(text_scale_factor), FL_VALUE_TYPE_FLOAT);
326 
327  FlValue* always_use_24hr_format =
328  fl_value_lookup_string(settings, "alwaysUse24HourFormat");
329  EXPECT_NE(always_use_24hr_format, nullptr);
330  EXPECT_EQ(fl_value_get_type(always_use_24hr_format),
332 
333  FlValue* platform_brightness =
334  fl_value_lookup_string(settings, "platformBrightness");
335  EXPECT_NE(platform_brightness, nullptr);
336  EXPECT_EQ(fl_value_get_type(platform_brightness), FL_VALUE_TYPE_STRING);
337 
338  return kSuccess;
339  }));
340 
341  StartEngine();
342 
343  EXPECT_TRUE(called);
344 }
G_MODULE_EXPORT FlJsonMessageCodec * fl_json_message_codec_new()
G_MODULE_EXPORT FlValue * fl_message_codec_decode_message(FlMessageCodec *self, GBytes *message, GError **error)
G_MODULE_EXPORT FlValue * fl_value_lookup_string(FlValue *self, const gchar *key)
Definition: fl_value.cc:811
G_MODULE_EXPORT FlValueType fl_value_get_type(FlValue *self)
Definition: fl_value.cc:466
typedefG_BEGIN_DECLS struct _FlValue FlValue
Definition: fl_value.h:42
@ FL_VALUE_TYPE_STRING
Definition: fl_value.h:68
@ FL_VALUE_TYPE_BOOL
Definition: fl_value.h:65
@ FL_VALUE_TYPE_FLOAT
Definition: fl_value.h:67

References error, fl_engine_get_embedder_api(), fl_json_message_codec_new(), fl_message_codec_decode_message(), fl_value_get_type(), fl_value_lookup_string(), FL_VALUE_TYPE_BOOL, FL_VALUE_TYPE_FLOAT, FL_VALUE_TYPE_STRING, g_autoptr(), and message.

◆ TEST_F() [34/37]

TEST_F ( FlEngineTest  ,
UIIsolateDefaultThreadPolicy   
)

Definition at line 441 of file fl_engine_test.cc.

441  {
443 
444  bool same_task_runner = false;
445 
446  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
447  Initialize,
448  ([&same_task_runner](size_t version, const FlutterRendererConfig* config,
449  const FlutterProjectArgs* args, void* user_data,
450  FLUTTER_API_SYMBOL(FlutterEngine)* engine_out) {
451  same_task_runner = args->custom_task_runners->platform_task_runner ==
452  args->custom_task_runners->ui_task_runner;
453  return kSuccess;
454  }));
455  fl_engine_get_embedder_api(engine)->RunInitialized =
456  MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
457 
458  StartEngine();
459  EXPECT_TRUE(same_task_runner);
460 }
G_MODULE_EXPORT void fl_dart_project_set_ui_thread_policy(FlDartProject *project, FlUIThreadPolicy policy)
@ FL_UI_THREAD_POLICY_DEFAULT

References args, fl_dart_project_set_ui_thread_policy(), fl_engine_get_embedder_api(), FL_UI_THREAD_POLICY_DEFAULT, and user_data.

◆ TEST_F() [35/37]

TEST_F ( FlEngineTest  ,
UIIsolateOnPlatformTaskRunner   
)

Definition at line 462 of file fl_engine_test.cc.

462  {
465 
466  bool same_task_runner = false;
467 
468  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
469  Initialize,
470  ([&same_task_runner](size_t version, const FlutterRendererConfig* config,
471  const FlutterProjectArgs* args, void* user_data,
472  FLUTTER_API_SYMBOL(FlutterEngine)* engine_out) {
473  same_task_runner = args->custom_task_runners->platform_task_runner ==
474  args->custom_task_runners->ui_task_runner;
475  return kSuccess;
476  }));
477  fl_engine_get_embedder_api(engine)->RunInitialized =
478  MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
479 
480  StartEngine();
481  EXPECT_TRUE(same_task_runner);
482 }
@ FL_UI_THREAD_POLICY_RUN_ON_PLATFORM_THREAD

References args, fl_dart_project_set_ui_thread_policy(), fl_engine_get_embedder_api(), FL_UI_THREAD_POLICY_RUN_ON_PLATFORM_THREAD, and user_data.

◆ TEST_F() [36/37]

TEST_F ( FlEngineTest  ,
UIIsolateOnSeparateThread   
)

Definition at line 484 of file fl_engine_test.cc.

484  {
487 
488  bool separate_thread = false;
489 
490  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
491  Initialize,
492  ([&separate_thread](size_t version, const FlutterRendererConfig* config,
493  const FlutterProjectArgs* args, void* user_data,
494  FLUTTER_API_SYMBOL(FlutterEngine)* engine_out) {
495  separate_thread = args->custom_task_runners->ui_task_runner == nullptr;
496  return kSuccess;
497  }));
498  fl_engine_get_embedder_api(engine)->RunInitialized =
499  MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
500 
501  StartEngine();
502  EXPECT_TRUE(separate_thread);
503 }
@ FL_UI_THREAD_POLICY_RUN_ON_SEPARATE_THREAD

References args, fl_dart_project_set_ui_thread_policy(), fl_engine_get_embedder_api(), FL_UI_THREAD_POLICY_RUN_ON_SEPARATE_THREAD, and user_data.

◆ TEST_F() [37/37]

TEST_F ( FlEngineTest  ,
WindowMetrics   
)

Definition at line 92 of file fl_engine_test.cc.

92  {
93  StartEngine();
94 
95  bool called = false;
96  fl_engine_get_embedder_api(engine)->SendWindowMetricsEvent = MOCK_ENGINE_PROC(
97  SendWindowMetricsEvent,
98  ([&called](auto engine, const FlutterWindowMetricsEvent* event) {
99  called = true;
100  EXPECT_EQ(event->display_id, 99u);
101  EXPECT_EQ(event->view_id, 1);
102  EXPECT_EQ(event->width, 800u);
103  EXPECT_EQ(event->height, 600u);
104  EXPECT_TRUE(event->has_constraints);
105  EXPECT_EQ(event->min_width_constraint, 800u);
106  EXPECT_EQ(event->min_height_constraint, 600u);
107  EXPECT_EQ(event->max_width_constraint, 3840u);
108  EXPECT_EQ(event->max_height_constraint, 2160u);
109  EXPECT_EQ(event->pixel_ratio, 2.0);
110 
111  return kSuccess;
112  }));
113 
114  fl_engine_send_window_metrics_event(engine, 99, 1, 800, 600, 3840, 2160, 2.0);
115 
116  EXPECT_TRUE(called);
117 }
void fl_engine_send_window_metrics_event(FlEngine *self, FlutterEngineDisplayId display_id, FlutterViewId view_id, size_t min_width, size_t min_height, size_t max_width, size_t max_height, double pixel_ratio)
Definition: fl_engine.cc:1197

References fl_engine_get_embedder_api(), and fl_engine_send_window_metrics_event().