Flutter Linux Embedder
Functions
fl_engine_test.cc File Reference
#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"

Go to the source code of this file.

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

623  {
624  g_autoptr(GError) error = nullptr;
625  gboolean r = fl_engine_add_view_finish(FL_ENGINE(object), result, &error);
626  EXPECT_TRUE(r);
627  EXPECT_EQ(error, nullptr);
628 
629  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
630 }

References error, fl_engine_add_view_finish(), 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 700 of file fl_engine_test.cc.

702  {
703  g_autoptr(GError) error = nullptr;
704  gboolean r = fl_engine_add_view_finish(FL_ENGINE(object), result, &error);
705  EXPECT_FALSE(r);
706  EXPECT_NE(error, nullptr);
707 
708  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
709 }

References error, fl_engine_add_view_finish(), 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 664 of file fl_engine_test.cc.

666  {
667  g_autoptr(GError) error = nullptr;
668  gboolean r = fl_engine_add_view_finish(FL_ENGINE(object), result, &error);
669  EXPECT_FALSE(r);
670  EXPECT_NE(error, nullptr);
671 
672  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
673 }

References error, fl_engine_add_view_finish(), 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.

334  {
335  int* count = reinterpret_cast<int*>(user_data);
336  *count += 1;
337 }

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

732  {
733  g_autoptr(GError) error = nullptr;
734  gboolean r = fl_engine_remove_view_finish(FL_ENGINE(object), result, &error);
735  EXPECT_TRUE(r);
736  EXPECT_EQ(error, nullptr);
737 
738  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
739 }

References error, fl_engine_remove_view_finish(), 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 803 of file fl_engine_test.cc.

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

References error, fl_engine_remove_view_finish(), 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 769 of file fl_engine_test.cc.

771  {
772  g_autoptr(GError) error = nullptr;
773  gboolean r = fl_engine_remove_view_finish(FL_ENGINE(object), result, &error);
774  EXPECT_FALSE(r);
775  EXPECT_NE(error, nullptr);
776 
777  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
778 }

References error, fl_engine_remove_view_finish(), and user_data.

Referenced by TEST().

◆ TEST() [1/25]

TEST ( FlEngineTest  ,
AddView   
)

Definition at line 632 of file fl_engine_test.cc.

632  {
633  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
634 
635  g_autoptr(FlDartProject) project = fl_dart_project_new();
636  g_autoptr(FlEngine) engine = fl_engine_new(project);
637 
638  bool called = false;
639  fl_engine_get_embedder_api(engine)->AddView = MOCK_ENGINE_PROC(
640  AddView, ([&called](auto engine, const FlutterAddViewInfo* info) {
641  called = true;
642  EXPECT_EQ(info->view_metrics->width, 123u);
643  EXPECT_EQ(info->view_metrics->height, 456u);
644  EXPECT_EQ(info->view_metrics->pixel_ratio, 2.0);
645 
646  FlutterAddViewResult result;
647  result.struct_size = sizeof(FlutterAddViewResult);
648  result.added = true;
649  result.user_data = info->user_data;
650  info->add_view_callback(&result);
651 
652  return kSuccess;
653  }));
654 
655  FlutterViewId view_id =
656  fl_engine_add_view(engine, 123, 456, 2.0, nullptr, add_view_cb, loop);
657  EXPECT_GT(view_id, 0);
658  EXPECT_TRUE(called);
659 
660  // Blocks here until add_view_cb is called.
661  g_main_loop_run(loop);
662 }

References add_view_cb(), fl_dart_project_new(), fl_engine_add_view(), fl_engine_get_embedder_api(), and fl_engine_new().

◆ TEST() [2/25]

TEST ( FlEngineTest  ,
AddViewEngineError   
)

Definition at line 711 of file fl_engine_test.cc.

711  {
712  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
713 
714  g_autoptr(FlDartProject) project = fl_dart_project_new();
715  g_autoptr(FlEngine) engine = fl_engine_new(project);
716 
717  fl_engine_get_embedder_api(engine)->AddView = MOCK_ENGINE_PROC(
718  AddView, ([](auto engine, const FlutterAddViewInfo* info) {
719  return kInvalidArguments;
720  }));
721 
722  FlutterViewId view_id = fl_engine_add_view(engine, 123, 456, 2.0, nullptr,
723  add_view_engine_error_cb, loop);
724  EXPECT_GT(view_id, 0);
725 
726  // Blocks here until remove_view_engine_error_cb is called.
727  g_main_loop_run(loop);
728 }

References add_view_engine_error_cb(), fl_dart_project_new(), fl_engine_add_view(), fl_engine_get_embedder_api(), and fl_engine_new().

◆ TEST() [3/25]

TEST ( FlEngineTest  ,
AddViewError   
)

Definition at line 675 of file fl_engine_test.cc.

675  {
676  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
677 
678  g_autoptr(FlDartProject) project = fl_dart_project_new();
679  g_autoptr(FlEngine) engine = fl_engine_new(project);
680 
681  fl_engine_get_embedder_api(engine)->AddView = MOCK_ENGINE_PROC(
682  AddView, ([](auto engine, const FlutterAddViewInfo* info) {
683  FlutterAddViewResult result;
684  result.struct_size = sizeof(FlutterAddViewResult);
685  result.added = false;
686  result.user_data = info->user_data;
687  info->add_view_callback(&result);
688 
689  return kSuccess;
690  }));
691 
692  FlutterViewId view_id = fl_engine_add_view(engine, 123, 456, 2.0, nullptr,
693  add_view_error_cb, loop);
694  EXPECT_GT(view_id, 0);
695 
696  // Blocks here until add_view_error_cb is called.
697  g_main_loop_run(loop);
698 }

References add_view_error_cb(), fl_dart_project_new(), fl_engine_add_view(), fl_engine_get_embedder_api(), and fl_engine_new().

◆ TEST() [4/25]

TEST ( FlEngineTest  ,
ChildObjects   
)

Definition at line 972 of file fl_engine_test.cc.

972  {
973  g_autoptr(FlDartProject) project = fl_dart_project_new();
974  g_autoptr(FlEngine) engine = fl_engine_new(project);
975 
976  // Check objects exist before engine started.
977  EXPECT_NE(fl_engine_get_binary_messenger(engine), nullptr);
978  EXPECT_NE(fl_engine_get_renderer(engine), nullptr);
979  EXPECT_NE(fl_engine_get_display_monitor(engine), nullptr);
980  EXPECT_NE(fl_engine_get_task_runner(engine), nullptr);
981  EXPECT_NE(fl_engine_get_keyboard_manager(engine), nullptr);
982  EXPECT_NE(fl_engine_get_mouse_cursor_handler(engine), nullptr);
983  EXPECT_NE(fl_engine_get_windowing_handler(engine), nullptr);
984 }

References 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_renderer(), fl_engine_get_task_runner(), fl_engine_get_windowing_handler(), and fl_engine_new().

◆ TEST() [5/25]

TEST ( FlEngineTest  ,
CLocale   
)

Definition at line 493 of file fl_engine_test.cc.

493  {
494  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
495  g_setenv("LANGUAGE", "C", TRUE);
496  g_autoptr(FlDartProject) project = fl_dart_project_new();
497 
498  g_autoptr(FlEngine) engine = fl_engine_new(project);
499 
500  bool called = false;
501  fl_engine_get_embedder_api(engine)->UpdateLocales = MOCK_ENGINE_PROC(
502  UpdateLocales, ([&called](auto engine, const FlutterLocale** locales,
503  size_t locales_count) {
504  called = true;
505 
506  EXPECT_EQ(locales_count, static_cast<size_t>(1));
507 
508  EXPECT_STREQ(locales[0]->language_code, "C");
509  EXPECT_STREQ(locales[0]->country_code, nullptr);
510  EXPECT_STREQ(locales[0]->script_code, nullptr);
511  EXPECT_STREQ(locales[0]->variant_code, nullptr);
512 
513  return kSuccess;
514  }));
515 
516  g_autoptr(GError) error = nullptr;
517  EXPECT_TRUE(fl_engine_start(engine, &error));
518  EXPECT_EQ(error, nullptr);
519 
520  EXPECT_TRUE(called);
521 
522  if (initial_language) {
523  g_setenv("LANGUAGE", initial_language, TRUE);
524  } else {
525  g_unsetenv("LANGUAGE");
526  }
527 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), and TRUE.

◆ TEST() [6/25]

TEST ( FlEngineTest  ,
DartEntrypointArgs   
)

Definition at line 385 of file fl_engine_test.cc.

385  {
386  GPtrArray* args_array = g_ptr_array_new();
387  g_ptr_array_add(args_array, const_cast<char*>("arg_one"));
388  g_ptr_array_add(args_array, const_cast<char*>("arg_two"));
389  g_ptr_array_add(args_array, const_cast<char*>("arg_three"));
390  g_ptr_array_add(args_array, nullptr);
391  gchar** args = reinterpret_cast<gchar**>(g_ptr_array_free(args_array, false));
392 
393  g_autoptr(FlDartProject) project = fl_dart_project_new();
394  fl_dart_project_set_dart_entrypoint_arguments(project, args);
395  g_autoptr(FlEngine) engine = fl_engine_new(project);
396 
397  bool called = false;
398  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
399  Initialize, ([&called, &set_args = args](
400  size_t version, const FlutterRendererConfig* config,
401  const FlutterProjectArgs* args, void* user_data,
402  FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
403  called = true;
404  EXPECT_NE(set_args, args->dart_entrypoint_argv);
405  EXPECT_EQ(args->dart_entrypoint_argc, 3);
406 
407  return kSuccess;
408  }));
409  fl_engine_get_embedder_api(engine)->RunInitialized =
410  MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
411 
412  g_autoptr(GError) error = nullptr;
413  EXPECT_TRUE(fl_engine_start(engine, &error));
414  EXPECT_EQ(error, nullptr);
415 
416  EXPECT_TRUE(called);
417 }

References args, error, fl_dart_project_new(), fl_dart_project_set_dart_entrypoint_arguments(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), and user_data.

◆ TEST() [7/25]

TEST ( FlEngineTest  ,
DispatchSemanticsAction   
)

Definition at line 178 of file fl_engine_test.cc.

178  {
179  g_autoptr(FlDartProject) project = fl_dart_project_new();
180  g_autoptr(FlEngine) engine = fl_engine_new(project);
181 
182  bool called = false;
183  fl_engine_get_embedder_api(engine)->DispatchSemanticsAction =
184  MOCK_ENGINE_PROC(
185  DispatchSemanticsAction,
186  ([&called](auto engine, uint64_t id, FlutterSemanticsAction action,
187  const uint8_t* data, size_t data_length) {
188  EXPECT_EQ(id, static_cast<uint64_t>(42));
189  EXPECT_EQ(action, kFlutterSemanticsActionTap);
190  EXPECT_EQ(data_length, static_cast<size_t>(4));
191  EXPECT_EQ(data[0], 't');
192  EXPECT_EQ(data[1], 'e');
193  EXPECT_EQ(data[2], 's');
194  EXPECT_EQ(data[3], 't');
195  called = true;
196 
197  return kSuccess;
198  }));
199 
200  g_autoptr(GError) error = nullptr;
201  EXPECT_TRUE(fl_engine_start(engine, &error));
202  EXPECT_EQ(error, nullptr);
203  g_autoptr(GBytes) data = g_bytes_new_static("test", 4);
204  fl_engine_dispatch_semantics_action(engine, 42, kFlutterSemanticsActionTap,
205  data);
206 
207  EXPECT_TRUE(called);
208 }

References error, fl_dart_project_new(), fl_engine_dispatch_semantics_action(), fl_engine_get_embedder_api(), fl_engine_new(), and fl_engine_start().

◆ TEST() [8/25]

TEST ( FlEngineTest  ,
DuplicateLocale   
)

Definition at line 529 of file fl_engine_test.cc.

529  {
530  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
531  g_setenv("LANGUAGE", "en:en", TRUE);
532  g_autoptr(FlDartProject) project = fl_dart_project_new();
533 
534  g_autoptr(FlEngine) engine = fl_engine_new(project);
535 
536  bool called = false;
537  fl_engine_get_embedder_api(engine)->UpdateLocales = MOCK_ENGINE_PROC(
538  UpdateLocales, ([&called](auto engine, const FlutterLocale** locales,
539  size_t locales_count) {
540  called = true;
541 
542  EXPECT_EQ(locales_count, static_cast<size_t>(2));
543 
544  EXPECT_STREQ(locales[0]->language_code, "en");
545  EXPECT_STREQ(locales[0]->country_code, nullptr);
546  EXPECT_STREQ(locales[0]->script_code, nullptr);
547  EXPECT_STREQ(locales[0]->variant_code, nullptr);
548 
549  EXPECT_STREQ(locales[1]->language_code, "C");
550  EXPECT_STREQ(locales[1]->country_code, nullptr);
551  EXPECT_STREQ(locales[1]->script_code, nullptr);
552  EXPECT_STREQ(locales[1]->variant_code, nullptr);
553 
554  return kSuccess;
555  }));
556 
557  g_autoptr(GError) error = nullptr;
558  EXPECT_TRUE(fl_engine_start(engine, &error));
559  EXPECT_EQ(error, nullptr);
560 
561  EXPECT_TRUE(called);
562 
563  if (initial_language) {
564  g_setenv("LANGUAGE", initial_language, TRUE);
565  } else {
566  g_unsetenv("LANGUAGE");
567  }
568 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), and TRUE.

◆ TEST() [9/25]

TEST ( FlEngineTest  ,
EmptyLocales   
)

Definition at line 570 of file fl_engine_test.cc.

570  {
571  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
572  g_setenv("LANGUAGE", "de:: :en_US", TRUE);
573  g_autoptr(FlDartProject) project = fl_dart_project_new();
574 
575  g_autoptr(FlEngine) engine = fl_engine_new(project);
576 
577  bool called = false;
578  fl_engine_get_embedder_api(engine)->UpdateLocales = MOCK_ENGINE_PROC(
579  UpdateLocales, ([&called](auto engine, const FlutterLocale** locales,
580  size_t locales_count) {
581  called = true;
582 
583  EXPECT_EQ(locales_count, static_cast<size_t>(4));
584 
585  EXPECT_STREQ(locales[0]->language_code, "de");
586  EXPECT_STREQ(locales[0]->country_code, nullptr);
587  EXPECT_STREQ(locales[0]->script_code, nullptr);
588  EXPECT_STREQ(locales[0]->variant_code, nullptr);
589 
590  EXPECT_STREQ(locales[1]->language_code, "en");
591  EXPECT_STREQ(locales[1]->country_code, "US");
592  EXPECT_STREQ(locales[1]->script_code, nullptr);
593  EXPECT_STREQ(locales[1]->variant_code, nullptr);
594 
595  EXPECT_STREQ(locales[2]->language_code, "en");
596  EXPECT_STREQ(locales[2]->country_code, nullptr);
597  EXPECT_STREQ(locales[2]->script_code, nullptr);
598  EXPECT_STREQ(locales[2]->variant_code, nullptr);
599 
600  EXPECT_STREQ(locales[3]->language_code, "C");
601  EXPECT_STREQ(locales[3]->country_code, nullptr);
602  EXPECT_STREQ(locales[3]->script_code, nullptr);
603  EXPECT_STREQ(locales[3]->variant_code, nullptr);
604 
605  return kSuccess;
606  }));
607 
608  g_autoptr(GError) error = nullptr;
609  EXPECT_TRUE(fl_engine_start(engine, &error));
610  EXPECT_EQ(error, nullptr);
611 
612  EXPECT_TRUE(called);
613 
614  if (initial_language) {
615  g_setenv("LANGUAGE", initial_language, TRUE);
616  } else {
617  g_unsetenv("LANGUAGE");
618  }
619 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), and TRUE.

◆ TEST() [10/25]

TEST ( FlEngineTest  ,
EngineId   
)

Definition at line 419 of file fl_engine_test.cc.

419  {
420  g_autoptr(FlDartProject) project = fl_dart_project_new();
421  g_autoptr(FlEngine) engine = fl_engine_new(project);
422  int64_t engine_id;
423  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
424  Initialize,
425  ([&engine_id](size_t version, const FlutterRendererConfig* config,
426  const FlutterProjectArgs* args, void* user_data,
427  FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
428  engine_id = args->engine_id;
429  return kSuccess;
430  }));
431  fl_engine_get_embedder_api(engine)->RunInitialized =
432  MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
433 
434  g_autoptr(GError) error = nullptr;
435  EXPECT_TRUE(fl_engine_start(engine, &error));
436  EXPECT_EQ(error, nullptr);
437  EXPECT_TRUE(engine_id != 0);
438 
439  EXPECT_EQ(fl_engine_for_id(engine_id), engine);
440 }

References args, error, fl_dart_project_new(), fl_engine_for_id(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), and user_data.

◆ TEST() [11/25]

TEST ( FlEngineTest  ,
Locales   
)

Definition at line 442 of file fl_engine_test.cc.

442  {
443  g_autofree gchar* initial_language = g_strdup(g_getenv("LANGUAGE"));
444  g_setenv("LANGUAGE", "de:en_US", TRUE);
445  g_autoptr(FlDartProject) project = fl_dart_project_new();
446 
447  g_autoptr(FlEngine) engine = fl_engine_new(project);
448 
449  bool called = false;
450  fl_engine_get_embedder_api(engine)->UpdateLocales = MOCK_ENGINE_PROC(
451  UpdateLocales, ([&called](auto engine, const FlutterLocale** locales,
452  size_t locales_count) {
453  called = true;
454 
455  EXPECT_EQ(locales_count, static_cast<size_t>(4));
456 
457  EXPECT_STREQ(locales[0]->language_code, "de");
458  EXPECT_STREQ(locales[0]->country_code, nullptr);
459  EXPECT_STREQ(locales[0]->script_code, nullptr);
460  EXPECT_STREQ(locales[0]->variant_code, nullptr);
461 
462  EXPECT_STREQ(locales[1]->language_code, "en");
463  EXPECT_STREQ(locales[1]->country_code, "US");
464  EXPECT_STREQ(locales[1]->script_code, nullptr);
465  EXPECT_STREQ(locales[1]->variant_code, nullptr);
466 
467  EXPECT_STREQ(locales[2]->language_code, "en");
468  EXPECT_STREQ(locales[2]->country_code, nullptr);
469  EXPECT_STREQ(locales[2]->script_code, nullptr);
470  EXPECT_STREQ(locales[2]->variant_code, nullptr);
471 
472  EXPECT_STREQ(locales[3]->language_code, "C");
473  EXPECT_STREQ(locales[3]->country_code, nullptr);
474  EXPECT_STREQ(locales[3]->script_code, nullptr);
475  EXPECT_STREQ(locales[3]->variant_code, nullptr);
476 
477  return kSuccess;
478  }));
479 
480  g_autoptr(GError) error = nullptr;
481  EXPECT_TRUE(fl_engine_start(engine, &error));
482  EXPECT_EQ(error, nullptr);
483 
484  EXPECT_TRUE(called);
485 
486  if (initial_language) {
487  g_setenv("LANGUAGE", initial_language, TRUE);
488  } else {
489  g_unsetenv("LANGUAGE");
490  }
491 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), and TRUE.

◆ TEST() [12/25]

TEST ( FlEngineTest  ,
MousePointer   
)

Definition at line 103 of file fl_engine_test.cc.

103  {
104  g_autoptr(FlDartProject) project = fl_dart_project_new();
105  g_autoptr(FlEngine) engine = fl_engine_new(project);
106 
107  bool called = false;
108  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
109  SendPointerEvent,
110  ([&called](auto engine, const FlutterPointerEvent* events,
111  size_t events_count) {
112  called = true;
113  EXPECT_EQ(events_count, static_cast<size_t>(1));
114  EXPECT_EQ(events[0].view_id, 1);
115  EXPECT_EQ(events[0].phase, kDown);
116  EXPECT_EQ(events[0].timestamp, static_cast<size_t>(1234567890));
117  EXPECT_EQ(events[0].x, 800);
118  EXPECT_EQ(events[0].y, 600);
119  EXPECT_EQ(events[0].device, static_cast<int32_t>(0));
120  EXPECT_EQ(events[0].signal_kind, kFlutterPointerSignalKindScroll);
121  EXPECT_EQ(events[0].scroll_delta_x, 1.2);
122  EXPECT_EQ(events[0].scroll_delta_y, -3.4);
123  EXPECT_EQ(events[0].device_kind, kFlutterPointerDeviceKindMouse);
124  EXPECT_EQ(events[0].buttons, kFlutterPointerButtonMouseSecondary);
125 
126  return kSuccess;
127  }));
128 
129  g_autoptr(GError) error = nullptr;
130  EXPECT_TRUE(fl_engine_start(engine, &error));
131  EXPECT_EQ(error, nullptr);
132  fl_engine_send_mouse_pointer_event(engine, 1, kDown, 1234567890, 800, 600,
133  kFlutterPointerDeviceKindMouse, 1.2, -3.4,
134  kFlutterPointerButtonMouseSecondary);
135 
136  EXPECT_TRUE(called);
137 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_send_mouse_pointer_event(), and fl_engine_start().

◆ TEST() [13/25]

TEST ( FlEngineTest  ,
NotifyDisplayUpdate   
)

Definition at line 18 of file fl_engine_test.cc.

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

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_notify_display_update(), fl_engine_start(), height, and width.

◆ TEST() [14/25]

TEST ( FlEngineTest  ,
OnPreEngineRestart   
)

Definition at line 340 of file fl_engine_test.cc.

340  {
341  g_autoptr(FlDartProject) project = fl_dart_project_new();
342  g_autoptr(FlEngine) engine = fl_engine_new(project);
343 
344  OnPreEngineRestartCallback callback;
345  void* callback_user_data;
346 
347  bool called = false;
348  fl_engine_get_embedder_api(engine)->Initialize = MOCK_ENGINE_PROC(
349  Initialize, ([&callback, &callback_user_data, &called](
350  size_t version, const FlutterRendererConfig* config,
351  const FlutterProjectArgs* args, void* user_data,
352  FLUTTER_API_SYMBOL(FlutterEngine) * engine_out) {
353  called = true;
354  callback = args->on_pre_engine_restart_callback;
355  callback_user_data = user_data;
356 
357  return kSuccess;
358  }));
359  fl_engine_get_embedder_api(engine)->RunInitialized =
360  MOCK_ENGINE_PROC(RunInitialized, ([](auto engine) { return kSuccess; }));
361 
362  g_autoptr(GError) error = nullptr;
363  EXPECT_TRUE(fl_engine_start(engine, &error));
364  EXPECT_EQ(error, nullptr);
365 
366  EXPECT_TRUE(called);
367  EXPECT_NE(callback, nullptr);
368 
369  // The following call has no effect but should not crash.
370  callback(callback_user_data);
371 
372  int count = 0;
373 
374  // Set handler so that:
375  //
376  // * When the engine restarts, count += 1;
377  // * When the engine is freed, count += 10.
378  g_signal_connect(engine, "on-pre-engine-restart",
379  G_CALLBACK(on_pre_engine_restart_cb), &count);
380 
381  callback(callback_user_data);
382  EXPECT_EQ(count, 1);
383 }

References args, error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_start(), on_pre_engine_restart_cb(), and user_data.

◆ TEST() [15/25]

TEST ( FlEngineTest  ,
PlatformMessage   
)

Definition at line 211 of file fl_engine_test.cc.

211  {
212  g_autoptr(FlDartProject) project = fl_dart_project_new();
213  g_autoptr(FlEngine) engine = fl_engine_new(project);
214 
215  bool called = false;
216  FlutterEngineSendPlatformMessageFnPtr old_handler =
217  fl_engine_get_embedder_api(engine)->SendPlatformMessage;
218  fl_engine_get_embedder_api(engine)->SendPlatformMessage = MOCK_ENGINE_PROC(
219  SendPlatformMessage,
220  ([&called, old_handler](auto engine,
221  const FlutterPlatformMessage* message) {
222  if (strcmp(message->channel, "test") != 0) {
223  return old_handler(engine, message);
224  }
225 
226  called = true;
227 
228  EXPECT_EQ(message->message_size, static_cast<size_t>(4));
229  EXPECT_EQ(message->message[0], 't');
230  EXPECT_EQ(message->message[1], 'e');
231  EXPECT_EQ(message->message[2], 's');
232  EXPECT_EQ(message->message[3], 't');
233 
234  return kSuccess;
235  }));
236 
237  g_autoptr(GError) error = nullptr;
238  EXPECT_TRUE(fl_engine_start(engine, &error));
239  EXPECT_EQ(error, nullptr);
240  g_autoptr(GBytes) message = g_bytes_new_static("test", 4);
241  fl_engine_send_platform_message(engine, "test", message, nullptr, nullptr,
242  nullptr);
243 
244  EXPECT_TRUE(called);
245 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_send_platform_message(), and fl_engine_start().

◆ TEST() [16/25]

TEST ( FlEngineTest  ,
PlatformMessageResponse   
)

Definition at line 248 of file fl_engine_test.cc.

248  {
249  g_autoptr(FlDartProject) project = fl_dart_project_new();
250  g_autoptr(FlEngine) engine = fl_engine_new(project);
251 
252  bool called = false;
253  fl_engine_get_embedder_api(engine)->SendPlatformMessageResponse =
254  MOCK_ENGINE_PROC(
255  SendPlatformMessageResponse,
256  ([&called](auto engine,
257  const FlutterPlatformMessageResponseHandle* handle,
258  const uint8_t* data, size_t data_length) {
259  called = true;
260 
261  EXPECT_EQ(
262  handle,
263  reinterpret_cast<const FlutterPlatformMessageResponseHandle*>(
264  42));
265  EXPECT_EQ(data_length, static_cast<size_t>(4));
266  EXPECT_EQ(data[0], 't');
267  EXPECT_EQ(data[1], 'e');
268  EXPECT_EQ(data[2], 's');
269  EXPECT_EQ(data[3], 't');
270 
271  return kSuccess;
272  }));
273 
274  g_autoptr(GError) error = nullptr;
275  EXPECT_TRUE(fl_engine_start(engine, &error));
276  EXPECT_EQ(error, nullptr);
277  g_autoptr(GBytes) response = g_bytes_new_static("test", 4);
278  EXPECT_TRUE(fl_engine_send_platform_message_response(
279  engine, reinterpret_cast<const FlutterPlatformMessageResponseHandle*>(42),
280  response, &error));
281  EXPECT_EQ(error, nullptr);
282 
283  EXPECT_TRUE(called);
284 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_send_platform_message_response(), and fl_engine_start().

◆ TEST() [17/25]

TEST ( FlEngineTest  ,
PointerPanZoom   
)

Definition at line 140 of file fl_engine_test.cc.

140  {
141  g_autoptr(FlDartProject) project = fl_dart_project_new();
142  g_autoptr(FlEngine) engine = fl_engine_new(project);
143 
144  bool called = false;
145  fl_engine_get_embedder_api(engine)->SendPointerEvent = MOCK_ENGINE_PROC(
146  SendPointerEvent,
147  ([&called](auto engine, const FlutterPointerEvent* events,
148  size_t events_count) {
149  called = true;
150  EXPECT_EQ(events_count, static_cast<size_t>(1));
151  EXPECT_EQ(events[0].view_id, 1);
152  EXPECT_EQ(events[0].phase, kPanZoomUpdate);
153  EXPECT_EQ(events[0].timestamp, static_cast<size_t>(1234567890));
154  EXPECT_EQ(events[0].x, 800);
155  EXPECT_EQ(events[0].y, 600);
156  EXPECT_EQ(events[0].device, static_cast<int32_t>(1));
157  EXPECT_EQ(events[0].signal_kind, kFlutterPointerSignalKindNone);
158  EXPECT_EQ(events[0].pan_x, 1.5);
159  EXPECT_EQ(events[0].pan_y, 2.5);
160  EXPECT_EQ(events[0].scale, 3.5);
161  EXPECT_EQ(events[0].rotation, 4.5);
162  EXPECT_EQ(events[0].device_kind, kFlutterPointerDeviceKindTrackpad);
163  EXPECT_EQ(events[0].buttons, 0);
164 
165  return kSuccess;
166  }));
167 
168  g_autoptr(GError) error = nullptr;
169  EXPECT_TRUE(fl_engine_start(engine, &error));
170  EXPECT_EQ(error, nullptr);
171  fl_engine_send_pointer_pan_zoom_event(engine, 1, 1234567890, 800, 600,
172  kPanZoomUpdate, 1.5, 2.5, 3.5, 4.5);
173 
174  EXPECT_TRUE(called);
175 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_send_pointer_pan_zoom_event(), and fl_engine_start().

◆ TEST() [18/25]

TEST ( FlEngineTest  ,
RemoveView   
)

Definition at line 741 of file fl_engine_test.cc.

741  {
742  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
743 
744  g_autoptr(FlDartProject) project = fl_dart_project_new();
745  g_autoptr(FlEngine) engine = fl_engine_new(project);
746 
747  bool called = false;
748  fl_engine_get_embedder_api(engine)->RemoveView = MOCK_ENGINE_PROC(
749  RemoveView, ([&called](auto engine, const FlutterRemoveViewInfo* info) {
750  called = true;
751  EXPECT_EQ(info->view_id, 123);
752 
753  FlutterRemoveViewResult result;
754  result.struct_size = sizeof(FlutterRemoveViewResult);
755  result.removed = true;
756  result.user_data = info->user_data;
757  info->remove_view_callback(&result);
758 
759  return kSuccess;
760  }));
761 
762  fl_engine_remove_view(engine, 123, nullptr, remove_view_cb, loop);
763  EXPECT_TRUE(called);
764 
765  // Blocks here until remove_view_cb is called.
766  g_main_loop_run(loop);
767 }

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

◆ TEST() [19/25]

TEST ( FlEngineTest  ,
RemoveViewEngineError   
)

Definition at line 814 of file fl_engine_test.cc.

814  {
815  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
816 
817  g_autoptr(FlDartProject) project = fl_dart_project_new();
818  g_autoptr(FlEngine) engine = fl_engine_new(project);
819 
820  fl_engine_get_embedder_api(engine)->RemoveView = MOCK_ENGINE_PROC(
821  RemoveView, ([](auto engine, const FlutterRemoveViewInfo* info) {
822  return kInvalidArguments;
823  }));
824 
825  fl_engine_remove_view(engine, 123, nullptr, remove_view_engine_error_cb,
826  loop);
827 
828  // Blocks here until remove_view_engine_error_cb is called.
829  g_main_loop_run(loop);
830 }

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

◆ TEST() [20/25]

TEST ( FlEngineTest  ,
RemoveViewError   
)

Definition at line 780 of file fl_engine_test.cc.

780  {
781  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
782 
783  g_autoptr(FlDartProject) project = fl_dart_project_new();
784  g_autoptr(FlEngine) engine = fl_engine_new(project);
785 
786  fl_engine_get_embedder_api(engine)->RemoveView = MOCK_ENGINE_PROC(
787  RemoveView, ([](auto engine, const FlutterRemoveViewInfo* info) {
788  FlutterRemoveViewResult result;
789  result.struct_size = sizeof(FlutterRemoveViewResult);
790  result.removed = false;
791  result.user_data = info->user_data;
792  info->remove_view_callback(&result);
793 
794  return kSuccess;
795  }));
796 
797  fl_engine_remove_view(engine, 123, nullptr, remove_view_error_cb, loop);
798 
799  // Blocks here until remove_view_error_cb is called.
800  g_main_loop_run(loop);
801 }

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

◆ TEST() [21/25]

TEST ( FlEngineTest  ,
SendKeyEvent   
)

Definition at line 832 of file fl_engine_test.cc.

832  {
833  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
834 
835  g_autoptr(FlDartProject) project = fl_dart_project_new();
836  g_autoptr(FlEngine) engine = fl_engine_new(project);
837 
838  g_autoptr(GError) error = nullptr;
839  EXPECT_TRUE(fl_engine_start(engine, &error));
840  EXPECT_EQ(error, nullptr);
841 
842  bool called;
843  fl_engine_get_embedder_api(engine)->SendKeyEvent = MOCK_ENGINE_PROC(
844  SendKeyEvent,
845  ([&called](auto engine, const FlutterKeyEvent* event,
846  FlutterKeyEventCallback callback, void* user_data) {
847  called = true;
848  EXPECT_EQ(event->timestamp, 1234);
849  EXPECT_EQ(event->type, kFlutterKeyEventTypeUp);
850  EXPECT_EQ(event->physical, static_cast<uint64_t>(42));
851  EXPECT_EQ(event->logical, static_cast<uint64_t>(123));
852  EXPECT_TRUE(event->synthesized);
853  EXPECT_EQ(event->device_type, kFlutterKeyEventDeviceTypeKeyboard);
854  callback(TRUE, user_data);
855  return kSuccess;
856  }));
857 
858  FlutterKeyEvent event = {.struct_size = sizeof(FlutterKeyEvent),
859  .timestamp = 1234,
860  .type = kFlutterKeyEventTypeUp,
861  .physical = 42,
862  .logical = 123,
863  .character = nullptr,
864  .synthesized = true,
865  .device_type = kFlutterKeyEventDeviceTypeKeyboard};
866  fl_engine_send_key_event(
867  engine, &event, nullptr,
868  [](GObject* object, GAsyncResult* result, gpointer user_data) {
869  gboolean handled;
870  g_autoptr(GError) error = nullptr;
871  EXPECT_TRUE(fl_engine_send_key_event_finish(FL_ENGINE(object), result,
872  &handled, &error));
873  EXPECT_EQ(error, nullptr);
874  EXPECT_TRUE(handled);
875  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
876  },
877  loop);
878 
879  g_main_loop_run(loop);
880  EXPECT_TRUE(called);
881 }

References 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(), TRUE, type, and user_data.

◆ TEST() [22/25]

TEST ( FlEngineTest  ,
SendKeyEventError   
)

Definition at line 928 of file fl_engine_test.cc.

928  {
929  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
930 
931  g_autoptr(FlDartProject) project = fl_dart_project_new();
932  g_autoptr(FlEngine) engine = fl_engine_new(project);
933 
934  g_autoptr(GError) error = nullptr;
935  EXPECT_TRUE(fl_engine_start(engine, &error));
936  EXPECT_EQ(error, nullptr);
937 
938  bool called;
939  fl_engine_get_embedder_api(engine)->SendKeyEvent = MOCK_ENGINE_PROC(
940  SendKeyEvent,
941  ([&called](auto engine, const FlutterKeyEvent* event,
942  FlutterKeyEventCallback callback, void* user_data) {
943  called = true;
944  return kInvalidArguments;
945  }));
946 
947  FlutterKeyEvent event = {.struct_size = sizeof(FlutterKeyEvent),
948  .timestamp = 1234,
949  .type = kFlutterKeyEventTypeUp,
950  .physical = 42,
951  .logical = 123,
952  .character = nullptr,
953  .synthesized = true,
954  .device_type = kFlutterKeyEventDeviceTypeKeyboard};
955  fl_engine_send_key_event(
956  engine, &event, nullptr,
957  [](GObject* object, GAsyncResult* result, gpointer user_data) {
958  gboolean handled;
959  g_autoptr(GError) error = nullptr;
960  EXPECT_FALSE(fl_engine_send_key_event_finish(FL_ENGINE(object), result,
961  &handled, &error));
962  EXPECT_NE(error, nullptr);
963  EXPECT_STREQ(error->message, "Failed to send key event");
964  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
965  },
966  loop);
967 
968  g_main_loop_run(loop);
969  EXPECT_TRUE(called);
970 }

References 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(), type, and user_data.

◆ TEST() [23/25]

TEST ( FlEngineTest  ,
SendKeyEventNotHandled   
)

Definition at line 883 of file fl_engine_test.cc.

883  {
884  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);
885 
886  g_autoptr(FlDartProject) project = fl_dart_project_new();
887  g_autoptr(FlEngine) engine = fl_engine_new(project);
888 
889  g_autoptr(GError) error = nullptr;
890  EXPECT_TRUE(fl_engine_start(engine, &error));
891  EXPECT_EQ(error, nullptr);
892 
893  bool called;
894  fl_engine_get_embedder_api(engine)->SendKeyEvent = MOCK_ENGINE_PROC(
895  SendKeyEvent,
896  ([&called](auto engine, const FlutterKeyEvent* event,
897  FlutterKeyEventCallback callback, void* user_data) {
898  called = true;
899  callback(FALSE, user_data);
900  return kSuccess;
901  }));
902 
903  FlutterKeyEvent event = {.struct_size = sizeof(FlutterKeyEvent),
904  .timestamp = 1234,
905  .type = kFlutterKeyEventTypeUp,
906  .physical = 42,
907  .logical = 123,
908  .character = nullptr,
909  .synthesized = true,
910  .device_type = kFlutterKeyEventDeviceTypeKeyboard};
911  fl_engine_send_key_event(
912  engine, &event, nullptr,
913  [](GObject* object, GAsyncResult* result, gpointer user_data) {
914  gboolean handled;
915  g_autoptr(GError) error = nullptr;
916  EXPECT_TRUE(fl_engine_send_key_event_finish(FL_ENGINE(object), result,
917  &handled, &error));
918  EXPECT_EQ(error, nullptr);
919  EXPECT_FALSE(handled);
920  g_main_loop_quit(static_cast<GMainLoop*>(user_data));
921  },
922  loop);
923 
924  g_main_loop_run(loop);
925  EXPECT_TRUE(called);
926 }

References 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(), type, and user_data.

◆ TEST() [24/25]

TEST ( FlEngineTest  ,
SettingsHandler   
)

Definition at line 287 of file fl_engine_test.cc.

287  {
288  g_autoptr(FlDartProject) project = fl_dart_project_new();
289  g_autoptr(FlEngine) engine = fl_engine_new(project);
290 
291  bool called = false;
292  fl_engine_get_embedder_api(engine)->SendPlatformMessage = MOCK_ENGINE_PROC(
293  SendPlatformMessage,
294  ([&called](auto engine, const FlutterPlatformMessage* message) {
295  called = true;
296 
297  EXPECT_STREQ(message->channel, "flutter/settings");
298 
299  g_autoptr(FlJsonMessageCodec) codec = fl_json_message_codec_new();
300  g_autoptr(GBytes) data =
301  g_bytes_new(message->message, message->message_size);
302  g_autoptr(GError) error = nullptr;
303  g_autoptr(FlValue) settings = fl_message_codec_decode_message(
304  FL_MESSAGE_CODEC(codec), data, &error);
305  EXPECT_NE(settings, nullptr);
306  EXPECT_EQ(error, nullptr);
307 
308  FlValue* text_scale_factor =
309  fl_value_lookup_string(settings, "textScaleFactor");
310  EXPECT_NE(text_scale_factor, nullptr);
311  EXPECT_EQ(fl_value_get_type(text_scale_factor), FL_VALUE_TYPE_FLOAT);
312 
313  FlValue* always_use_24hr_format =
314  fl_value_lookup_string(settings, "alwaysUse24HourFormat");
315  EXPECT_NE(always_use_24hr_format, nullptr);
316  EXPECT_EQ(fl_value_get_type(always_use_24hr_format),
317  FL_VALUE_TYPE_BOOL);
318 
319  FlValue* platform_brightness =
320  fl_value_lookup_string(settings, "platformBrightness");
321  EXPECT_NE(platform_brightness, nullptr);
322  EXPECT_EQ(fl_value_get_type(platform_brightness), FL_VALUE_TYPE_STRING);
323 
324  return kSuccess;
325  }));
326 
327  g_autoptr(GError) error = nullptr;
328  EXPECT_TRUE(fl_engine_start(engine, &error));
329  EXPECT_EQ(error, nullptr);
330 
331  EXPECT_TRUE(called);
332 }

References 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, and FL_VALUE_TYPE_STRING.

◆ TEST() [25/25]

TEST ( FlEngineTest  ,
WindowMetrics   
)

Definition at line 75 of file fl_engine_test.cc.

75  {
76  g_autoptr(FlDartProject) project = fl_dart_project_new();
77  g_autoptr(FlEngine) engine = fl_engine_new(project);
78 
79  g_autoptr(GError) error = nullptr;
80  EXPECT_TRUE(fl_engine_start(engine, &error));
81  EXPECT_EQ(error, nullptr);
82 
83  bool called = false;
84  fl_engine_get_embedder_api(engine)->SendWindowMetricsEvent = MOCK_ENGINE_PROC(
85  SendWindowMetricsEvent,
86  ([&called](auto engine, const FlutterWindowMetricsEvent* event) {
87  called = true;
88  EXPECT_EQ(event->display_id, 99u);
89  EXPECT_EQ(event->view_id, 1);
90  EXPECT_EQ(event->width, static_cast<size_t>(3840));
91  EXPECT_EQ(event->height, static_cast<size_t>(2160));
92  EXPECT_EQ(event->pixel_ratio, 2.0);
93 
94  return kSuccess;
95  }));
96 
97  fl_engine_send_window_metrics_event(engine, 99, 1, 3840, 2160, 2.0);
98 
99  EXPECT_TRUE(called);
100 }

References error, fl_dart_project_new(), fl_engine_get_embedder_api(), fl_engine_new(), fl_engine_send_window_metrics_event(), and fl_engine_start().

fl_engine_get_embedder_api
FlutterEngineProcTable * fl_engine_get_embedder_api(FlEngine *self)
Definition: fl_engine.cc:721
type
uint8_t type
Definition: fl_standard_message_codec_test.cc:1115
fl_engine_send_key_event_finish
gboolean fl_engine_send_key_event_finish(FlEngine *self, GAsyncResult *result, gboolean *handled, GError **error)
Definition: fl_engine.cc:1187
fl_engine_get_keyboard_manager
FlKeyboardManager * fl_engine_get_keyboard_manager(FlEngine *self)
Definition: fl_engine.cc:1289
add_view_engine_error_cb
static void add_view_engine_error_cb(GObject *object, GAsyncResult *result, gpointer user_data)
Definition: fl_engine_test.cc:700
fl_engine_get_renderer
FlRenderer * fl_engine_get_renderer(FlEngine *self)
Definition: fl_engine.cc:597
FlValue
typedefG_BEGIN_DECLS struct _FlValue FlValue
Definition: fl_value.h:42
fl_json_message_codec_new
G_MODULE_EXPORT FlJsonMessageCodec * fl_json_message_codec_new()
Definition: fl_json_message_codec.cc:306
fl_engine_remove_view
void fl_engine_remove_view(FlEngine *self, FlutterViewId view_id, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_engine.cc:788
fl_engine_dispatch_semantics_action
void fl_engine_dispatch_semantics_action(FlEngine *self, uint64_t id, FlutterSemanticsAction action, GBytes *data)
Definition: fl_engine.cc:1204
fl_dart_project_new
G_MODULE_EXPORT FlDartProject * fl_dart_project_new()
Definition: fl_dart_project.cc:50
fl_value_lookup_string
G_MODULE_EXPORT FlValue * fl_value_lookup_string(FlValue *self, const gchar *key)
Definition: fl_value.cc:811
fl_engine_get_binary_messenger
G_MODULE_EXPORT FlBinaryMessenger * fl_engine_get_binary_messenger(FlEngine *self)
Definition: fl_engine.cc:1246
fl_engine_send_key_event
void fl_engine_send_key_event(FlEngine *self, const FlutterKeyEvent *event, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_engine.cc:1164
user_data
G_BEGIN_DECLS G_MODULE_EXPORT FlValue gpointer user_data
Definition: fl_event_channel.h:90
fl_message_codec_decode_message
G_MODULE_EXPORT FlValue * fl_message_codec_decode_message(FlMessageCodec *self, GBytes *message, GError **error)
Definition: fl_message_codec.cc:33
fl_value_get_type
G_MODULE_EXPORT FlValueType fl_value_get_type(FlValue *self)
Definition: fl_value.cc:466
fl_engine_add_view_finish
gboolean fl_engine_add_view_finish(FlEngine *self, GAsyncResult *result, GError **error)
Definition: fl_engine.cc:781
fl_engine_remove_view_finish
gboolean fl_engine_remove_view_finish(FlEngine *self, GAsyncResult *result, GError **error)
Definition: fl_engine.cc:813
FL_VALUE_TYPE_STRING
@ FL_VALUE_TYPE_STRING
Definition: fl_value.h:68
fl_dart_project_set_dart_entrypoint_arguments
G_MODULE_EXPORT void fl_dart_project_set_dart_entrypoint_arguments(FlDartProject *self, char **argv)
Definition: fl_dart_project.cc:110
remove_view_engine_error_cb
static void remove_view_engine_error_cb(GObject *object, GAsyncResult *result, gpointer user_data)
Definition: fl_engine_test.cc:803
TRUE
return TRUE
Definition: fl_pixel_buffer_texture_test.cc:53
fl_engine_add_view
FlutterViewId fl_engine_add_view(FlEngine *self, size_t width, size_t height, double pixel_ratio, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_engine.cc:738
fl_engine_get_mouse_cursor_handler
FlMouseCursorHandler * fl_engine_get_mouse_cursor_handler(FlEngine *self)
Definition: fl_engine.cc:1299
fl_engine_get_display_monitor
FlDisplayMonitor * fl_engine_get_display_monitor(FlEngine *self)
Definition: fl_engine.cc:602
add_view_error_cb
static void add_view_error_cb(GObject *object, GAsyncResult *result, gpointer user_data)
Definition: fl_engine_test.cc:664
add_view_cb
static void add_view_cb(GObject *object, GAsyncResult *result, gpointer user_data)
Definition: fl_engine_test.cc:621
height
const uint8_t uint32_t uint32_t * height
Definition: fl_pixel_buffer_texture_test.cc:39
remove_view_cb
static void remove_view_cb(GObject *object, GAsyncResult *result, gpointer user_data)
Definition: fl_engine_test.cc:730
fl_engine_new
G_MODULE_EXPORT FlEngine * fl_engine_new(FlDartProject *project)
Definition: fl_engine.cc:580
fl_engine_get_windowing_handler
FlWindowingHandler * fl_engine_get_windowing_handler(FlEngine *self)
Definition: fl_engine.cc:1284
args
G_BEGIN_DECLS G_MODULE_EXPORT FlValue * args
Definition: fl_event_channel.h:89
error
const uint8_t uint32_t uint32_t GError ** error
Definition: fl_pixel_buffer_texture_test.cc:40
fl_engine_for_id
FlEngine * fl_engine_for_id(int64_t id)
Definition: fl_engine.cc:567
fl_engine_get_task_runner
FlTaskRunner * fl_engine_get_task_runner(FlEngine *self)
Definition: fl_engine.cc:1252
fl_engine_send_pointer_pan_zoom_event
void fl_engine_send_pointer_pan_zoom_event(FlEngine *self, FlutterViewId view_id, size_t timestamp, double x, double y, FlutterPointerPhase phase, double pan_x, double pan_y, double scale, double rotation)
Definition: fl_engine.cc:1125
fl_engine_send_platform_message
void fl_engine_send_platform_message(FlEngine *self, const gchar *channel, GBytes *message, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_engine.cc:871
on_pre_engine_restart_cb
void on_pre_engine_restart_cb(FlEngine *engine, gpointer user_data)
Definition: fl_engine_test.cc:334
fl_engine_start
gboolean fl_engine_start(FlEngine *self, GError **error)
Definition: fl_engine.cc:607
FL_VALUE_TYPE_FLOAT
@ FL_VALUE_TYPE_FLOAT
Definition: fl_value.h:67
fl_engine_notify_display_update
void fl_engine_notify_display_update(FlEngine *self, const FlutterEngineDisplay *displays, size_t displays_length)
Definition: fl_engine.cc:725
remove_view_error_cb
static void remove_view_error_cb(GObject *object, GAsyncResult *result, gpointer user_data)
Definition: fl_engine_test.cc:769
fl_engine_send_window_metrics_event
void fl_engine_send_window_metrics_event(FlEngine *self, FlutterEngineDisplayId display_id, FlutterViewId view_id, size_t width, size_t height, double pixel_ratio)
Definition: fl_engine.cc:939
width
const uint8_t uint32_t * width
Definition: fl_pixel_buffer_texture_test.cc:38
fl_engine_send_mouse_pointer_event
void fl_engine_send_mouse_pointer_event(FlEngine *self, FlutterViewId view_id, FlutterPointerPhase phase, size_t timestamp, double x, double y, FlutterPointerDeviceKind device_kind, double scroll_delta_x, double scroll_delta_y, int64_t buttons)
Definition: fl_engine.cc:961
FL_VALUE_TYPE_BOOL
@ FL_VALUE_TYPE_BOOL
Definition: fl_value.h:65
fl_engine_send_platform_message_response
gboolean fl_engine_send_platform_message_response(FlEngine *self, const FlutterPlatformMessageResponseHandle *handle, GBytes *response, GError **error)
Definition: fl_engine.cc:839