fl_text_input_handler_test.cc File Reference

#include <utility>
#include "flutter/shell/platform/linux/fl_binary_messenger_private.h"
#include "flutter/shell/platform/linux/fl_method_codec_private.h"
#include "flutter/shell/platform/linux/fl_text_input_handler.h"
#include "flutter/shell/platform/linux/testing/fl_mock_binary_messenger.h"
#include "flutter/shell/platform/linux/testing/fl_test.h"
#include "flutter/shell/platform/linux/testing/mock_gtk.h"
#include "flutter/testing/testing.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"

Go to the source code of this file.

Classes
struct	InputConfig
struct	EditingState
struct	EditingDelta

Functions
static FlValue *	build_map (std::map< const gchar *, FlValue * > args)
static FlValue *	build_list (std::vector< FlValue * > args)
static FlValue *	build_input_config (InputConfig config)
static FlValue *	build_editing_state (EditingState state)
static FlValue *	build_editing_delta (EditingDelta delta)
static void	set_client (FlMockBinaryMessenger *messenger, InputConfig config)
static void	set_editing_state (FlMockBinaryMessenger *messenger, EditingState state)
static void	send_key_event (FlTextInputHandler *handler, gint keyval, gint state=0)
	TEST (FlTextInputHandlerTest, MessageHandler)
	TEST (FlTextInputHandlerTest, SetClient)
	TEST (FlTextInputHandlerTest, Show)
	TEST (FlTextInputHandlerTest, Hide)
	TEST (FlTextInputHandlerTest, ClearClient)
	TEST (FlTextInputHandlerTest, PerformAction)
	TEST (FlTextInputHandlerTest, MultilineWithSendAction)
	TEST (FlTextInputHandlerTest, MoveCursor)
	TEST (FlTextInputHandlerTest, Select)
	TEST (FlTextInputHandlerTest, Composing)
	TEST (FlTextInputHandlerTest, SurroundingText)
	TEST (FlTextInputHandlerTest, SetMarkedTextRect)
	TEST (FlTextInputHandlerTest, TextInputTypeNone)
	TEST (FlTextInputHandlerTest, TextEditingDelta)
	TEST (FlTextInputHandlerTest, ComposingDelta)
	TEST (FlTextInputHandlerTest, NonComposingDelta)

Function Documentation

build_editing_delta()

static FlValue * build_editing_delta ( EditingDelta  delta )

static

Definition at line 85 of file fl_text_input_handler_test.cc.

                                                        {
  return build_map({
      {"oldText", fl_value_new_string(delta.old_text)},
      {"deltaText", fl_value_new_string(delta.delta_text)},
      {"deltaStart", fl_value_new_int(delta.delta_start)},
      {"deltaEnd", fl_value_new_int(delta.delta_end)},
      {"selectionBase", fl_value_new_int(delta.selection_base)},
      {"selectionExtent", fl_value_new_int(delta.selection_extent)},
      {"selectionAffinity", fl_value_new_string("TextAffinity.downstream")},
      {"selectionIsDirectional", fl_value_new_bool(false)},
      {"composingBase", fl_value_new_int(delta.composing_base)},
      {"composingExtent", fl_value_new_int(delta.composing_extent)},
  });
}

References build_map(), EditingDelta::composing_base, EditingDelta::composing_extent, EditingDelta::delta_end, EditingDelta::delta_start, EditingDelta::delta_text, fl_value_new_bool(), fl_value_new_int(), fl_value_new_string(), EditingDelta::old_text, EditingDelta::selection_base, and EditingDelta::selection_extent.

Referenced by TEST(), TEST(), and TEST().

build_editing_state()

static FlValue * build_editing_state ( EditingState  state )

static

Definition at line 62 of file fl_text_input_handler_test.cc.

                                                        {
  return build_map({
      {"text", fl_value_new_string(state.text)},
      {"selectionBase", fl_value_new_int(state.selection_base)},
      {"selectionExtent", fl_value_new_int(state.selection_extent)},
      {"selectionAffinity", fl_value_new_string("TextAffinity.downstream")},
      {"selectionIsDirectional", fl_value_new_bool(false)},
      {"composingBase", fl_value_new_int(state.composing_base)},
      {"composingExtent", fl_value_new_int(state.composing_extent)},
  });
}

References build_map(), EditingState::composing_base, EditingState::composing_extent, fl_value_new_bool(), fl_value_new_int(), fl_value_new_string(), EditingState::selection_base, EditingState::selection_extent, and EditingState::text.

Referenced by set_editing_state(), TEST(), TEST(), TEST(), TEST(), and TEST().

build_input_config()

static FlValue * build_input_config ( InputConfig  config )

static

Definition at line 41 of file fl_text_input_handler_test.cc.

                                                       {
  return build_list({
      fl_value_new_int(config.client_id),
      build_map({
          {"inputAction", fl_value_new_string(config.input_action)},
          {"inputType", build_map({
                            {"name", fl_value_new_string(config.input_type)},
                        })},
          {"enableDeltaModel", fl_value_new_bool(config.enable_delta_model)},
      }),
  });
}

References build_list(), build_map(), InputConfig::client_id, InputConfig::enable_delta_model, fl_value_new_bool(), fl_value_new_int(), fl_value_new_string(), InputConfig::input_action, and InputConfig::input_type.

Referenced by set_client().

build_list()

static FlValue * build_list ( std::vector< FlValue * >  args )

static

Definition at line 26 of file fl_text_input_handler_test.cc.

                                                     {
  FlValue* value = fl_value_new_list();
  for (auto it = args.begin(); it != args.end(); ++it) {
    fl_value_append_take(value, *it);
  }
  return value;
}

References args, fl_value_append_take(), fl_value_new_list(), and value.

Referenced by build_input_config(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

build_map()

static FlValue * build_map ( std::map< const gchar *, FlValue * >  args )

static

Definition at line 18 of file fl_text_input_handler_test.cc.

                                                               {
  FlValue* value = fl_value_new_map();
  for (auto it = args.begin(); it != args.end(); ++it) {
    fl_value_set_string_take(value, it->first, it->second);
  }
  return value;
}

References args, fl_value_new_map(), fl_value_set_string_take(), and value.

Referenced by build_editing_delta(), build_editing_state(), build_input_config(), TEST(), TEST(), TEST(), and TEST().

send_key_event()

static void send_key_event ( FlTextInputHandler *  handler, gint  keyval, gint  state = 0  )

static

Definition at line 143 of file fl_text_input_handler_test.cc.

                                           {
  GdkEvent* gdk_event = gdk_event_new(GDK_KEY_PRESS);
  gdk_event->key.keyval = keyval;
  gdk_event->key.state = state;
  g_autoptr(FlKeyEvent) key_event = fl_key_event_new_from_gdk_event(gdk_event);
  fl_text_input_handler_filter_keypress(handler, key_event);
}

References fl_key_event_new_from_gdk_event(), fl_text_input_handler_filter_keypress(), g_autoptr(), handler, and key_event.

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

set_client()

static void set_client ( FlMockBinaryMessenger *  messenger, InputConfig  config  )

static

Definition at line 100 of file fl_text_input_handler_test.cc.

                                                                             {
  gboolean called = FALSE;
  g_autoptr(FlValue) args = build_input_config(config);
  fl_mock_binary_messenger_invoke_json_method(
      messenger, "flutter/textinput", "TextInput.setClient", args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
 
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
 
        g_autoptr(FlValue) expected_result = fl_value_new_null();
        EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
                                       FL_METHOD_SUCCESS_RESPONSE(response)),
                                   expected_result));
      },
      &called);
  EXPECT_TRUE(called);
}

References args, build_input_config(), fl_method_success_response_get_result(), fl_mock_binary_messenger_invoke_json_method(), fl_value_equal(), fl_value_new_null(), g_autoptr(), TRUE, and user_data.

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

set_editing_state()

static void set_editing_state ( FlMockBinaryMessenger *  messenger, EditingState  state  )

static

Definition at line 121 of file fl_text_input_handler_test.cc.

                                                  {
  gboolean called = FALSE;
  g_autoptr(FlValue) args = build_editing_state(state);
  fl_mock_binary_messenger_invoke_json_method(
      messenger, "flutter/textinput", "TextInput.setEditingState", args,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
 
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
 
        g_autoptr(FlValue) expected_result = fl_value_new_null();
        EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
                                       FL_METHOD_SUCCESS_RESPONSE(response)),
                                   expected_result));
      },
      &called);
  EXPECT_TRUE(called);
}

References args, build_editing_state(), fl_method_success_response_get_result(), fl_mock_binary_messenger_invoke_json_method(), fl_value_equal(), fl_value_new_null(), g_autoptr(), TRUE, and user_data.

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

TEST() [1/16]

TEST	(	FlTextInputHandlerTest	,
		ClearClient
	)

Definition at line 242 of file fl_text_input_handler_test.cc.

                                          {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_json_method(
      messenger, "flutter/textinput", "TextInput.clearClient", nullptr,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
 
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
 
        g_autoptr(FlValue) expected_result = fl_value_new_null();
        EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
                                       FL_METHOD_SUCCESS_RESPONSE(response)),
                                   expected_result));
      },
      &called);
  EXPECT_TRUE(called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References fl_binary_messenger_shutdown(), fl_method_success_response_get_result(), fl_mock_binary_messenger_invoke_json_method(), fl_mock_binary_messenger_new(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_null(), g_autoptr(), handler, TRUE, and user_data.

TEST() [2/16]

TEST	(	FlTextInputHandlerTest	,
		Composing
	)

Definition at line 519 of file fl_text_input_handler_test.cc.

                                        {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  // update
  EXPECT_CALL(mock_gtk, gtk_im_context_get_preedit_string(
                            ::testing::_, ::testing::A<gchar**>(), ::testing::_,
                            ::testing::A<gint*>()))
      .WillOnce(
          ::testing::DoAll(::testing::SetArgPointee<1>(g_strdup("Flutter")),
                           ::testing::SetArgPointee<3>(0)));
 
  int call_count = 0;
  fl_mock_binary_messenger_set_json_method_channel(
      messenger, "flutter/textinput",
      [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
         FlValue* args, gpointer user_data) {
        int* call_count = static_cast<int*>(user_data);
 
        EXPECT_STREQ(name, "TextInputClient.updateEditingState");
        g_autoptr(FlValue) expected_args = nullptr;
        switch (*call_count) {
          case 0:
            expected_args = build_list({
                fl_value_new_int(-1),  // client_id
                build_editing_state({
                    .text = "Flutter",
                    .selection_base = 0,
                    .selection_extent = 0,
                    .composing_base = 0,
                    .composing_extent = 7,
                }),
            });
            break;
          case 1:
            // commit
            expected_args = build_list({
                fl_value_new_int(-1),  // client_id
                build_editing_state({
                    .text = "engine",
                    .selection_base = 6,
                    .selection_extent = 6,
                }),
            });
            break;
          case 2:
            // end
            expected_args = build_list({
                fl_value_new_int(-1),  // client_id
                build_editing_state({
                    .text = "engine",
                    .selection_base = 6,
                    .selection_extent = 6,
                }),
            });
            break;
          default:
            g_assert_not_reached();
            break;
        }
        EXPECT_TRUE(fl_value_equal(args, expected_args));
        (*call_count)++;
 
        return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
      },
      &call_count);
 
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler),
                        "preedit-start", nullptr);
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler),
                        "preedit-changed", nullptr);
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler), "commit",
                        "engine", nullptr);
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler),
                        "preedit-end", nullptr);
  EXPECT_EQ(call_count, 3);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, build_editing_state(), build_list(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_json_method_channel(), fl_text_input_handler_get_im_context(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), g_autoptr(), gtk_im_context_get_preedit_string(), handler, name, and user_data.

TEST() [3/16]

TEST	(	FlTextInputHandlerTest	,
		ComposingDelta
	)

Definition at line 866 of file fl_text_input_handler_test.cc.

                                             {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  // set config
  set_client(messenger, {
                            .client_id = 1,
                            .enable_delta_model = true,
                        });
 
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler),
                        "preedit-start", nullptr);
 
  // update
  EXPECT_CALL(mock_gtk, gtk_im_context_get_preedit_string(
                            ::testing::_, ::testing::A<gchar**>(), ::testing::_,
                            ::testing::A<gint*>()))
      .WillOnce(
          ::testing::DoAll(::testing::SetArgPointee<1>(g_strdup("Flutter ")),
                           ::testing::SetArgPointee<3>(8)));
 
  int call_count = 0;
  fl_mock_binary_messenger_set_json_method_channel(
      messenger, "flutter/textinput",
      [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
         FlValue* args, gpointer user_data) {
        int* call_count = static_cast<int*>(user_data);
 
        EXPECT_STREQ(name, "TextInputClient.updateEditingStateWithDeltas");
        g_autoptr(FlValue) expected_args = nullptr;
        switch (*call_count) {
          case 0:
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_map({{
                    "deltas",
                    build_list({
                        build_editing_delta({
                            .old_text = "",
                            .delta_text = "Flutter ",
                            .delta_start = 0,
                            .delta_end = 0,
                            .selection_base = 8,
                            .selection_extent = 8,
                            .composing_base = 0,
                            .composing_extent = 8,
                        }),
                    }),
                }}),
            });
            break;
          case 1:
            // commit
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_map({{
                    "deltas",
                    build_list({
                        build_editing_delta({
                            .old_text = "Flutter ",
                            .delta_text = "Flutter engine",
                            .delta_start = 0,
                            .delta_end = 8,
                            .selection_base = 14,
                            .selection_extent = 14,
                            .composing_base = -1,
                            .composing_extent = -1,
                        }),
                    }),
                }}),
            });
            break;
          case 2:
            // end
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_map({{
                    "deltas",
                    build_list({
                        build_editing_delta({
                            .old_text = "Flutter engine",
                            .selection_base = 14,
                            .selection_extent = 14,
                        }),
                    }),
                }}),
            });
            break;
          default:
            g_assert_not_reached();
            break;
        }
        EXPECT_TRUE(fl_value_equal(args, expected_args));
        (*call_count)++;
 
        return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
      },
      &call_count);
 
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler),
                        "preedit-changed", nullptr);
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler), "commit",
                        "Flutter engine", nullptr);
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler),
                        "preedit-end", nullptr);
  EXPECT_EQ(call_count, 3);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, build_editing_delta(), build_list(), build_map(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_json_method_channel(), fl_text_input_handler_get_im_context(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), g_autoptr(), gtk_im_context_get_preedit_string(), handler, name, set_client(), and user_data.

TEST() [4/16]

TEST	(	FlTextInputHandlerTest	,
		Hide
	)

Definition at line 211 of file fl_text_input_handler_test.cc.

                                   {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  EXPECT_CALL(mock_gtk, gtk_im_context_focus_out);
 
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_json_method(
      messenger, "flutter/textinput", "TextInput.hide", nullptr,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
 
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
 
        g_autoptr(FlValue) expected_result = fl_value_new_null();
        EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
                                       FL_METHOD_SUCCESS_RESPONSE(response)),
                                   expected_result));
      },
      &called);
  EXPECT_TRUE(called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References fl_binary_messenger_shutdown(), fl_method_success_response_get_result(), fl_mock_binary_messenger_invoke_json_method(), fl_mock_binary_messenger_new(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_null(), g_autoptr(), gtk_im_context_focus_out(), handler, TRUE, and user_data.

TEST() [5/16]

TEST	(	FlTextInputHandlerTest	,
		MessageHandler
	)

Definition at line 153 of file fl_text_input_handler_test.cc.

                                             {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  EXPECT_TRUE(
      fl_mock_binary_messenger_has_handler(messenger, "flutter/textinput"));
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References fl_binary_messenger_shutdown(), fl_mock_binary_messenger_has_handler(), fl_mock_binary_messenger_new(), fl_text_input_handler_new(), g_autoptr(), and handler.

TEST() [6/16]

TEST	(	FlTextInputHandlerTest	,
		MoveCursor
	)

Definition at line 389 of file fl_text_input_handler_test.cc.

                                         {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  set_client(messenger, {.client_id = 1});
  set_editing_state(messenger, {
                                   .text = "Flutter",
                                   .selection_base = 4,
                                   .selection_extent = 4,
                               });
 
  int call_count = 0;
  fl_mock_binary_messenger_set_json_method_channel(
      messenger, "flutter/textinput",
      [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
         FlValue* args, gpointer user_data) {
        int* call_count = static_cast<int*>(user_data);
 
        EXPECT_STREQ(name, "TextInputClient.updateEditingState");
        g_autoptr(FlValue) expected_args = nullptr;
        switch (*call_count) {
          case 0:
            // move cursor to beginning
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_editing_state({
                    .text = "Flutter",
                    .selection_base = 0,
                    .selection_extent = 0,
                }),
            });
            break;
          case 1:
            // move cursor to end
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_editing_state({
                    .text = "Flutter",
                    .selection_base = 7,
                    .selection_extent = 7,
                }),
            });
            break;
          default:
            g_assert_not_reached();
            break;
        }
        EXPECT_TRUE(fl_value_equal(args, expected_args));
        (*call_count)++;
 
        return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
      },
      &call_count);
 
  send_key_event(handler, GDK_KEY_Home);
  send_key_event(handler, GDK_KEY_End);
  EXPECT_EQ(call_count, 2);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, build_editing_state(), build_list(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_json_method_channel(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), g_autoptr(), handler, name, send_key_event(), set_client(), set_editing_state(), and user_data.

TEST() [7/16]

TEST	(	FlTextInputHandlerTest	,
		MultilineWithSendAction
	)

Definition at line 331 of file fl_text_input_handler_test.cc.

                                                      {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  set_client(messenger, {
                            .client_id = 1,
                            .input_type = "TextInputType.multiline",
                            .input_action = "TextInputAction.send",
                        });
  set_editing_state(messenger, {
                                   .text = "Flutter",
                                   .selection_base = 7,
                                   .selection_extent = 7,
                               });
 
  // Because the input action is not set to TextInputAction.newline, the next
  // expected call is "TextInputClient.performAction". If the input action was
  // set to TextInputAction.newline the next call would be
  // "TextInputClient.updateEditingState" (this case is tested in the test named
  // 'PerformAction').
  int call_count = 0;
  fl_mock_binary_messenger_set_json_method_channel(
      messenger, "flutter/textinput",
      [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
         FlValue* args, gpointer user_data) {
        int* call_count = static_cast<int*>(user_data);
 
        EXPECT_STREQ(name, "TextInputClient.performAction");
        g_autoptr(FlValue) expected_args = nullptr;
        switch (*call_count) {
          case 0:
            // Perform action.
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                fl_value_new_string("TextInputAction.send"),
            });
            break;
          default:
            g_assert_not_reached();
            break;
        }
        EXPECT_TRUE(fl_value_equal(args, expected_args));
        (*call_count)++;
 
        return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
      },
      &call_count);
 
  send_key_event(handler, GDK_KEY_Return);
  EXPECT_EQ(call_count, 1);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, build_list(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_json_method_channel(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), fl_value_new_string(), g_autoptr(), handler, name, send_key_event(), set_client(), set_editing_state(), and user_data.

TEST() [8/16]

TEST	(	FlTextInputHandlerTest	,
		NonComposingDelta
	)

Definition at line 980 of file fl_text_input_handler_test.cc.

                                                {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  // set config
  set_client(messenger, {
                            .client_id = 1,
                            .enable_delta_model = true,
                        });
 
  int call_count = 0;
  fl_mock_binary_messenger_set_json_method_channel(
      messenger, "flutter/textinput",
      [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
         FlValue* args, gpointer user_data) {
        int* call_count = static_cast<int*>(user_data);
 
        EXPECT_STREQ(name, "TextInputClient.updateEditingStateWithDeltas");
        g_autoptr(FlValue) expected_args = nullptr;
        switch (*call_count) {
          case 0:
            // commit F
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_map({{
                    "deltas",
                    build_list({
                        build_editing_delta({
                            .old_text = "",
                            .delta_text = "F",
                            .delta_start = 0,
                            .delta_end = 0,
                            .selection_base = 1,
                            .selection_extent = 1,
                            .composing_base = -1,
                            .composing_extent = -1,
                        }),
                    }),
                }}),
            });
            break;
          case 1:
            // commit l
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_map({{
                    "deltas",
                    build_list({
                        build_editing_delta({
                            .old_text = "F",
                            .delta_text = "l",
                            .delta_start = 1,
                            .delta_end = 1,
                            .selection_base = 2,
                            .selection_extent = 2,
                            .composing_base = -1,
                            .composing_extent = -1,
                        }),
                    }),
                }}),
            });
            break;
          case 2:
            // commit u
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_map({{
                    "deltas",
                    build_list({
                        build_editing_delta({
                            .old_text = "Fl",
                            .delta_text = "u",
                            .delta_start = 2,
                            .delta_end = 2,
                            .selection_base = 3,
                            .selection_extent = 3,
                            .composing_base = -1,
                            .composing_extent = -1,
                        }),
                    }),
                }}),
            });
            break;
          case 3:
            // commit t
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_map({{
                    "deltas",
                    build_list({
                        build_editing_delta({
                            .old_text = "Flu",
                            .delta_text = "t",
                            .delta_start = 3,
                            .delta_end = 3,
                            .selection_base = 4,
                            .selection_extent = 4,
                            .composing_base = -1,
                            .composing_extent = -1,
                        }),
                    }),
                }}),
            });
            break;
          case 4:
            // commit t again
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_map({{
                    "deltas",
                    build_list({
                        build_editing_delta({
                            .old_text = "Flut",
                            .delta_text = "t",
                            .delta_start = 4,
                            .delta_end = 4,
                            .selection_base = 5,
                            .selection_extent = 5,
                            .composing_base = -1,
                            .composing_extent = -1,
                        }),
                    }),
                }}),
            });
            break;
          case 5:
            // commit e
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_map({{
                    "deltas",
                    build_list({
                        build_editing_delta({
                            .old_text = "Flutt",
                            .delta_text = "e",
                            .delta_start = 5,
                            .delta_end = 5,
                            .selection_base = 6,
                            .selection_extent = 6,
                            .composing_base = -1,
                            .composing_extent = -1,
                        }),
                    }),
                }}),
            });
            break;
          case 6:
            // commit r
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_map({{
                    "deltas",
                    build_list({
                        build_editing_delta({
                            .old_text = "Flutte",
                            .delta_text = "r",
                            .delta_start = 6,
                            .delta_end = 6,
                            .selection_base = 7,
                            .selection_extent = 7,
                            .composing_base = -1,
                            .composing_extent = -1,
                        }),
                    }),
                }}),
            });
            break;
          default:
            g_assert_not_reached();
            break;
        }
        EXPECT_TRUE(fl_value_equal(args, expected_args));
        (*call_count)++;
 
        return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
      },
      &call_count);
 
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler), "commit",
                        "F", nullptr);
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler), "commit",
                        "l", nullptr);
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler), "commit",
                        "u", nullptr);
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler), "commit",
                        "t", nullptr);
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler), "commit",
                        "t", nullptr);
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler), "commit",
                        "e", nullptr);
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler), "commit",
                        "r", nullptr);
  EXPECT_EQ(call_count, 7);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, build_editing_delta(), build_list(), build_map(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_json_method_channel(), fl_text_input_handler_get_im_context(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), g_autoptr(), handler, name, set_client(), and user_data.

TEST() [9/16]

TEST	(	FlTextInputHandlerTest	,
		PerformAction
	)

Definition at line 271 of file fl_text_input_handler_test.cc.

                                            {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  set_client(messenger, {
                            .client_id = 1,
                            .input_type = "TextInputType.multiline",
                            .input_action = "TextInputAction.newline",
                        });
  set_editing_state(messenger, {
                                   .text = "Flutter",
                                   .selection_base = 7,
                                   .selection_extent = 7,
                               });
 
  // Client will update editing state and perform action
  int call_count = 0;
  fl_mock_binary_messenger_set_json_method_channel(
      messenger, "flutter/textinput",
      [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
         FlValue* args, gpointer user_data) {
        int* call_count = static_cast<int*>(user_data);
 
        if (strcmp(name, "TextInputClient.updateEditingState") == 0) {
          g_autoptr(FlValue) expected_args = build_list({
              fl_value_new_int(1),  // client_id
              build_editing_state({
                  .text = "Flutter\n",
                  .selection_base = 8,
                  .selection_extent = 8,
              }),
          });
          EXPECT_TRUE(fl_value_equal(args, expected_args));
          EXPECT_EQ(*call_count, 0);
          (*call_count)++;
        } else if (strcmp(name, "TextInputClient.performAction") == 0) {
          g_autoptr(FlValue) expected_args = build_list({
              fl_value_new_int(1),  // client_id
              fl_value_new_string("TextInputAction.newline"),
          });
          EXPECT_TRUE(fl_value_equal(args, expected_args));
          EXPECT_EQ(*call_count, 1);
          (*call_count)++;
        }
 
        return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
      },
      &call_count);
 
  send_key_event(handler, GDK_KEY_Return);
  EXPECT_EQ(call_count, 2);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, build_editing_state(), build_list(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_json_method_channel(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), fl_value_new_string(), g_autoptr(), handler, name, send_key_event(), set_client(), set_editing_state(), and user_data.

TEST() [10/16]

TEST	(	FlTextInputHandlerTest	,
		Select
	)

Definition at line 454 of file fl_text_input_handler_test.cc.

                                     {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  set_client(messenger, {.client_id = 1});
  set_editing_state(messenger, {
                                   .text = "Flutter",
                                   .selection_base = 4,
                                   .selection_extent = 4,
                               });
 
  int call_count = 0;
  fl_mock_binary_messenger_set_json_method_channel(
      messenger, "flutter/textinput",
      [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
         FlValue* args, gpointer user_data) {
        int* call_count = static_cast<int*>(user_data);
 
        EXPECT_STREQ(name, "TextInputClient.updateEditingState");
        g_autoptr(FlValue) expected_args = nullptr;
        switch (*call_count) {
          case 0:
            // select to end
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_editing_state({
                    .text = "Flutter",
                    .selection_base = 4,
                    .selection_extent = 7,
                }),
            });
            break;
          case 1:
            // select to beginning
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_editing_state({
                    .text = "Flutter",
                    .selection_base = 4,
                    .selection_extent = 0,
                }),
            });
            break;
          default:
            g_assert_not_reached();
            break;
        }
        EXPECT_TRUE(fl_value_equal(args, expected_args));
        (*call_count)++;
 
        return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
      },
      &call_count);
 
  send_key_event(handler, GDK_KEY_End, GDK_SHIFT_MASK);
  send_key_event(handler, GDK_KEY_Home, GDK_SHIFT_MASK);
  EXPECT_EQ(call_count, 2);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, build_editing_state(), build_list(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_json_method_channel(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), g_autoptr(), handler, name, send_key_event(), set_client(), set_editing_state(), and user_data.

TEST() [11/16]

TEST	(	FlTextInputHandlerTest	,
		SetClient
	)

Definition at line 167 of file fl_text_input_handler_test.cc.

                                        {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  set_client(messenger, {.client_id = 1});
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References fl_binary_messenger_shutdown(), fl_mock_binary_messenger_new(), fl_text_input_handler_new(), g_autoptr(), handler, and set_client().

TEST() [12/16]

TEST	(	FlTextInputHandlerTest	,
		SetMarkedTextRect
	)

Definition at line 668 of file fl_text_input_handler_test.cc.

                                                {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler),
                        "preedit-start", nullptr);
 
  // set editable size and transform
  g_autoptr(FlValue) size_and_transform = build_map({
      {
          "transform",
          build_list({
              fl_value_new_float(1),
              fl_value_new_float(2),
              fl_value_new_float(3),
              fl_value_new_float(4),
              fl_value_new_float(5),
              fl_value_new_float(6),
              fl_value_new_float(7),
              fl_value_new_float(8),
              fl_value_new_float(9),
              fl_value_new_float(10),
              fl_value_new_float(11),
              fl_value_new_float(12),
              fl_value_new_float(13),
              fl_value_new_float(14),
              fl_value_new_float(15),
              fl_value_new_float(16),
          }),
      },
  });
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_json_method(
      messenger, "flutter/textinput", "TextInput.setEditableSizeAndTransform",
      size_and_transform,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
 
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
 
        g_autoptr(FlValue) expected_result = fl_value_new_null();
        EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
                                       FL_METHOD_SUCCESS_RESPONSE(response)),
                                   expected_result));
      },
      &called);
  EXPECT_TRUE(called);
 
  EXPECT_CALL(mock_gtk, gtk_widget_translate_coordinates(
                            ::testing::_, ::testing::_, ::testing::Eq(27),
                            ::testing::Eq(32), ::testing::_, ::testing::_))
      .WillOnce(::testing::DoAll(::testing::SetArgPointee<4>(123),
                                 ::testing::SetArgPointee<5>(456),
                                 ::testing::Return(true)));
 
  EXPECT_CALL(mock_gtk, gtk_im_context_set_cursor_location(
                            ::testing::_,
                            ::testing::Pointee(::testing::AllOf(
                                ::testing::Field(&GdkRectangle::x, 123),
                                ::testing::Field(&GdkRectangle::y, 456),
                                ::testing::Field(&GdkRectangle::width, 0),
                                ::testing::Field(&GdkRectangle::height, 0)))));
 
  // set marked text rect
  g_autoptr(FlValue) rect = build_map({
      {"x", fl_value_new_float(1)},
      {"y", fl_value_new_float(2)},
      {"width", fl_value_new_float(3)},
      {"height", fl_value_new_float(4)},
  });
  called = FALSE;
  fl_mock_binary_messenger_invoke_json_method(
      messenger, "flutter/textinput", "TextInput.setMarkedTextRect", rect,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
 
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
 
        g_autoptr(FlValue) expected_result = fl_value_new_null();
        EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
                                       FL_METHOD_SUCCESS_RESPONSE(response)),
                                   expected_result));
      },
      &called);
  EXPECT_TRUE(called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References build_list(), build_map(), fl_binary_messenger_shutdown(), fl_method_success_response_get_result(), fl_mock_binary_messenger_invoke_json_method(), fl_mock_binary_messenger_new(), fl_text_input_handler_get_im_context(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_float(), fl_value_new_null(), g_autoptr(), gtk_im_context_set_cursor_location(), gtk_widget_translate_coordinates(), handler, TRUE, and user_data.

TEST() [13/16]

TEST	(	FlTextInputHandlerTest	,
		Show
	)

Definition at line 180 of file fl_text_input_handler_test.cc.

                                   {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  EXPECT_CALL(mock_gtk, gtk_im_context_focus_in);
 
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_json_method(
      messenger, "flutter/textinput", "TextInput.show", nullptr,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
 
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
 
        g_autoptr(FlValue) expected_result = fl_value_new_null();
        EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
                                       FL_METHOD_SUCCESS_RESPONSE(response)),
                                   expected_result));
      },
      &called);
  EXPECT_TRUE(called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References fl_binary_messenger_shutdown(), fl_method_success_response_get_result(), fl_mock_binary_messenger_invoke_json_method(), fl_mock_binary_messenger_new(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_null(), g_autoptr(), gtk_im_context_focus_in(), handler, TRUE, and user_data.

TEST() [14/16]

TEST	(	FlTextInputHandlerTest	,
		SurroundingText
	)

Definition at line 603 of file fl_text_input_handler_test.cc.

                                              {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  set_client(messenger, {.client_id = 1});
  set_editing_state(messenger, {
                                   .text = "Flutter",
                                   .selection_base = 3,
                                   .selection_extent = 3,
                               });
 
  // retrieve
  EXPECT_CALL(mock_gtk, gtk_im_context_set_surrounding(
                            ::testing::_, ::testing::StrEq("Flutter"), -1, 3));
 
  gboolean retrieved = false;
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler),
                        "retrieve-surrounding", &retrieved, nullptr);
  EXPECT_TRUE(retrieved);
 
  int call_count = 0;
  fl_mock_binary_messenger_set_json_method_channel(
      messenger, "flutter/textinput",
      [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
         FlValue* args, gpointer user_data) {
        int* call_count = static_cast<int*>(user_data);
 
        EXPECT_STREQ(name, "TextInputClient.updateEditingState");
        g_autoptr(FlValue) expected_args = nullptr;
        switch (*call_count) {
          case 0:
            // delete
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_editing_state({
                    .text = "Flutr",
                    .selection_base = 3,
                    .selection_extent = 3,
                }),
            });
            break;
          default:
            g_assert_not_reached();
            break;
        }
        EXPECT_TRUE(fl_value_equal(args, expected_args));
        (*call_count)++;
 
        return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
      },
      &call_count);
 
  gboolean deleted = false;
  g_signal_emit_by_name(fl_text_input_handler_get_im_context(handler),
                        "delete-surrounding", 1, 2, &deleted, nullptr);
  EXPECT_TRUE(deleted);
  EXPECT_EQ(call_count, 1);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, build_editing_state(), build_list(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_json_method_channel(), fl_text_input_handler_get_im_context(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), g_autoptr(), gtk_im_context_set_surrounding(), handler, name, set_client(), set_editing_state(), and user_data.

TEST() [15/16]

TEST	(	FlTextInputHandlerTest	,
		TextEditingDelta
	)

Definition at line 802 of file fl_text_input_handler_test.cc.

                                               {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  set_client(messenger, {
                            .client_id = 1,
                            .enable_delta_model = true,
                        });
  set_editing_state(messenger, {
                                   .text = "Flutter",
                                   .selection_base = 7,
                                   .selection_extent = 7,
                               });
 
  // update editing state with deltas
  int call_count = 0;
  fl_mock_binary_messenger_set_json_method_channel(
      messenger, "flutter/textinput",
      [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
         FlValue* args, gpointer user_data) {
        int* call_count = static_cast<int*>(user_data);
 
        EXPECT_STREQ(name, "TextInputClient.updateEditingStateWithDeltas");
        g_autoptr(FlValue) expected_args = nullptr;
        switch (*call_count) {
          case 0:
            expected_args = build_list({
                fl_value_new_int(1),  // client_id
                build_map({{
                    "deltas",
                    build_list({
                        build_editing_delta({
                            .old_text = "Flutter",
                            .delta_text = "Flutter",
                            .delta_start = 7,
                            .delta_end = 7,
                            .selection_base = 0,
                            .selection_extent = 0,
                        }),
                    }),
                }}),
            });
            break;
          default:
            g_assert_not_reached();
            break;
        }
        EXPECT_TRUE(fl_value_equal(args, expected_args));
        (*call_count)++;
 
        return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
      },
      &call_count);
 
  send_key_event(handler, GDK_KEY_Home);
  EXPECT_EQ(call_count, 1);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References args, build_editing_delta(), build_list(), build_map(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_mock_binary_messenger_new(), fl_mock_binary_messenger_set_json_method_channel(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), g_autoptr(), handler, name, send_key_event(), set_client(), set_editing_state(), and user_data.

TEST() [16/16]

TEST	(	FlTextInputHandlerTest	,
		TextInputTypeNone
	)

Definition at line 765 of file fl_text_input_handler_test.cc.

                                                {
  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
  ::testing::NiceMock<flutter::testing::MockGtk> mock_gtk;
 
  g_autoptr(FlTextInputHandler) handler =
      fl_text_input_handler_new(FL_BINARY_MESSENGER(messenger));
  EXPECT_NE(handler, nullptr);
 
  set_client(messenger, {
                            .client_id = 1,
                            .input_type = "TextInputType.none",
                        });
 
  EXPECT_CALL(mock_gtk, gtk_im_context_focus_in).Times(0);
  EXPECT_CALL(mock_gtk, gtk_im_context_focus_out);
 
  gboolean called = FALSE;
  fl_mock_binary_messenger_invoke_json_method(
      messenger, "flutter/textinput", "TextInput.show", nullptr,
      [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
         gpointer user_data) {
        gboolean* called = static_cast<gboolean*>(user_data);
        *called = TRUE;
 
        EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
 
        g_autoptr(FlValue) expected_result = fl_value_new_null();
        EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
                                       FL_METHOD_SUCCESS_RESPONSE(response)),
                                   expected_result));
      },
      &called);
  EXPECT_TRUE(called);
 
  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
}

References fl_binary_messenger_shutdown(), fl_method_success_response_get_result(), fl_mock_binary_messenger_invoke_json_method(), fl_mock_binary_messenger_new(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_null(), g_autoptr(), gtk_im_context_focus_in(), gtk_im_context_focus_out(), handler, set_client(), TRUE, and user_data.