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/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_renderable.h"

Go to the source code of this file.

Classes
class	FlEngineTest

Functions
	TEST_F (FlEngineTest, NotifyDisplayUpdate)
	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, ChildObjects)

Function Documentation

add_view_cb()

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

static

Definition at line 646 of file fl_engine_test.cc.

                                            {
  g_autoptr(GError) error = nullptr;
  gboolean r = fl_engine_add_view_finish(FL_ENGINE(object), result, &error);
  EXPECT_TRUE(r);
  EXPECT_EQ(error, nullptr);
 
  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
}

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 724 of file fl_engine_test.cc.

                                                         {
  g_autoptr(GError) error = nullptr;
  gboolean r = fl_engine_add_view_finish(FL_ENGINE(object), result, &error);
  EXPECT_FALSE(r);
  EXPECT_NE(error, nullptr);
 
  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
}

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 691 of file fl_engine_test.cc.

                                                  {
  g_autoptr(GError) error = nullptr;
  gboolean r = fl_engine_add_view_finish(FL_ENGINE(object), result, &error);
  EXPECT_FALSE(r);
  EXPECT_NE(error, nullptr);
 
  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
}

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 328 of file fl_engine_test.cc.

                                                                    {
  int* count = reinterpret_cast<int*>(user_data);
  *count += 1;
}

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 751 of file fl_engine_test.cc.

                                               {
  g_autoptr(GError) error = nullptr;
  gboolean r = fl_engine_remove_view_finish(FL_ENGINE(object), result, &error);
  EXPECT_TRUE(r);
  EXPECT_EQ(error, nullptr);
 
  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
}

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 814 of file fl_engine_test.cc.

                                                            {
  g_autoptr(GError) error = nullptr;
  gboolean r = fl_engine_remove_view_finish(FL_ENGINE(object), result, &error);
  EXPECT_FALSE(r);
  EXPECT_NE(error, nullptr);
 
  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
}

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 785 of file fl_engine_test.cc.

                                                     {
  g_autoptr(GError) error = nullptr;
  gboolean r = fl_engine_remove_view_finish(FL_ENGINE(object), result, &error);
  EXPECT_FALSE(r);
  EXPECT_NE(error, nullptr);
 
  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
}

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

Referenced by TEST_F().

TEST_F() [1/31]

TEST_F	(	FlEngineTest	,
		AddView
	)

Definition at line 657 of file fl_engine_test.cc.

                              {
  bool called = false;
  fl_engine_get_embedder_api(engine)->AddView = MOCK_ENGINE_PROC(
      AddView, ([&called](auto engine, const FlutterAddViewInfo* info) {
        called = true;
        EXPECT_EQ(info->view_metrics->width, 123u);
        EXPECT_EQ(info->view_metrics->height, 456u);
        EXPECT_TRUE(info->view_metrics->has_constraints);
        EXPECT_EQ(info->view_metrics->min_width_constraint, 123u);
        EXPECT_EQ(info->view_metrics->min_height_constraint, 456u);
        EXPECT_EQ(info->view_metrics->max_width_constraint, 888u);
        EXPECT_EQ(info->view_metrics->max_height_constraint, 999u);
        EXPECT_EQ(info->view_metrics->pixel_ratio, 2.0);
 
        FlutterAddViewResult result;
        result.struct_size = sizeof(FlutterAddViewResult);
        result.added = true;
        result.user_data = info->user_data;
        info->add_view_callback(&result);
 
        return kSuccess;
      }));
 
  g_autoptr(FlMockRenderable) renderable = fl_mock_renderable_new();
  FlutterViewId view_id =
      fl_engine_add_view(engine, FL_RENDERABLE(renderable), 123, 456, 888, 999,
                         2.0, nullptr, add_view_cb, loop);
  EXPECT_GT(view_id, 0);
  EXPECT_TRUE(called);
 
  // Blocks here until add_view_cb is called.
  g_main_loop_run(loop);
}

References FlutterAddViewInfo::add_view_callback, add_view_cb(), FlutterAddViewResult::added, FlutterEngineProcTable::AddView, engine, fl_engine_add_view(), fl_engine_get_embedder_api(), g_autoptr(), FlutterWindowMetricsEvent::has_constraints, FlutterWindowMetricsEvent::height, kSuccess, FlutterWindowMetricsEvent::max_height_constraint, FlutterWindowMetricsEvent::max_width_constraint, FlutterWindowMetricsEvent::min_height_constraint, FlutterWindowMetricsEvent::min_width_constraint, MOCK_ENGINE_PROC, FlutterWindowMetricsEvent::pixel_ratio, renderable, FlutterAddViewResult::struct_size, FlutterAddViewResult::user_data, FlutterAddViewInfo::user_data, view_id, FlutterAddViewInfo::view_metrics, and FlutterWindowMetricsEvent::width.

TEST_F() [2/31]

TEST_F	(	FlEngineTest	,
		AddViewEngineError
	)

Definition at line 735 of file fl_engine_test.cc.

                                         {
  fl_engine_get_embedder_api(engine)->AddView = MOCK_ENGINE_PROC(
      AddView, ([](auto engine, const FlutterAddViewInfo* info) {
        return kInvalidArguments;
      }));
 
  g_autoptr(FlMockRenderable) renderable = fl_mock_renderable_new();
  FlutterViewId view_id =
      fl_engine_add_view(engine, FL_RENDERABLE(renderable), 123, 456, 123, 456,
                         2.0, nullptr, add_view_engine_error_cb, loop);
  EXPECT_GT(view_id, 0);
 
  // Blocks here until remove_view_engine_error_cb is called.
  g_main_loop_run(loop);
}

References add_view_engine_error_cb(), FlutterEngineProcTable::AddView, engine, fl_engine_add_view(), fl_engine_get_embedder_api(), g_autoptr(), kInvalidArguments, MOCK_ENGINE_PROC, renderable, and view_id.

TEST_F() [3/31]

TEST_F	(	FlEngineTest	,
		AddViewError
	)

Definition at line 702 of file fl_engine_test.cc.

                                   {
  fl_engine_get_embedder_api(engine)->AddView = MOCK_ENGINE_PROC(
      AddView, ([](auto engine, const FlutterAddViewInfo* info) {
        FlutterAddViewResult result;
        result.struct_size = sizeof(FlutterAddViewResult);
        result.added = false;
        result.user_data = info->user_data;
        info->add_view_callback(&result);
 
        return kSuccess;
      }));
 
  g_autoptr(FlMockRenderable) renderable = fl_mock_renderable_new();
  FlutterViewId view_id =
      fl_engine_add_view(engine, FL_RENDERABLE(renderable), 123, 456, 123, 456,
                         2.0, nullptr, add_view_error_cb, loop);
  EXPECT_GT(view_id, 0);
 
  // Blocks here until add_view_error_cb is called.
  g_main_loop_run(loop);
}

References FlutterAddViewInfo::add_view_callback, add_view_error_cb(), FlutterAddViewResult::added, FlutterEngineProcTable::AddView, engine, fl_engine_add_view(), fl_engine_get_embedder_api(), g_autoptr(), kSuccess, MOCK_ENGINE_PROC, renderable, FlutterAddViewResult::struct_size, FlutterAddViewResult::user_data, FlutterAddViewInfo::user_data, and view_id.

TEST_F() [4/31]

TEST_F	(	FlEngineTest	,
		ChildObjects
	)

Definition at line 1011 of file fl_engine_test.cc.

                                   {
  // Check objects exist before engine started.
  EXPECT_NE(fl_engine_get_binary_messenger(engine), nullptr);
  EXPECT_NE(fl_engine_get_display_monitor(engine), nullptr);
  EXPECT_NE(fl_engine_get_task_runner(engine), nullptr);
  EXPECT_NE(fl_engine_get_keyboard_manager(engine), nullptr);
  EXPECT_NE(fl_engine_get_mouse_cursor_handler(engine), nullptr);
}

References engine, 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/31]

TEST_F	(	FlEngineTest	,
		CLocale
	)

Definition at line 533 of file fl_engine_test.cc.

                              {
  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
  g_setenv("LANGUAGE", "C", TRUE);
 
  bool called = false;
  fl_engine_get_embedder_api(engine)->UpdateLocales = MOCK_ENGINE_PROC(
      UpdateLocales, ([&called](auto engine, const FlutterLocale** locales,
                                size_t locales_count) {
        called = true;
 
        EXPECT_EQ(locales_count, static_cast<size_t>(1));
 
        EXPECT_STREQ(locales[0]->language_code, "C");
        EXPECT_STREQ(locales[0]->country_code, nullptr);
        EXPECT_STREQ(locales[0]->script_code, nullptr);
        EXPECT_STREQ(locales[0]->variant_code, nullptr);
 
        return kSuccess;
      }));
 
  StartEngine();
 
  EXPECT_TRUE(called);
 
  if (initial_language) {
    g_setenv("LANGUAGE", initial_language, TRUE);
  } else {
    g_unsetenv("LANGUAGE");
  }
}

References engine, fl_engine_get_embedder_api(), kSuccess, MOCK_ENGINE_PROC, TRUE, and FlutterEngineProcTable::UpdateLocales.

TEST_F() [6/31]

TEST_F	(	FlEngineTest	,
		DartEntrypointArgs
	)

Definition at line 374 of file fl_engine_test.cc.

                                         {
  GPtrArray* args_array = g_ptr_array_new();
  g_ptr_array_add(args_array, const_cast<char*>("arg_one"));
  g_ptr_array_add(args_array, const_cast<char*>("arg_two"));
  g_ptr_array_add(args_array, const_cast<char*>("arg_three"));
  g_ptr_array_add(args_array, nullptr);
  gchar** args = reinterpret_cast<gchar**>(g_ptr_array_free(args_array, false));
 
  fl_dart_project_set_dart_entrypoint_arguments(project, args);
 
  bool called = false;
  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
      Initialize, ([&called, &set_args = args](
                       size_t version, const FlutterRendererConfig* config,
                       const FlutterProjectArgs* args, void* user_data,
                       FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
        called = true;
        EXPECT_NE(set_args, args->dart_entrypoint_argv);
        EXPECT_EQ(args->dart_entrypoint_argc, 3);
 
        return kSuccess;
      }));
  fl_engine_get_embedder_api(engine)->RunInitialized =
      MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
 
  StartEngine();
 
  EXPECT_TRUE(called);
}

References args, engine, fl_dart_project_set_dart_entrypoint_arguments(), fl_engine_get_embedder_api(), FLUTTER_API_SYMBOL, FlutterEngineProcTable::Initialize, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::RunInitialized, and user_data.

TEST_F() [7/31]

TEST_F	(	FlEngineTest	,
		DisableImpeller
	)

Definition at line 983 of file fl_engine_test.cc.

                                      {
  fl_dart_project_set_enable_impeller(project, FALSE);
 
  bool called = false;
  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
      Initialize,
      ([&called](size_t version, const FlutterRendererConfig* config,
                 const FlutterProjectArgs* args, void* user_data,
                 FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
        called = true;
        bool has_impeller_switch = false;
        for (int i = 0; i < args->command_line_argc; i++) {
          if (strcmp(args->command_line_argv[i], "--enable-impeller") == 0) {
            has_impeller_switch = true;
          }
        }
        EXPECT_FALSE(has_impeller_switch);
        return kSuccess;
      }));
  fl_engine_get_embedder_api(engine)->RunInitialized =
      MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
  EXPECT_TRUE(called);
}

References args, engine, error, fl_dart_project_set_enable_impeller(), fl_engine_get_embedder_api(), fl_engine_start(), FLUTTER_API_SYMBOL, g_autoptr(), i, FlutterEngineProcTable::Initialize, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::RunInitialized, and user_data.

TEST_F() [8/31]

TEST_F	(	FlEngineTest	,
		DispatchSemanticsAction
	)

Definition at line 192 of file fl_engine_test.cc.

                                              {
  bool called = false;
  fl_engine_get_embedder_api(engine)->SendSemanticsAction = MOCK_ENGINE_PROC(
      SendSemanticsAction,
      ([&called](auto engine, const FlutterSendSemanticsActionInfo* info) {
        EXPECT_EQ(info->view_id, static_cast<int64_t>(456));
        EXPECT_EQ(info->node_id, static_cast<uint64_t>(42));
        EXPECT_EQ(info->action, kFlutterSemanticsActionTap);
        EXPECT_EQ(info->data_length, static_cast<size_t>(4));
        EXPECT_EQ(info->data[0], 't');
        EXPECT_EQ(info->data[1], 'e');
        EXPECT_EQ(info->data[2], 's');
        EXPECT_EQ(info->data[3], 't');
        called = true;
 
        return kSuccess;
      }));
 
  StartEngine();
  g_autoptr(GBytes) data = g_bytes_new_static("test", 4);
  fl_engine_dispatch_semantics_action(engine, 456, 42,
                                      kFlutterSemanticsActionTap, data);
 
  EXPECT_TRUE(called);
}

References FlutterSendSemanticsActionInfo::action, FlutterSendSemanticsActionInfo::data, FlutterSendSemanticsActionInfo::data_length, engine, fl_engine_dispatch_semantics_action(), fl_engine_get_embedder_api(), g_autoptr(), kFlutterSemanticsActionTap, kSuccess, MOCK_ENGINE_PROC, FlutterSendSemanticsActionInfo::node_id, FlutterEngineProcTable::SendSemanticsAction, and FlutterSendSemanticsActionInfo::view_id.

TEST_F() [9/31]

TEST_F	(	FlEngineTest	,
		DuplicateLocale
	)

Definition at line 564 of file fl_engine_test.cc.

                                      {
  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
  g_setenv("LANGUAGE", "en:en", TRUE);
 
  bool called = false;
  fl_engine_get_embedder_api(engine)->UpdateLocales = MOCK_ENGINE_PROC(
      UpdateLocales, ([&called](auto engine, const FlutterLocale** locales,
                                size_t locales_count) {
        called = true;
 
        EXPECT_EQ(locales_count, static_cast<size_t>(2));
 
        EXPECT_STREQ(locales[0]->language_code, "en");
        EXPECT_STREQ(locales[0]->country_code, nullptr);
        EXPECT_STREQ(locales[0]->script_code, nullptr);
        EXPECT_STREQ(locales[0]->variant_code, nullptr);
 
        EXPECT_STREQ(locales[1]->language_code, "C");
        EXPECT_STREQ(locales[1]->country_code, nullptr);
        EXPECT_STREQ(locales[1]->script_code, nullptr);
        EXPECT_STREQ(locales[1]->variant_code, nullptr);
 
        return kSuccess;
      }));
 
  StartEngine();
 
  EXPECT_TRUE(called);
 
  if (initial_language) {
    g_setenv("LANGUAGE", initial_language, TRUE);
  } else {
    g_unsetenv("LANGUAGE");
  }
}

References engine, fl_engine_get_embedder_api(), kSuccess, MOCK_ENGINE_PROC, TRUE, and FlutterEngineProcTable::UpdateLocales.

TEST_F() [10/31]

TEST_F	(	FlEngineTest	,
		EmptyLocales
	)

Definition at line 600 of file fl_engine_test.cc.

                                   {
  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
  g_setenv("LANGUAGE", "de:: :en_US", TRUE);
 
  bool called = false;
  fl_engine_get_embedder_api(engine)->UpdateLocales = MOCK_ENGINE_PROC(
      UpdateLocales, ([&called](auto engine, const FlutterLocale** locales,
                                size_t locales_count) {
        called = true;
 
        EXPECT_EQ(locales_count, static_cast<size_t>(4));
 
        EXPECT_STREQ(locales[0]->language_code, "de");
        EXPECT_STREQ(locales[0]->country_code, nullptr);
        EXPECT_STREQ(locales[0]->script_code, nullptr);
        EXPECT_STREQ(locales[0]->variant_code, nullptr);
 
        EXPECT_STREQ(locales[1]->language_code, "en");
        EXPECT_STREQ(locales[1]->country_code, "US");
        EXPECT_STREQ(locales[1]->script_code, nullptr);
        EXPECT_STREQ(locales[1]->variant_code, nullptr);
 
        EXPECT_STREQ(locales[2]->language_code, "en");
        EXPECT_STREQ(locales[2]->country_code, nullptr);
        EXPECT_STREQ(locales[2]->script_code, nullptr);
        EXPECT_STREQ(locales[2]->variant_code, nullptr);
 
        EXPECT_STREQ(locales[3]->language_code, "C");
        EXPECT_STREQ(locales[3]->country_code, nullptr);
        EXPECT_STREQ(locales[3]->script_code, nullptr);
        EXPECT_STREQ(locales[3]->variant_code, nullptr);
 
        return kSuccess;
      }));
 
  StartEngine();
 
  EXPECT_TRUE(called);
 
  if (initial_language) {
    g_setenv("LANGUAGE", initial_language, TRUE);
  } else {
    g_unsetenv("LANGUAGE");
  }
}

References engine, fl_engine_get_embedder_api(), kSuccess, MOCK_ENGINE_PROC, TRUE, and FlutterEngineProcTable::UpdateLocales.

TEST_F() [11/31]

TEST_F	(	FlEngineTest	,
		EnableImpellerDefault
	)

Definition at line 959 of file fl_engine_test.cc.

                                            {
  bool called = false;
  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
      Initialize,
      ([&called](size_t version, const FlutterRendererConfig* config,
                 const FlutterProjectArgs* args, void* user_data,
                 FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
        called = true;
        bool has_impeller_switch = false;
        for (int i = 0; i < args->command_line_argc; i++) {
          if (strcmp(args->command_line_argv[i], "--enable-impeller") == 0) {
            has_impeller_switch = true;
          }
        }
        EXPECT_TRUE(has_impeller_switch);
        return kSuccess;
      }));
  fl_engine_get_embedder_api(engine)->RunInitialized =
      MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
 
  StartEngine();
  EXPECT_TRUE(called);
}

References args, engine, fl_engine_get_embedder_api(), FLUTTER_API_SYMBOL, i, FlutterEngineProcTable::Initialize, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::RunInitialized, and user_data.

TEST_F() [12/31]

TEST_F	(	FlEngineTest	,
		EngineId
	)

Definition at line 404 of file fl_engine_test.cc.

                               {
  int64_t engine_id;
  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
      Initialize,
      ([&engine_id](size_t version, const FlutterRendererConfig* config,
                    const FlutterProjectArgs* args, void* user_data,
                    FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
        engine_id = args->engine_id;
        return kSuccess;
      }));
  fl_engine_get_embedder_api(engine)->RunInitialized =
      MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
 
  StartEngine();
  EXPECT_TRUE(engine_id != 0);
 
  EXPECT_EQ(fl_engine_for_id(engine_id), engine);
}

References args, engine, fl_engine_for_id(), fl_engine_get_embedder_api(), FLUTTER_API_SYMBOL, FlutterEngineProcTable::Initialize, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::RunInitialized, and user_data.

TEST_F() [13/31]

TEST_F	(	FlEngineTest	,
		Locales
	)

Definition at line 487 of file fl_engine_test.cc.

                              {
  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
  g_setenv("LANGUAGE", "de:en_US", TRUE);
 
  bool called = false;
  fl_engine_get_embedder_api(engine)->UpdateLocales = MOCK_ENGINE_PROC(
      UpdateLocales, ([&called](auto engine, const FlutterLocale** locales,
                                size_t locales_count) {
        called = true;
 
        EXPECT_EQ(locales_count, static_cast<size_t>(4));
 
        EXPECT_STREQ(locales[0]->language_code, "de");
        EXPECT_STREQ(locales[0]->country_code, nullptr);
        EXPECT_STREQ(locales[0]->script_code, nullptr);
        EXPECT_STREQ(locales[0]->variant_code, nullptr);
 
        EXPECT_STREQ(locales[1]->language_code, "en");
        EXPECT_STREQ(locales[1]->country_code, "US");
        EXPECT_STREQ(locales[1]->script_code, nullptr);
        EXPECT_STREQ(locales[1]->variant_code, nullptr);
 
        EXPECT_STREQ(locales[2]->language_code, "en");
        EXPECT_STREQ(locales[2]->country_code, nullptr);
        EXPECT_STREQ(locales[2]->script_code, nullptr);
        EXPECT_STREQ(locales[2]->variant_code, nullptr);
 
        EXPECT_STREQ(locales[3]->language_code, "C");
        EXPECT_STREQ(locales[3]->country_code, nullptr);
        EXPECT_STREQ(locales[3]->script_code, nullptr);
        EXPECT_STREQ(locales[3]->variant_code, nullptr);
 
        return kSuccess;
      }));
 
  StartEngine();
 
  EXPECT_TRUE(called);
 
  if (initial_language) {
    g_setenv("LANGUAGE", initial_language, TRUE);
  } else {
    g_unsetenv("LANGUAGE");
  }
}

References engine, fl_engine_get_embedder_api(), kSuccess, MOCK_ENGINE_PROC, TRUE, and FlutterEngineProcTable::UpdateLocales.

TEST_F() [14/31]

TEST_F	(	FlEngineTest	,
		MousePointer
	)

Definition at line 102 of file fl_engine_test.cc.

                                   {
  bool called = false;
  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
      SendPointerEvent,
      ([&called](auto engine, const FlutterPointerEvent* events,
                 size_t events_count) {
        called = true;
        EXPECT_EQ(events_count, static_cast<size_t>(1));
        EXPECT_EQ(events[0].view_id, 1);
        EXPECT_EQ(events[0].phase, kDown);
        EXPECT_EQ(events[0].timestamp, static_cast<size_t>(1234567890));
        EXPECT_EQ(events[0].x, 800);
        EXPECT_EQ(events[0].y, 600);
        EXPECT_EQ(events[0].device, static_cast<int32_t>(0));
        EXPECT_EQ(events[0].signal_kind, kFlutterPointerSignalKindScroll);
        EXPECT_EQ(events[0].scroll_delta_x, 1.2);
        EXPECT_EQ(events[0].scroll_delta_y, -3.4);
        EXPECT_EQ(events[0].device_kind, kFlutterPointerDeviceKindMouse);
        EXPECT_EQ(events[0].buttons, kFlutterPointerButtonMouseSecondary);
 
        return kSuccess;
      }));
 
  StartEngine();
  fl_engine_send_mouse_pointer_event(engine, 1, kDown, 1234567890, 800, 600,
                                     kFlutterPointerDeviceKindMouse, 1.2, -3.4,
                                     kFlutterPointerButtonMouseSecondary, 0, 0);
 
  EXPECT_TRUE(called);
}

References device, engine, fl_engine_get_embedder_api(), fl_engine_send_mouse_pointer_event(), kDown, kFlutterPointerButtonMouseSecondary, kFlutterPointerDeviceKindMouse, kFlutterPointerSignalKindScroll, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

TEST_F() [15/31]

TEST_F	(	FlEngineTest	,
		MousePointerDeviceState
	)

Definition at line 134 of file fl_engine_test.cc.

                                              {
  bool device_state_sent = false;
  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
      SendPointerEvent,
      ([&device_state_sent](auto engine, const FlutterPointerEvent* events,
                            size_t events_count) {
        device_state_sent = true;
        EXPECT_EQ(events_count, static_cast<size_t>(1));
        EXPECT_DOUBLE_EQ(events[0].pressure, 0.5);
        EXPECT_DOUBLE_EQ(events[0].pressure_min, 0.0);
        EXPECT_DOUBLE_EQ(events[0].pressure_max, 1.0);
        EXPECT_DOUBLE_EQ(events[0].rotation, G_PI / 2.0);
 
        return kSuccess;
      }));
 
  StartEngine();
  fl_engine_send_mouse_pointer_event(
      engine, 1, kDown, 1234567890, 800, 600, kFlutterPointerDeviceKindMouse,
      1.2, -3.4, kFlutterPointerButtonMouseSecondary, 90.0, 0.5);
 
  EXPECT_TRUE(device_state_sent);
}

References engine, fl_engine_get_embedder_api(), fl_engine_send_mouse_pointer_event(), kDown, kFlutterPointerButtonMouseSecondary, kFlutterPointerDeviceKindMouse, kSuccess, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPointerEvent.

TEST_F() [16/31]

TEST_F	(	FlEngineTest	,
		NotifyDisplayUpdate
	)

Definition at line 22 of file fl_engine_test.cc.

                                          {
  StartEngine();
 
  bool called = false;
  fl_engine_get_embedder_api(engine)->NotifyDisplayUpdate = MOCK_ENGINE_PROC(
      NotifyDisplayUpdate,
      ([&called](auto engine, FlutterEngineDisplaysUpdateType update_type,
                 const FlutterEngineDisplay* displays, size_t displays_length) {
        called = true;
        EXPECT_EQ(update_type, kFlutterEngineDisplaysUpdateTypeStartup);
        EXPECT_EQ(displays_length, 2u);
 
        EXPECT_EQ(displays[0].display_id, 1u);
        EXPECT_EQ(displays[0].refresh_rate, 60);
        EXPECT_EQ(displays[0].width, 1024u);
        EXPECT_EQ(displays[0].height, 768u);
        EXPECT_EQ(displays[0].device_pixel_ratio, 1.0);
 
        EXPECT_EQ(displays[1].display_id, 2u);
        EXPECT_EQ(displays[1].refresh_rate, 120);
        EXPECT_EQ(displays[1].width, 3840u);
        EXPECT_EQ(displays[1].height, 2160u);
        EXPECT_EQ(displays[1].device_pixel_ratio, 2.0);
 
        return kSuccess;
      }));
 
  FlutterEngineDisplay displays[2] = {
      {
          .struct_size = sizeof(FlutterEngineDisplay),
          .display_id = 1,
          .single_display = false,
          .refresh_rate = 60.0,
          .width = 1024,
          .height = 768,
          .device_pixel_ratio = 1.0,
      },
      {
          .struct_size = sizeof(FlutterEngineDisplay),
          .display_id = 2,
          .single_display = false,
          .refresh_rate = 120.0,
          .width = 3840,
          .height = 2160,
          .device_pixel_ratio = 2.0,
      }};
  fl_engine_notify_display_update(engine, displays, 2);
 
  EXPECT_TRUE(called);
}

References displays, engine, fl_engine_get_embedder_api(), fl_engine_notify_display_update(), height, kFlutterEngineDisplaysUpdateTypeStartup, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::NotifyDisplayUpdate, FlutterEngineDisplay::struct_size, and width.

TEST_F() [17/31]

TEST_F	(	FlEngineTest	,
		OnPreEngineRestart
	)

Definition at line 334 of file fl_engine_test.cc.

                                         {
  OnPreEngineRestartCallback callback;
  void* callback_user_data;
 
  bool called = false;
  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
      Initialize, ([&callback, &callback_user_data, &called](
                       size_t version, const FlutterRendererConfig* config,
                       const FlutterProjectArgs* args, void* user_data,
                       FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
        called = true;
        callback = args->on_pre_engine_restart_callback;
        callback_user_data = user_data;
 
        return kSuccess;
      }));
  fl_engine_get_embedder_api(engine)->RunInitialized =
      MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
 
  StartEngine();
 
  EXPECT_TRUE(called);
  EXPECT_NE(callback, nullptr);
 
  // The following call has no effect but should not crash.
  callback(callback_user_data);
 
  int count = 0;
 
  // Set handler so that:
  //
  //  * When the engine restarts, count += 1;
  //  * When the engine is freed, count += 10.
  g_signal_connect(engine, "on-pre-engine-restart",
                   G_CALLBACK(on_pre_engine_restart_cb), &count);
 
  callback(callback_user_data);
  EXPECT_EQ(count, 1);
}

References args, callback, engine, fl_engine_get_embedder_api(), FLUTTER_API_SYMBOL, FlutterEngineProcTable::Initialize, kSuccess, MOCK_ENGINE_PROC, on_pre_engine_restart_cb(), FlutterEngineProcTable::RunInitialized, and user_data.

TEST_F() [18/31]

TEST_F	(	FlEngineTest	,
		PlatformMessage
	)

Definition at line 219 of file fl_engine_test.cc.

                                      {
  bool called = false;
  FlutterEngineSendPlatformMessageFnPtr old_handler =
      fl_engine_get_embedder_api(engine)->SendPlatformMessage;
  fl_engine_get_embedder_api(engine)->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&called, old_handler](auto engine,
                              const FlutterPlatformMessage* message) {
        if (strcmp(message->channel, "test") != 0) {
          return old_handler(engine, message);
        }
 
        called = true;
 
        EXPECT_EQ(message->message_size, static_cast<size_t>(4));
        EXPECT_EQ(message->message[0], 't');
        EXPECT_EQ(message->message[1], 'e');
        EXPECT_EQ(message->message[2], 's');
        EXPECT_EQ(message->message[3], 't');
 
        return kSuccess;
      }));
 
  StartEngine();
  g_autoptr(GBytes) message = g_bytes_new_static("test", 4);
  fl_engine_send_platform_message(engine, "test", message, nullptr, nullptr,
                                  nullptr);
 
  EXPECT_TRUE(called);
}

References engine, fl_engine_get_embedder_api(), fl_engine_send_platform_message(), g_autoptr(), kSuccess, message, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPlatformMessage.

TEST_F() [19/31]

TEST_F	(	FlEngineTest	,
		PlatformMessageResponse
	)

Definition at line 251 of file fl_engine_test.cc.

                                              {
  bool called = false;
  fl_engine_get_embedder_api(engine)->SendPlatformMessageResponse =
      MOCK_ENGINE_PROC(
          SendPlatformMessageResponse,
          ([&called](auto engine,
                     const FlutterPlatformMessageResponseHandle* handle,
                     const uint8_t* data, size_t data_length) {
            called = true;
 
            EXPECT_EQ(
                handle,
                reinterpret_cast<const FlutterPlatformMessageResponseHandle*>(
                    42));
            EXPECT_EQ(data_length, static_cast<size_t>(4));
            EXPECT_EQ(data[0], 't');
            EXPECT_EQ(data[1], 'e');
            EXPECT_EQ(data[2], 's');
            EXPECT_EQ(data[3], 't');
 
            return kSuccess;
          }));
 
  g_autoptr(GError) error = nullptr;
  StartEngine();
  g_autoptr(GBytes) response = g_bytes_new_static("test", 4);
  EXPECT_TRUE(fl_engine_send_platform_message_response(
      engine, reinterpret_cast<const FlutterPlatformMessageResponseHandle*>(42),
      response, &error));
  EXPECT_EQ(error, nullptr);
 
  EXPECT_TRUE(called);
}

References engine, error, fl_engine_get_embedder_api(), fl_engine_send_platform_message_response(), g_autoptr(), kSuccess, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPlatformMessageResponse.

TEST_F() [20/31]

TEST_F	(	FlEngineTest	,
		PointerPanZoom
	)

Definition at line 159 of file fl_engine_test.cc.

                                     {
  bool called = false;
  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
      SendPointerEvent,
      ([&called](auto engine, const FlutterPointerEvent* events,
                 size_t events_count) {
        called = true;
        EXPECT_EQ(events_count, static_cast<size_t>(1));
        EXPECT_EQ(events[0].view_id, 1);
        EXPECT_EQ(events[0].phase, kPanZoomUpdate);
        EXPECT_EQ(events[0].timestamp, static_cast<size_t>(1234567890));
        EXPECT_EQ(events[0].x, 800);
        EXPECT_EQ(events[0].y, 600);
        EXPECT_EQ(events[0].device, static_cast<int32_t>(1));
        EXPECT_EQ(events[0].signal_kind, kFlutterPointerSignalKindNone);
        EXPECT_EQ(events[0].pan_x, 1.5);
        EXPECT_EQ(events[0].pan_y, 2.5);
        EXPECT_EQ(events[0].scale, 3.5);
        EXPECT_EQ(events[0].rotation, 4.5);
        EXPECT_EQ(events[0].device_kind, kFlutterPointerDeviceKindTrackpad);
        EXPECT_EQ(events[0].buttons, 0);
 
        return kSuccess;
      }));
 
  StartEngine();
  fl_engine_send_pointer_pan_zoom_event(engine, 1, 1234567890, 800, 600,
                                        kPanZoomUpdate, 1.5, 2.5, 3.5, 4.5);
 
  EXPECT_TRUE(called);
}

References device, engine, fl_engine_get_embedder_api(), fl_engine_send_pointer_pan_zoom_event(), kFlutterPointerDeviceKindTrackpad, kFlutterPointerSignalKindNone, kPanZoomUpdate, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

TEST_F() [21/31]

TEST_F	(	FlEngineTest	,
		RemoveView
	)

Definition at line 762 of file fl_engine_test.cc.

                                 {
  bool called = false;
  fl_engine_get_embedder_api(engine)->RemoveView = MOCK_ENGINE_PROC(
      RemoveView, ([&called](auto engine, const FlutterRemoveViewInfo* info) {
        called = true;
        EXPECT_EQ(info->view_id, 123);
 
        FlutterRemoveViewResult result;
        result.struct_size = sizeof(FlutterRemoveViewResult);
        result.removed = true;
        result.user_data = info->user_data;
        info->remove_view_callback(&result);
 
        return kSuccess;
      }));
 
  fl_engine_remove_view(engine, 123, nullptr, remove_view_cb, loop);
  EXPECT_TRUE(called);
 
  // Blocks here until remove_view_cb is called.
  g_main_loop_run(loop);
}

References engine, fl_engine_get_embedder_api(), fl_engine_remove_view(), kSuccess, MOCK_ENGINE_PROC, FlutterRemoveViewInfo::remove_view_callback, remove_view_cb(), FlutterRemoveViewResult::removed, FlutterEngineProcTable::RemoveView, FlutterRemoveViewResult::struct_size, FlutterRemoveViewResult::user_data, FlutterRemoveViewInfo::user_data, and FlutterRemoveViewInfo::view_id.

TEST_F() [22/31]

TEST_F	(	FlEngineTest	,
		RemoveViewEngineError
	)

Definition at line 825 of file fl_engine_test.cc.

                                            {
  fl_engine_get_embedder_api(engine)->RemoveView = MOCK_ENGINE_PROC(
      RemoveView, ([](auto engine, const FlutterRemoveViewInfo* info) {
        return kInvalidArguments;
      }));
 
  fl_engine_remove_view(engine, 123, nullptr, remove_view_engine_error_cb,
                        loop);
 
  // Blocks here until remove_view_engine_error_cb is called.
  g_main_loop_run(loop);
}

References engine, fl_engine_get_embedder_api(), fl_engine_remove_view(), kInvalidArguments, MOCK_ENGINE_PROC, remove_view_engine_error_cb(), and FlutterEngineProcTable::RemoveView.

TEST_F() [23/31]

TEST_F	(	FlEngineTest	,
		RemoveViewError
	)

Definition at line 796 of file fl_engine_test.cc.

                                      {
  fl_engine_get_embedder_api(engine)->RemoveView = MOCK_ENGINE_PROC(
      RemoveView, ([](auto engine, const FlutterRemoveViewInfo* info) {
        FlutterRemoveViewResult result;
        result.struct_size = sizeof(FlutterRemoveViewResult);
        result.removed = false;
        result.user_data = info->user_data;
        info->remove_view_callback(&result);
 
        return kSuccess;
      }));
 
  fl_engine_remove_view(engine, 123, nullptr, remove_view_error_cb, loop);
 
  // Blocks here until remove_view_error_cb is called.
  g_main_loop_run(loop);
}

References engine, fl_engine_get_embedder_api(), fl_engine_remove_view(), kSuccess, MOCK_ENGINE_PROC, FlutterRemoveViewInfo::remove_view_callback, remove_view_error_cb(), FlutterRemoveViewResult::removed, FlutterEngineProcTable::RemoveView, FlutterRemoveViewResult::struct_size, FlutterRemoveViewResult::user_data, and FlutterRemoveViewInfo::user_data.

TEST_F() [24/31]

TEST_F	(	FlEngineTest	,
		SendKeyEvent
	)

Definition at line 838 of file fl_engine_test.cc.

                                   {
  StartEngine();
 
  bool called;
  fl_engine_get_embedder_api(engine)->SendKeyEvent = MOCK_ENGINE_PROC(
      SendKeyEvent,
      ([&called](auto engine, const FlutterKeyEvent* event,
                 FlutterKeyEventCallback callback, void* user_data) {
        called = true;
        EXPECT_EQ(event->timestamp, 1234);
        EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
        EXPECT_EQ(event->physical, static_cast<uint64_t>(42));
        EXPECT_EQ(event->logical, static_cast<uint64_t>(123));
        EXPECT_TRUE(event->synthesized);
        EXPECT_EQ(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
        callback(TRUE, user_data);
        return kSuccess;
      }));
 
  FlutterKeyEvent event = {.struct_size = sizeof(FlutterKeyEvent),
                           .timestamp = 1234,
                           .type = kFlutterKeyEventTypeUp,
                           .physical = 42,
                           .logical = 123,
                           .character = nullptr,
                           .synthesized = true,
                           .device_type = kFlutterKeyEventDeviceTypeKeyboard};
  fl_engine_send_key_event(
      engine, &event, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        gboolean handled;
        g_autoptr(GError) error = nullptr;
        EXPECT_TRUE(fl_engine_send_key_event_finish(FL_ENGINE(object), result,
                                                    &handled, &error));
        EXPECT_EQ(error, nullptr);
        EXPECT_TRUE(handled);
        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);
 
  g_main_loop_run(loop);
  EXPECT_TRUE(called);
}

References callback, character, FlutterKeyEvent::device_type, engine, error, fl_engine_get_embedder_api(), fl_engine_send_key_event(), fl_engine_send_key_event_finish(), g_autoptr(), kFlutterKeyEventDeviceTypeKeyboard, kFlutterKeyEventTypeUp, kSuccess, FlutterKeyEvent::logical, MOCK_ENGINE_PROC, FlutterKeyEvent::physical, FlutterEngineProcTable::SendKeyEvent, FlutterKeyEvent::struct_size, FlutterKeyEvent::synthesized, FlutterKeyEvent::timestamp, TRUE, type, FlutterKeyEvent::type, and user_data.

TEST_F() [25/31]

TEST_F	(	FlEngineTest	,
		SendKeyEventError
	)

Definition at line 920 of file fl_engine_test.cc.

                                        {
  g_autoptr(GError) error = nullptr;
  // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.Assign)
  StartEngine();
 
  bool called;
  fl_engine_get_embedder_api(engine)->SendKeyEvent = MOCK_ENGINE_PROC(
      SendKeyEvent,
      ([&called](auto engine, const FlutterKeyEvent* event,
                 FlutterKeyEventCallback callback, void* user_data) {
        called = true;
        return kInvalidArguments;
      }));
 
  FlutterKeyEvent event = {.struct_size = sizeof(FlutterKeyEvent),
                           .timestamp = 1234,
                           .type = kFlutterKeyEventTypeUp,
                           .physical = 42,
                           .logical = 123,
                           .character = nullptr,
                           .synthesized = true,
                           .device_type = kFlutterKeyEventDeviceTypeKeyboard};
  fl_engine_send_key_event(
      engine, &event, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        gboolean handled;
        g_autoptr(GError) error = nullptr;
        EXPECT_FALSE(fl_engine_send_key_event_finish(FL_ENGINE(object), result,
                                                     &handled, &error));
        EXPECT_NE(error, nullptr);
        EXPECT_STREQ(error->message, "Failed to send key event");
        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);
 
  g_main_loop_run(loop);
  EXPECT_TRUE(called);
}

References callback, character, engine, error, fl_engine_get_embedder_api(), fl_engine_send_key_event(), fl_engine_send_key_event_finish(), g_autoptr(), kFlutterKeyEventDeviceTypeKeyboard, kFlutterKeyEventTypeUp, kInvalidArguments, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendKeyEvent, FlutterKeyEvent::struct_size, type, and user_data.

TEST_F() [26/31]

TEST_F	(	FlEngineTest	,
		SendKeyEventNotHandled
	)

Definition at line 882 of file fl_engine_test.cc.

                                             {
  StartEngine();
 
  bool called;
  fl_engine_get_embedder_api(engine)->SendKeyEvent = MOCK_ENGINE_PROC(
      SendKeyEvent,
      ([&called](auto engine, const FlutterKeyEvent* event,
                 FlutterKeyEventCallback callback, void* user_data) {
        called = true;
        callback(FALSE, user_data);
        return kSuccess;
      }));
 
  FlutterKeyEvent event = {.struct_size = sizeof(FlutterKeyEvent),
                           .timestamp = 1234,
                           .type = kFlutterKeyEventTypeUp,
                           .physical = 42,
                           .logical = 123,
                           .character = nullptr,
                           .synthesized = true,
                           .device_type = kFlutterKeyEventDeviceTypeKeyboard};
  fl_engine_send_key_event(
      engine, &event, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        gboolean handled;
        g_autoptr(GError) error = nullptr;
        EXPECT_TRUE(fl_engine_send_key_event_finish(FL_ENGINE(object), result,
                                                    &handled, &error));
        EXPECT_EQ(error, nullptr);
        EXPECT_FALSE(handled);
        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);
 
  g_main_loop_run(loop);
  EXPECT_TRUE(called);
}

References callback, character, engine, error, fl_engine_get_embedder_api(), fl_engine_send_key_event(), fl_engine_send_key_event_finish(), g_autoptr(), kFlutterKeyEventDeviceTypeKeyboard, kFlutterKeyEventTypeUp, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendKeyEvent, FlutterKeyEvent::struct_size, type, and user_data.

TEST_F() [27/31]

TEST_F	(	FlEngineTest	,
		SettingsHandler
	)

Definition at line 286 of file fl_engine_test.cc.

                                      {
  bool called = false;
  fl_engine_get_embedder_api(engine)->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&called](auto engine, const FlutterPlatformMessage* message) {
        called = true;
 
        EXPECT_STREQ(message->channel, "flutter/settings");
 
        g_autoptr(FlJsonMessageCodec) codec = fl_json_message_codec_new();
        g_autoptr(GBytes) data =
            g_bytes_new(message->message, message->message_size);
        g_autoptr(GError) error = nullptr;
        g_autoptr(FlValue) settings = fl_message_codec_decode_message(
            FL_MESSAGE_CODEC(codec), data, &error);
        EXPECT_NE(settings, nullptr);
        EXPECT_EQ(error, nullptr);
 
        FlValue* text_scale_factor =
            fl_value_lookup_string(settings, "textScaleFactor");
        EXPECT_NE(text_scale_factor, nullptr);
        EXPECT_EQ(fl_value_get_type(text_scale_factor), FL_VALUE_TYPE_FLOAT);
 
        FlValue* always_use_24hr_format =
            fl_value_lookup_string(settings, "alwaysUse24HourFormat");
        EXPECT_NE(always_use_24hr_format, nullptr);
        EXPECT_EQ(fl_value_get_type(always_use_24hr_format),
                  FL_VALUE_TYPE_BOOL);
 
        FlValue* platform_brightness =
            fl_value_lookup_string(settings, "platformBrightness");
        EXPECT_NE(platform_brightness, nullptr);
        EXPECT_EQ(fl_value_get_type(platform_brightness), FL_VALUE_TYPE_STRING);
 
        return kSuccess;
      }));
 
  StartEngine();
 
  EXPECT_TRUE(called);
}

References engine, 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(), kSuccess, message, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPlatformMessage.

TEST_F() [28/31]

TEST_F	(	FlEngineTest	,
		UIIsolateDefaultThreadPolicy
	)

Definition at line 423 of file fl_engine_test.cc.

                                                   {
  fl_dart_project_set_ui_thread_policy(project, FL_UI_THREAD_POLICY_DEFAULT);
 
  bool same_task_runner = false;
 
  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
      Initialize,
      ([&same_task_runner](size_t version, const FlutterRendererConfig* config,
                           const FlutterProjectArgs* args, void* user_data,
                           FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
        same_task_runner = args->custom_task_runners->platform_task_runner ==
                           args->custom_task_runners->ui_task_runner;
        return kSuccess;
      }));
  fl_engine_get_embedder_api(engine)->RunInitialized =
      MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
 
  StartEngine();
  EXPECT_TRUE(same_task_runner);
}

References args, engine, fl_dart_project_set_ui_thread_policy(), fl_engine_get_embedder_api(), FL_UI_THREAD_POLICY_DEFAULT, FLUTTER_API_SYMBOL, FlutterEngineProcTable::Initialize, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::RunInitialized, and user_data.

TEST_F() [29/31]

TEST_F	(	FlEngineTest	,
		UIIsolateOnPlatformTaskRunner
	)

Definition at line 444 of file fl_engine_test.cc.

                                                    {
  fl_dart_project_set_ui_thread_policy(
      project, FL_UI_THREAD_POLICY_RUN_ON_PLATFORM_THREAD);
 
  bool same_task_runner = false;
 
  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
      Initialize,
      ([&same_task_runner](size_t version, const FlutterRendererConfig* config,
                           const FlutterProjectArgs* args, void* user_data,
                           FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
        same_task_runner = args->custom_task_runners->platform_task_runner ==
                           args->custom_task_runners->ui_task_runner;
        return kSuccess;
      }));
  fl_engine_get_embedder_api(engine)->RunInitialized =
      MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
 
  StartEngine();
  EXPECT_TRUE(same_task_runner);
}

References args, engine, fl_dart_project_set_ui_thread_policy(), fl_engine_get_embedder_api(), FL_UI_THREAD_POLICY_RUN_ON_PLATFORM_THREAD, FLUTTER_API_SYMBOL, FlutterEngineProcTable::Initialize, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::RunInitialized, and user_data.

TEST_F() [30/31]

TEST_F	(	FlEngineTest	,
		UIIsolateOnSeparateThread
	)

Definition at line 466 of file fl_engine_test.cc.

                                                {
  fl_dart_project_set_ui_thread_policy(
      project, FL_UI_THREAD_POLICY_RUN_ON_SEPARATE_THREAD);
 
  bool separate_thread = false;
 
  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
      Initialize,
      ([&separate_thread](size_t version, const FlutterRendererConfig* config,
                          const FlutterProjectArgs* args, void* user_data,
                          FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
        separate_thread = args->custom_task_runners->ui_task_runner == nullptr;
        return kSuccess;
      }));
  fl_engine_get_embedder_api(engine)->RunInitialized =
      MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
 
  StartEngine();
  EXPECT_TRUE(separate_thread);
}

References args, engine, fl_dart_project_set_ui_thread_policy(), fl_engine_get_embedder_api(), FL_UI_THREAD_POLICY_RUN_ON_SEPARATE_THREAD, FLUTTER_API_SYMBOL, FlutterEngineProcTable::Initialize, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::RunInitialized, and user_data.

TEST_F() [31/31]

TEST_F	(	FlEngineTest	,
		WindowMetrics
	)

Definition at line 74 of file fl_engine_test.cc.

                                    {
  StartEngine();
 
  bool called = false;
  fl_engine_get_embedder_api(engine)->SendWindowMetricsEvent = MOCK_ENGINE_PROC(
      SendWindowMetricsEvent,
      ([&called](auto engine, const FlutterWindowMetricsEvent* event) {
        called = true;
        EXPECT_EQ(event->display_id, 99u);
        EXPECT_EQ(event->view_id, 1);
        EXPECT_EQ(event->width, 800u);
        EXPECT_EQ(event->height, 600u);
        EXPECT_TRUE(event->has_constraints);
        EXPECT_EQ(event->min_width_constraint, 800u);
        EXPECT_EQ(event->min_height_constraint, 600u);
        EXPECT_EQ(event->max_width_constraint, 3840u);
        EXPECT_EQ(event->max_height_constraint, 2160u);
        EXPECT_EQ(event->pixel_ratio, 2.0);
 
        return kSuccess;
      }));
 
  fl_engine_send_window_metrics_event(engine, 99, 1, 800, 600, 3840, 2160, 2.0);
 
  EXPECT_TRUE(called);
}

References FlutterWindowMetricsEvent::display_id, engine, fl_engine_get_embedder_api(), fl_engine_send_window_metrics_event(), FlutterWindowMetricsEvent::has_constraints, FlutterWindowMetricsEvent::height, kSuccess, FlutterWindowMetricsEvent::max_height_constraint, FlutterWindowMetricsEvent::max_width_constraint, FlutterWindowMetricsEvent::min_height_constraint, FlutterWindowMetricsEvent::min_width_constraint, MOCK_ENGINE_PROC, FlutterWindowMetricsEvent::pixel_ratio, FlutterEngineProcTable::SendWindowMetricsEvent, FlutterWindowMetricsEvent::view_id, and FlutterWindowMetricsEvent::width.