#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"

Functions
	TEST (FlEngineTest, NotifyDisplayUpdate)

	TEST (FlEngineTest, WindowMetrics)

	TEST (FlEngineTest, MousePointer)

	TEST (FlEngineTest, PointerPanZoom)

	TEST (FlEngineTest, DispatchSemanticsAction)

	TEST (FlEngineTest, PlatformMessage)

	TEST (FlEngineTest, PlatformMessageResponse)

	TEST (FlEngineTest, SettingsHandler)

void	on_pre_engine_restart_cb (FlEngine *engine, gpointer user_data)

	TEST (FlEngineTest, OnPreEngineRestart)

	TEST (FlEngineTest, DartEntrypointArgs)

	TEST (FlEngineTest, EngineId)

	TEST (FlEngineTest, UIIsolateDefaultThreadPolicy)

	TEST (FlEngineTest, UIIsolateOnPlatformTaskRunner)

	TEST (FlEngineTest, UIIsolateOnSeparateThread)

	TEST (FlEngineTest, Locales)

	TEST (FlEngineTest, CLocale)

	TEST (FlEngineTest, DuplicateLocale)

	TEST (FlEngineTest, EmptyLocales)

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

	TEST (FlEngineTest, AddView)

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

	TEST (FlEngineTest, AddViewError)

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

	TEST (FlEngineTest, AddViewEngineError)

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

	TEST (FlEngineTest, RemoveView)

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

	TEST (FlEngineTest, RemoveViewError)

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

	TEST (FlEngineTest, RemoveViewEngineError)

	TEST (FlEngineTest, SendKeyEvent)

	TEST (FlEngineTest, SendKeyEventNotHandled)

	TEST (FlEngineTest, SendKeyEventError)

	TEST (FlEngineTest, ChildObjects)

Function Documentation

◆ add_view_cb()

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

static

Definition at line 697 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().

◆ add_view_engine_error_cb()

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

static

Definition at line 780 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().

◆ add_view_error_cb()

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

static

Definition at line 742 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().

◆ on_pre_engine_restart_cb()

void on_pre_engine_restart_cb	(	FlEngine *	engine,
		gpointer	user_data
	)

Definition at line 334 of file fl_engine_test.cc.

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

References user_data.

Referenced by TEST().

◆ remove_view_cb()

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

static

Definition at line 812 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().

◆ remove_view_engine_error_cb()

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

static

Definition at line 885 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().

◆ remove_view_error_cb()

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

static

Definition at line 851 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().

◆ TEST() [1/28]

TEST	(	FlEngineTest	,
		AddView
	)

Definition at line 708 of file fl_engine_test.cc.

                            {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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_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, 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_dart_project_new(), fl_engine_add_view(), fl_engine_get_embedder_api(), fl_engine_new(), g_autoptr(), FlutterWindowMetricsEvent::height, kSuccess, MOCK_ENGINE_PROC, FlutterWindowMetricsEvent::pixel_ratio, FlutterAddViewResult::struct_size, FlutterAddViewResult::user_data, FlutterAddViewInfo::user_data, view_id, FlutterAddViewInfo::view_metrics, and FlutterWindowMetricsEvent::width.

◆ TEST() [2/28]

TEST	(	FlEngineTest	,
		AddViewEngineError
	)

Definition at line 791 of file fl_engine_test.cc.

                                       {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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, 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_dart_project_new(), fl_engine_add_view(), fl_engine_get_embedder_api(), fl_engine_new(), g_autoptr(), kInvalidArguments, MOCK_ENGINE_PROC, and view_id.

◆ TEST() [3/28]

TEST	(	FlEngineTest	,
		AddViewError
	)

Definition at line 753 of file fl_engine_test.cc.

                                 {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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, 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_dart_project_new(), fl_engine_add_view(), fl_engine_get_embedder_api(), fl_engine_new(), g_autoptr(), kSuccess, MOCK_ENGINE_PROC, FlutterAddViewResult::struct_size, FlutterAddViewResult::user_data, FlutterAddViewInfo::user_data, and view_id.

◆ TEST() [4/28]

TEST	(	FlEngineTest	,
		ChildObjects
	)

Definition at line 1055 of file fl_engine_test.cc.

                                 {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  // 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);
  EXPECT_NE(fl_engine_get_windowing_handler(engine), nullptr);
}

References engine, fl_dart_project_new(), fl_engine_get_binary_messenger(), fl_engine_get_display_monitor(), fl_engine_get_keyboard_manager(), fl_engine_get_mouse_cursor_handler(), fl_engine_get_task_runner(), fl_engine_get_windowing_handler(), fl_engine_new(), and g_autoptr().

◆ TEST() [5/28]

TEST	(	FlEngineTest	,
		CLocale
	)

Definition at line 569 of file fl_engine_test.cc.

                            {
  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
  g_setenv("LANGUAGE", "C", TRUE);
  g_autoptr(FlDartProject) project = fl_dart_project_new();
 
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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;
      }));
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
 
  EXPECT_TRUE(called);
 
  if (initial_language) {
    g_setenv("LANGUAGE", initial_language, TRUE);
  } else {
    g_unsetenv("LANGUAGE");
  }
}

References engine, error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), g_autoptr(), kSuccess, MOCK_ENGINE_PROC, TRUE, and FlutterEngineProcTable::UpdateLocales.

◆ TEST() [6/28]

TEST	(	FlEngineTest	,
		DartEntrypointArgs
	)

Definition at line 385 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));
 
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  fl_dart_project_set_dart_entrypoint_arguments(project, args);
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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; }));
 
  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_new(), fl_dart_project_set_dart_entrypoint_arguments(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), FLUTTER_API_SYMBOL, g_autoptr(), FlutterEngineProcTable::Initialize, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::RunInitialized, and user_data.

◆ TEST() [7/28]

TEST	(	FlEngineTest	,
		DispatchSemanticsAction
	)

Definition at line 179 of file fl_engine_test.cc.

                                            {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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;
      }));
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
  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, data, FlutterSendSemanticsActionInfo::data, FlutterSendSemanticsActionInfo::data_length, engine, error, fl_dart_project_new(), fl_engine_dispatch_semantics_action(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), g_autoptr(), kFlutterSemanticsActionTap, kSuccess, MOCK_ENGINE_PROC, FlutterSendSemanticsActionInfo::node_id, FlutterEngineProcTable::SendSemanticsAction, and FlutterSendSemanticsActionInfo::view_id.

◆ TEST() [8/28]

TEST	(	FlEngineTest	,
		DuplicateLocale
	)

Definition at line 605 of file fl_engine_test.cc.

                                    {
  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
  g_setenv("LANGUAGE", "en:en", TRUE);
  g_autoptr(FlDartProject) project = fl_dart_project_new();
 
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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;
      }));
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
 
  EXPECT_TRUE(called);
 
  if (initial_language) {
    g_setenv("LANGUAGE", initial_language, TRUE);
  } else {
    g_unsetenv("LANGUAGE");
  }
}

References engine, error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), g_autoptr(), kSuccess, MOCK_ENGINE_PROC, TRUE, and FlutterEngineProcTable::UpdateLocales.

◆ TEST() [9/28]

TEST	(	FlEngineTest	,
		EmptyLocales
	)

Definition at line 646 of file fl_engine_test.cc.

                                 {
  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
  g_setenv("LANGUAGE", "de:: :en_US", TRUE);
  g_autoptr(FlDartProject) project = fl_dart_project_new();
 
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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;
      }));
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
 
  EXPECT_TRUE(called);
 
  if (initial_language) {
    g_setenv("LANGUAGE", initial_language, TRUE);
  } else {
    g_unsetenv("LANGUAGE");
  }
}

References engine, error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), g_autoptr(), kSuccess, MOCK_ENGINE_PROC, TRUE, and FlutterEngineProcTable::UpdateLocales.

◆ TEST() [10/28]

TEST	(	FlEngineTest	,
		EngineId
	)

Definition at line 419 of file fl_engine_test.cc.

                             {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
  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; }));
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
  EXPECT_TRUE(engine_id != 0);
 
  EXPECT_EQ(fl_engine_for_id(engine_id), engine);
}

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

◆ TEST() [11/28]

TEST	(	FlEngineTest	,
		Locales
	)

Definition at line 518 of file fl_engine_test.cc.

                            {
  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
  g_setenv("LANGUAGE", "de:en_US", TRUE);
  g_autoptr(FlDartProject) project = fl_dart_project_new();
 
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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;
      }));
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
 
  EXPECT_TRUE(called);
 
  if (initial_language) {
    g_setenv("LANGUAGE", initial_language, TRUE);
  } else {
    g_unsetenv("LANGUAGE");
  }
}

References engine, error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), g_autoptr(), kSuccess, MOCK_ENGINE_PROC, TRUE, and FlutterEngineProcTable::UpdateLocales.

◆ TEST() [12/28]

TEST	(	FlEngineTest	,
		MousePointer
	)

Definition at line 104 of file fl_engine_test.cc.

                                 {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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;
      }));
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
  fl_engine_send_mouse_pointer_event(engine, 1, kDown, 1234567890, 800, 600,
                                     kFlutterPointerDeviceKindMouse, 1.2, -3.4,
                                     kFlutterPointerButtonMouseSecondary);
 
  EXPECT_TRUE(called);
}

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

◆ TEST() [13/28]

TEST	(	FlEngineTest	,
		NotifyDisplayUpdate
	)

Definition at line 19 of file fl_engine_test.cc.

                                        {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
 
  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, error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_notify_display_update(), fl_engine_start(), g_autoptr(), height, kFlutterEngineDisplaysUpdateTypeStartup, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::NotifyDisplayUpdate, FlutterEngineDisplay::struct_size, and width.

◆ TEST() [14/28]

TEST	(	FlEngineTest	,
		OnPreEngineRestart
	)

Definition at line 340 of file fl_engine_test.cc.

                                       {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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; }));
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
 
  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, error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), FLUTTER_API_SYMBOL, g_autoptr(), FlutterEngineProcTable::Initialize, kSuccess, MOCK_ENGINE_PROC, on_pre_engine_restart_cb(), FlutterEngineProcTable::RunInitialized, and user_data.

◆ TEST() [15/28]

TEST	(	FlEngineTest	,
		PlatformMessage
	)

Definition at line 211 of file fl_engine_test.cc.

                                    {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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;
      }));
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
  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, error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_send_platform_message(), fl_engine_start(), g_autoptr(), kSuccess, message, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPlatformMessage.

◆ TEST() [16/28]

TEST	(	FlEngineTest	,
		PlatformMessageResponse
	)

Definition at line 248 of file fl_engine_test.cc.

                                            {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
  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 data, engine, error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_send_platform_message_response(), fl_engine_start(), g_autoptr(), kSuccess, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendPlatformMessageResponse.

◆ TEST() [17/28]

TEST	(	FlEngineTest	,
		PointerPanZoom
	)

Definition at line 141 of file fl_engine_test.cc.

                                   {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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;
      }));
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
  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, error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_send_pointer_pan_zoom_event(), fl_engine_start(), g_autoptr(), kFlutterPointerDeviceKindTrackpad, kFlutterPointerSignalKindNone, kPanZoomUpdate, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendPointerEvent, view_id, x, and y.

◆ TEST() [18/28]

TEST	(	FlEngineTest	,
		RemoveView
	)

Definition at line 823 of file fl_engine_test.cc.

                               {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_remove_view(), g_autoptr(), 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() [19/28]

TEST	(	FlEngineTest	,
		RemoveViewEngineError
	)

Definition at line 896 of file fl_engine_test.cc.

                                          {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_remove_view(), g_autoptr(), kInvalidArguments, MOCK_ENGINE_PROC, remove_view_engine_error_cb(), and FlutterEngineProcTable::RemoveView.

◆ TEST() [20/28]

TEST	(	FlEngineTest	,
		RemoveViewError
	)

Definition at line 862 of file fl_engine_test.cc.

                                    {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_remove_view(), g_autoptr(), 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() [21/28]

TEST	(	FlEngineTest	,
		SendKeyEvent
	)

Definition at line 914 of file fl_engine_test.cc.

                                 {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
 
  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_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_send_key_event(), fl_engine_send_key_event_finish(), fl_engine_start(), 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() [22/28]

TEST	(	FlEngineTest	,
		SendKeyEventError
	)

Definition at line 1010 of file fl_engine_test.cc.

                                      {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  g_autoptr(GError) error = nullptr;
  // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.Assign)
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
 
  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_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_send_key_event(), fl_engine_send_key_event_finish(), fl_engine_start(), g_autoptr(), kFlutterKeyEventDeviceTypeKeyboard, kFlutterKeyEventTypeUp, kInvalidArguments, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendKeyEvent, FlutterKeyEvent::struct_size, type, and user_data.

◆ TEST() [23/28]

TEST	(	FlEngineTest	,
		SendKeyEventNotHandled
	)

Definition at line 965 of file fl_engine_test.cc.

                                           {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
 
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
 
  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_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_send_key_event(), fl_engine_send_key_event_finish(), fl_engine_start(), g_autoptr(), kFlutterKeyEventDeviceTypeKeyboard, kFlutterKeyEventTypeUp, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendKeyEvent, FlutterKeyEvent::struct_size, type, and user_data.

◆ TEST() [24/28]

TEST	(	FlEngineTest	,
		SettingsHandler
	)

Definition at line 287 of file fl_engine_test.cc.

                                    {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  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;
      }));
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
 
  EXPECT_TRUE(called);
}

References data, engine, error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), 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() [25/28]

TEST	(	FlEngineTest	,
		UIIsolateDefaultThreadPolicy
	)

Definition at line 442 of file fl_engine_test.cc.

                                                 {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
  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; }));
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
  EXPECT_TRUE(same_task_runner);
}

References args, engine, error, fl_dart_project_new(), fl_dart_project_set_ui_thread_policy(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), FL_UI_THREAD_POLICY_DEFAULT, FLUTTER_API_SYMBOL, g_autoptr(), FlutterEngineProcTable::Initialize, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::RunInitialized, and user_data.

◆ TEST() [26/28]

TEST	(	FlEngineTest	,
		UIIsolateOnPlatformTaskRunner
	)

Definition at line 467 of file fl_engine_test.cc.

                                                  {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
  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; }));
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
  EXPECT_TRUE(same_task_runner);
}

References args, engine, error, fl_dart_project_new(), fl_dart_project_set_ui_thread_policy(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), FL_UI_THREAD_POLICY_RUN_ON_PLATFORM_THREAD, FLUTTER_API_SYMBOL, g_autoptr(), FlutterEngineProcTable::Initialize, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::RunInitialized, and user_data.

◆ TEST() [27/28]

TEST	(	FlEngineTest	,
		UIIsolateOnSeparateThread
	)

Definition at line 493 of file fl_engine_test.cc.

                                              {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
  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; }));
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
  EXPECT_TRUE(separate_thread);
}

References args, engine, error, fl_dart_project_new(), fl_dart_project_set_ui_thread_policy(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), FL_UI_THREAD_POLICY_RUN_ON_SEPARATE_THREAD, FLUTTER_API_SYMBOL, g_autoptr(), FlutterEngineProcTable::Initialize, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::RunInitialized, and user_data.

◆ TEST() [28/28]

TEST	(	FlEngineTest	,
		WindowMetrics
	)

Definition at line 76 of file fl_engine_test.cc.

                                  {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
 
  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);
 
  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, static_cast<size_t>(3840));
        EXPECT_EQ(event->height, static_cast<size_t>(2160));
        EXPECT_EQ(event->pixel_ratio, 2.0);
 
        return kSuccess;
      }));
 
  fl_engine_send_window_metrics_event(engine, 99, 1, 3840, 2160, 2.0);
 
  EXPECT_TRUE(called);
}

References FlutterWindowMetricsEvent::display_id, engine, error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_send_window_metrics_event(), fl_engine_start(), g_autoptr(), FlutterWindowMetricsEvent::height, kSuccess, MOCK_ENGINE_PROC, FlutterWindowMetricsEvent::pixel_ratio, FlutterEngineProcTable::SendWindowMetricsEvent, FlutterWindowMetricsEvent::view_id, and FlutterWindowMetricsEvent::width.

Functions

Function Documentation

◆ add_view_cb()

◆ add_view_engine_error_cb()

◆ add_view_error_cb()

◆ on_pre_engine_restart_cb()

◆ remove_view_cb()

◆ remove_view_engine_error_cb()

◆ remove_view_error_cb()

◆ TEST() [1/28]

◆ TEST() [2/28]

◆ TEST() [3/28]

◆ TEST() [4/28]

◆ TEST() [5/28]

◆ TEST() [6/28]

◆ TEST() [7/28]

◆ TEST() [8/28]

◆ TEST() [9/28]

◆ TEST() [10/28]

◆ TEST() [11/28]

◆ TEST() [12/28]

◆ TEST() [13/28]

◆ TEST() [14/28]

◆ TEST() [15/28]

◆ TEST() [16/28]

◆ TEST() [17/28]

◆ TEST() [18/28]

◆ TEST() [19/28]

◆ TEST() [20/28]

◆ TEST() [21/28]

◆ TEST() [22/28]

◆ TEST() [23/28]

◆ TEST() [24/28]

◆ TEST() [25/28]

◆ TEST() [26/28]

◆ TEST() [27/28]

◆ TEST() [28/28]