// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <utility>

#include "flutter/shell/platform/linux/fl_method_codec_private.h"
#include "flutter/shell/platform/linux/fl_text_input_plugin.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_binary_messenger.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_json_method_codec.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_value.h"
#include "flutter/shell/platform/linux/testing/fl_test.h"
#include "flutter/shell/platform/linux/testing/mock_binary_messenger.h"
#include "flutter/shell/platform/linux/testing/mock_binary_messenger_response_handle.h"
#include "flutter/shell/platform/linux/testing/mock_im_context.h"
#include "flutter/shell/platform/linux/testing/mock_text_input_view_delegate.h"
#include "flutter/testing/testing.h"

#include "gmock/gmock.h"
#include "gtest/gtest.h"

void printTo(FlMethodResponse* response, ::std::ostream* os) {
  *os << ::testing::PrintToString(
      fl_method_response_get_result(response, nullptr));
}

MATCHER_P(SuccessResponse, result, "") {
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(FlMethodResponse) response =
      fl_method_codec_decode_response(FL_METHOD_CODEC(codec), arg, nullptr);
  if (fl_value_equal(fl_method_response_get_result(response, nullptr),
                     result)) {
    return true;
  }
  *result_listener << ::testing::PrintToString(response);
  return false;
}

MATCHER_P(FlValueEq, value, "equal to " + ::testing::PrintToString(value)) {
  return fl_value_equal(arg, value);
}

class MethodCallMatcher {
 public:
  using is_gtest_matcher = void;

  explicit MethodCallMatcher(::testing::Matcher<std::string> name,
                             ::testing::Matcher<FlValue*> args)
      : name_(std::move(name)), args_(std::move(args)) {}

  bool MatchAndExplain(GBytes* method_call,
                       ::testing::MatchResultListener* result_listener) const {
    g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
    g_autoptr(GError) error = nullptr;
    g_autofree gchar* name = nullptr;
    g_autoptr(FlValue) args = nullptr;
    gboolean result = fl_method_codec_decode_method_call(
        FL_METHOD_CODEC(codec), method_call, &name, &args, &error);
    if (!result) {
      *result_listener << ::testing::PrintToString(error->message);
      return false;
    }
    if (!name_.MatchAndExplain(name, result_listener)) {
      *result_listener << " where the name doesn't match: \"" << name << "\"";
      return false;
    }
    if (!args_.MatchAndExplain(args, result_listener)) {
      *result_listener << " where the args don't match: "
                       << ::testing::PrintToString(args);
      return false;
    }
    return true;
  }

  void DescribeTo(std::ostream* os) const {
    *os << "method name ";
    name_.DescribeTo(os);
    *os << " and args ";
    args_.DescribeTo(os);
  }

  void DescribeNegationTo(std::ostream* os) const {
    *os << "method name ";
    name_.DescribeNegationTo(os);
    *os << " or args ";
    args_.DescribeNegationTo(os);
  }

 private:
  ::testing::Matcher<std::string> name_;
  ::testing::Matcher<FlValue*> args_;
};

::testing::Matcher<GBytes*> MethodCall(const std::string& name,
                                       ::testing::Matcher<FlValue*> args) {
  return MethodCallMatcher(::testing::StrEq(name), std::move(args));
}

static FlValue* build_map(std::map<const gchar*, FlValue*> args) {
  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;
}

static FlValue* build_list(std::vector<FlValue*> args) {
  FlValue* value = fl_value_new_list();
  for (auto it = args.begin(); it != args.end(); ++it) {
    fl_value_append_take(value, *it);
  }
  return value;
}

struct InputConfig {
  int64_t client_id = -1;
  const gchar* input_type = "TextInputType.text";
  const gchar* input_action = "TextInputAction.none";
  gboolean enable_delta_model = false;
};

static FlValue* build_input_config(InputConfig config) {
  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)},
      }),
  });
}

struct EditingState {
  const gchar* text = "";
  int selection_base = -1;
  int selection_extent = -1;
  int composing_base = -1;
  int composing_extent = -1;
};

static FlValue* build_editing_state(EditingState state) {
  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)},
  });
}

struct EditingDelta {
  const gchar* old_text = "";
  const gchar* delta_text = "";
  int delta_start = -1;
  int delta_end = -1;
  int selection_base = -1;
  int selection_extent = -1;
  int composing_base = -1;
  int composing_extent = -1;
};

static FlValue* build_editing_delta(EditingDelta delta) {
  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)},
  });
}

static void send_key_event(FlTextInputPlugin* plugin,
                           gint keyval,
                           gint state = 0) {
  GdkEvent* gdk_event = gdk_event_new(GDK_KEY_PRESS);
  gdk_event->key.keyval = keyval;
  gdk_event->key.state = state;
  FlKeyEvent* key_event = fl_key_event_new_from_gdk_event(gdk_event);
  fl_text_input_plugin_filter_keypress(plugin, key_event);
  fl_key_event_dispose(key_event);
}

TEST(FlTextInputPluginTest, MessageHandler) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  EXPECT_TRUE(messenger.HasMessageHandler("flutter/textinput"));
}

TEST(FlTextInputPluginTest, SetClient) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  g_autoptr(FlValue) args = build_input_config({.client_id = 1});
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setClient", args, nullptr);

  g_autoptr(FlValue) null = fl_value_new_null();
  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", message);
}

TEST(FlTextInputPluginTest, Show) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  EXPECT_CALL(context,
              gtk_im_context_focus_in(::testing::Eq<GtkIMContext*>(context)));

  g_autoptr(FlValue) null = fl_value_new_null();
  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.show", nullptr, nullptr);

  messenger.ReceiveMessage("flutter/textinput", message);
}

TEST(FlTextInputPluginTest, Hide) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  EXPECT_CALL(context,
              gtk_im_context_focus_out(::testing::Eq<GtkIMContext*>(context)));

  g_autoptr(FlValue) null = fl_value_new_null();
  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.hide", nullptr, nullptr);

  messenger.ReceiveMessage("flutter/textinput", message);
}

TEST(FlTextInputPluginTest, ClearClient) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  g_autoptr(FlValue) null = fl_value_new_null();
  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.clearClient", nullptr, nullptr);

  messenger.ReceiveMessage("flutter/textinput", message);
}

TEST(FlTextInputPluginTest, PerformAction) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  // set input config
  g_autoptr(FlValue) config = build_input_config({
      .client_id = 1,
      .input_type = "TextInputType.multiline",
      .input_action = "TextInputAction.newline",
  });
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(GBytes) set_client = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setClient", config, nullptr);

  g_autoptr(FlValue) null = fl_value_new_null();
  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", set_client);

  // set editing state
  g_autoptr(FlValue) state = build_editing_state({
      .text = "Flutter",
      .selection_base = 7,
      .selection_extent = 7,
  });
  g_autoptr(GBytes) set_state = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setEditingState", state, nullptr);

  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", set_state);

  // update editing state
  g_autoptr(FlValue) new_state = build_list({
      fl_value_new_int(1),  // client_id
      build_editing_state({
          .text = "Flutter\n",
          .selection_base = 8,
          .selection_extent = 8,
      }),
  });

  EXPECT_CALL(messenger, fl_binary_messenger_send_on_channel(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::StrEq("flutter/textinput"),
                             MethodCall("TextInputClient.updateEditingState",
                                        FlValueEq(new_state)),
                             ::testing::_, ::testing::_, ::testing::_));

  // perform action
  g_autoptr(FlValue) action = build_list({
      fl_value_new_int(1),  // client_id
      fl_value_new_string("TextInputAction.newline"),
  });

  EXPECT_CALL(messenger, fl_binary_messenger_send_on_channel(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::StrEq("flutter/textinput"),
                             MethodCall("TextInputClient.performAction",
                                        FlValueEq(action)),
                             ::testing::_, ::testing::_, ::testing::_));

  send_key_event(plugin, GDK_KEY_Return);
}

// Regression test for https://github.com/flutter/flutter/issues/125879.
TEST(FlTextInputPluginTest, MultilineWithSendAction) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  // Set input config.
  g_autoptr(FlValue) config = build_input_config({
      .client_id = 1,
      .input_type = "TextInputType.multiline",
      .input_action = "TextInputAction.send",
  });
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(GBytes) set_client = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setClient", config, nullptr);

  g_autoptr(FlValue) null = fl_value_new_null();
  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", set_client);

  // Set editing state.
  g_autoptr(FlValue) state = build_editing_state({
      .text = "Flutter",
      .selection_base = 7,
      .selection_extent = 7,
  });
  g_autoptr(GBytes) set_state = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setEditingState", state, nullptr);

  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", set_state);

  // Perform action.
  g_autoptr(FlValue) action = build_list({
      fl_value_new_int(1),  // client_id
      fl_value_new_string("TextInputAction.send"),
  });

  // 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').
  EXPECT_CALL(messenger, fl_binary_messenger_send_on_channel(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::StrEq("flutter/textinput"),
                             MethodCall("TextInputClient.performAction",
                                        FlValueEq(action)),
                             ::testing::_, ::testing::_, ::testing::_));

  send_key_event(plugin, GDK_KEY_Return);
}

TEST(FlTextInputPluginTest, MoveCursor) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  // set input config
  g_autoptr(FlValue) config = build_input_config({.client_id = 1});
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(GBytes) set_client = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setClient", config, nullptr);

  g_autoptr(FlValue) null = fl_value_new_null();
  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", set_client);

  // set editing state
  g_autoptr(FlValue) state = build_editing_state({
      .text = "Flutter",
      .selection_base = 4,
      .selection_extent = 4,
  });
  g_autoptr(GBytes) set_state = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setEditingState", state, nullptr);

  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", set_state);

  // move cursor to beginning
  g_autoptr(FlValue) beginning = build_list({
      fl_value_new_int(1),  // client_id
      build_editing_state({
          .text = "Flutter",
          .selection_base = 0,
          .selection_extent = 0,
      }),
  });

  EXPECT_CALL(messenger, fl_binary_messenger_send_on_channel(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::StrEq("flutter/textinput"),
                             MethodCall("TextInputClient.updateEditingState",
                                        FlValueEq(beginning)),
                             ::testing::_, ::testing::_, ::testing::_));

  send_key_event(plugin, GDK_KEY_Home);

  // move cursor to end
  g_autoptr(FlValue) end = build_list({
      fl_value_new_int(1),  // client_id
      build_editing_state({
          .text = "Flutter",
          .selection_base = 7,
          .selection_extent = 7,
      }),
  });

  EXPECT_CALL(messenger, fl_binary_messenger_send_on_channel(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::StrEq("flutter/textinput"),
                             MethodCall("TextInputClient.updateEditingState",
                                        FlValueEq(end)),
                             ::testing::_, ::testing::_, ::testing::_));

  send_key_event(plugin, GDK_KEY_End);
}

TEST(FlTextInputPluginTest, Select) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  // set input config
  g_autoptr(FlValue) config = build_input_config({.client_id = 1});
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(GBytes) set_client = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setClient", config, nullptr);

  g_autoptr(FlValue) null = fl_value_new_null();
  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", set_client);

  // set editing state
  g_autoptr(FlValue) state = build_editing_state({
      .text = "Flutter",
      .selection_base = 4,
      .selection_extent = 4,
  });
  g_autoptr(GBytes) set_state = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setEditingState", state, nullptr);

  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", set_state);

  // select to end
  g_autoptr(FlValue) select_to_end = build_list({
      fl_value_new_int(1),  // client_id
      build_editing_state({
          .text = "Flutter",
          .selection_base = 4,
          .selection_extent = 7,
      }),
  });

  EXPECT_CALL(messenger, fl_binary_messenger_send_on_channel(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::StrEq("flutter/textinput"),
                             MethodCall("TextInputClient.updateEditingState",
                                        FlValueEq(select_to_end)),
                             ::testing::_, ::testing::_, ::testing::_));

  send_key_event(plugin, GDK_KEY_End, GDK_SHIFT_MASK);

  // select to beginning
  g_autoptr(FlValue) select_to_beginning = build_list({
      fl_value_new_int(1),  // client_id
      build_editing_state({
          .text = "Flutter",
          .selection_base = 4,
          .selection_extent = 0,
      }),
  });

  EXPECT_CALL(messenger, fl_binary_messenger_send_on_channel(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::StrEq("flutter/textinput"),
                             MethodCall("TextInputClient.updateEditingState",
                                        FlValueEq(select_to_beginning)),
                             ::testing::_, ::testing::_, ::testing::_));

  send_key_event(plugin, GDK_KEY_Home, GDK_SHIFT_MASK);
}

TEST(FlTextInputPluginTest, Composing) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  g_signal_emit_by_name(context, "preedit-start", nullptr);

  // update
  EXPECT_CALL(context,
              gtk_im_context_get_preedit_string(
                  ::testing::Eq<GtkIMContext*>(context),
                  ::testing::A<gchar**>(), ::testing::_, ::testing::A<gint*>()))
      .WillOnce(
          ::testing::DoAll(::testing::SetArgPointee<1>(g_strdup("Flutter")),
                           ::testing::SetArgPointee<3>(0)));

  g_autoptr(FlValue) state = 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,
      }),
  });

  EXPECT_CALL(messenger, fl_binary_messenger_send_on_channel(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::StrEq("flutter/textinput"),
                             MethodCall("TextInputClient.updateEditingState",
                                        FlValueEq(state)),
                             ::testing::_, ::testing::_, ::testing::_));

  g_signal_emit_by_name(context, "preedit-changed", nullptr);

  // commit
  g_autoptr(FlValue) commit = build_list({
      fl_value_new_int(-1),  // client_id
      build_editing_state({
          .text = "engine",
          .selection_base = 6,
          .selection_extent = 6,
      }),
  });

  EXPECT_CALL(messenger, fl_binary_messenger_send_on_channel(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::StrEq("flutter/textinput"),
                             MethodCall("TextInputClient.updateEditingState",
                                        FlValueEq(commit)),
                             ::testing::_, ::testing::_, ::testing::_));

  g_signal_emit_by_name(context, "commit", "engine", nullptr);

  // end
  EXPECT_CALL(messenger, fl_binary_messenger_send_on_channel(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::StrEq("flutter/textinput"),
                             MethodCall("TextInputClient.updateEditingState",
                                        ::testing::_),
                             ::testing::_, ::testing::_, ::testing::_));

  g_signal_emit_by_name(context, "preedit-end", nullptr);
}

TEST(FlTextInputPluginTest, SurroundingText) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  // set input config
  g_autoptr(FlValue) config = build_input_config({.client_id = 1});
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(GBytes) set_client = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setClient", config, nullptr);

  g_autoptr(FlValue) null = fl_value_new_null();
  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", set_client);

  // set editing state
  g_autoptr(FlValue) state = build_editing_state({
      .text = "Flutter",
      .selection_base = 3,
      .selection_extent = 3,
  });
  g_autoptr(GBytes) set_state = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setEditingState", state, nullptr);

  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", set_state);

  // retrieve
  EXPECT_CALL(context, gtk_im_context_set_surrounding(
                           ::testing::Eq<GtkIMContext*>(context),
                           ::testing::StrEq("Flutter"), 7, 3));

  gboolean retrieved = false;
  g_signal_emit_by_name(context, "retrieve-surrounding", &retrieved, nullptr);
  EXPECT_TRUE(retrieved);

  // delete
  g_autoptr(FlValue) update = build_list({
      fl_value_new_int(1),  // client_id
      build_editing_state({
          .text = "Flutr",
          .selection_base = 3,
          .selection_extent = 3,
      }),
  });

  EXPECT_CALL(messenger, fl_binary_messenger_send_on_channel(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::StrEq("flutter/textinput"),
                             MethodCall("TextInputClient.updateEditingState",
                                        FlValueEq(update)),
                             ::testing::_, ::testing::_, ::testing::_));

  gboolean deleted = false;
  g_signal_emit_by_name(context, "delete-surrounding", 1, 2, &deleted, nullptr);
  EXPECT_TRUE(deleted);
}

TEST(FlTextInputPluginTest, SetMarkedTextRect) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  g_signal_emit_by_name(context, "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),
          }),
      },
  });
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(GBytes) set_editable_size_and_transform =
      fl_method_codec_encode_method_call(
          FL_METHOD_CODEC(codec), "TextInput.setEditableSizeAndTransform",
          size_and_transform, nullptr);

  g_autoptr(FlValue) null = fl_value_new_null();
  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput",
                           set_editable_size_and_transform);

  // 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)},
  });
  g_autoptr(GBytes) set_marked_text_rect = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setMarkedTextRect", rect, nullptr);

  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  EXPECT_CALL(delegate, fl_text_input_view_delegate_translate_coordinates(
                            ::testing::Eq<FlTextInputViewDelegate*>(delegate),
                            ::testing::Eq(27), ::testing::Eq(32), ::testing::_,
                            ::testing::_))
      .WillOnce(::testing::DoAll(::testing::SetArgPointee<3>(123),
                                 ::testing::SetArgPointee<4>(456)));

  EXPECT_CALL(context, gtk_im_context_set_cursor_location(
                           ::testing::Eq<GtkIMContext*>(context),
                           ::testing::Pointee(::testing::AllOf(
                               ::testing::Field(&GdkRectangle::x, 123),
                               ::testing::Field(&GdkRectangle::y, 456),
                               ::testing::Field(&GdkRectangle::width, 0),
                               ::testing::Field(&GdkRectangle::height, 0)))));

  messenger.ReceiveMessage("flutter/textinput", set_marked_text_rect);
}

TEST(FlTextInputPluginTest, TextInputTypeNone) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  g_autoptr(FlValue) args = build_input_config({
      .client_id = 1,
      .input_type = "TextInputType.none",
  });
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(GBytes) set_client = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setClient", args, nullptr);

  g_autoptr(FlValue) null = fl_value_new_null();
  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::A<FlBinaryMessengerResponseHandle*>(),
                             SuccessResponse(null), ::testing::A<GError**>()))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", set_client);

  EXPECT_CALL(context,
              gtk_im_context_focus_in(::testing::Eq<GtkIMContext*>(context)))
      .Times(0);
  EXPECT_CALL(context,
              gtk_im_context_focus_out(::testing::Eq<GtkIMContext*>(context)));

  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  g_autoptr(GBytes) show = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.show", nullptr, nullptr);

  messenger.ReceiveMessage("flutter/textinput", show);
}

TEST(FlTextInputPluginTest, TextEditingDelta) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  // set config
  g_autoptr(FlValue) args = build_input_config({
      .client_id = 1,
      .enable_delta_model = true,
  });
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(GBytes) set_client = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setClient", args, nullptr);

  g_autoptr(FlValue) null = fl_value_new_null();
  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::A<FlBinaryMessengerResponseHandle*>(),
                             SuccessResponse(null), ::testing::A<GError**>()))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", set_client);

  // set editing state
  g_autoptr(FlValue) state = build_editing_state({
      .text = "Flutter",
      .selection_base = 7,
      .selection_extent = 7,
  });
  g_autoptr(GBytes) set_state = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setEditingState", state, nullptr);

  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::_, SuccessResponse(null), ::testing::_))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", set_state);

  // update editing state with deltas
  g_autoptr(FlValue) deltas = 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,
              }),
          }),
      }}),
  });

  EXPECT_CALL(messenger,
              fl_binary_messenger_send_on_channel(
                  ::testing::Eq<FlBinaryMessenger*>(messenger),
                  ::testing::StrEq("flutter/textinput"),
                  MethodCall("TextInputClient.updateEditingStateWithDeltas",
                             FlValueEq(deltas)),
                  ::testing::_, ::testing::_, ::testing::_));

  send_key_event(plugin, GDK_KEY_Home);
}

TEST(FlTextInputPluginTest, ComposingDelta) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  // set config
  g_autoptr(FlValue) args = build_input_config({
      .client_id = 1,
      .enable_delta_model = true,
  });
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(GBytes) set_client = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setClient", args, nullptr);

  g_autoptr(FlValue) null = fl_value_new_null();
  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::A<FlBinaryMessengerResponseHandle*>(),
                             SuccessResponse(null), ::testing::A<GError**>()))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", set_client);

  g_signal_emit_by_name(context, "preedit-start", nullptr);

  // update
  EXPECT_CALL(context,
              gtk_im_context_get_preedit_string(
                  ::testing::Eq<GtkIMContext*>(context),
                  ::testing::A<gchar**>(), ::testing::_, ::testing::A<gint*>()))
      .WillOnce(
          ::testing::DoAll(::testing::SetArgPointee<1>(g_strdup("Flutter ")),
                           ::testing::SetArgPointee<3>(8)));

  g_autoptr(FlValue) update = 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,
              }),
          }),
      }}),
  });

  EXPECT_CALL(messenger,
              fl_binary_messenger_send_on_channel(
                  ::testing::Eq<FlBinaryMessenger*>(messenger),
                  ::testing::StrEq("flutter/textinput"),
                  MethodCall("TextInputClient.updateEditingStateWithDeltas",
                             FlValueEq(update)),
                  ::testing::_, ::testing::_, ::testing::_));

  g_signal_emit_by_name(context, "preedit-changed", nullptr);

  // commit
  g_autoptr(FlValue) commit = 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,
              }),
          }),
      }}),
  });

  EXPECT_CALL(messenger,
              fl_binary_messenger_send_on_channel(
                  ::testing::Eq<FlBinaryMessenger*>(messenger),
                  ::testing::StrEq("flutter/textinput"),
                  MethodCall("TextInputClient.updateEditingStateWithDeltas",
                             FlValueEq(commit)),
                  ::testing::_, ::testing::_, ::testing::_));

  g_signal_emit_by_name(context, "commit", "Flutter engine", nullptr);

  // end
  g_autoptr(FlValue) end = 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,
              }),
          }),
      }}),
  });

  EXPECT_CALL(messenger,
              fl_binary_messenger_send_on_channel(
                  ::testing::Eq<FlBinaryMessenger*>(messenger),
                  ::testing::StrEq("flutter/textinput"),
                  MethodCall("TextInputClient.updateEditingStateWithDeltas",
                             FlValueEq(end)),
                  ::testing::_, ::testing::_, ::testing::_));

  g_signal_emit_by_name(context, "preedit-end", nullptr);
}

TEST(FlTextInputPluginTest, NonComposingDelta) {
  ::testing::NiceMock<flutter::testing::MockBinaryMessenger> messenger;
  ::testing::NiceMock<flutter::testing::MockIMContext> context;
  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;

  g_autoptr(FlTextInputPlugin) plugin =
      fl_text_input_plugin_new(messenger, context, delegate);
  EXPECT_NE(plugin, nullptr);

  // set config
  g_autoptr(FlValue) args = build_input_config({
      .client_id = 1,
      .enable_delta_model = true,
  });
  g_autoptr(FlJsonMethodCodec) codec = fl_json_method_codec_new();
  g_autoptr(GBytes) set_client = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), "TextInput.setClient", args, nullptr);

  g_autoptr(FlValue) null = fl_value_new_null();
  EXPECT_CALL(messenger, fl_binary_messenger_send_response(
                             ::testing::Eq<FlBinaryMessenger*>(messenger),
                             ::testing::A<FlBinaryMessengerResponseHandle*>(),
                             SuccessResponse(null), ::testing::A<GError**>()))
      .WillOnce(::testing::Return(true));

  messenger.ReceiveMessage("flutter/textinput", set_client);

  // commit F
  g_autoptr(FlValue) commit = 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,
              }),
          }),
      }}),
  });

  EXPECT_CALL(messenger,
              fl_binary_messenger_send_on_channel(
                  ::testing::Eq<FlBinaryMessenger*>(messenger),
                  ::testing::StrEq("flutter/textinput"),
                  MethodCall("TextInputClient.updateEditingStateWithDeltas",
                             FlValueEq(commit)),
                  ::testing::_, ::testing::_, ::testing::_));

  g_signal_emit_by_name(context, "commit", "F", nullptr);

  // commit l
  g_autoptr(FlValue) commitL = 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,
              }),
          }),
      }}),
  });

  EXPECT_CALL(messenger,
              fl_binary_messenger_send_on_channel(
                  ::testing::Eq<FlBinaryMessenger*>(messenger),
                  ::testing::StrEq("flutter/textinput"),
                  MethodCall("TextInputClient.updateEditingStateWithDeltas",
                             FlValueEq(commitL)),
                  ::testing::_, ::testing::_, ::testing::_));

  g_signal_emit_by_name(context, "commit", "l", nullptr);

  // commit u
  g_autoptr(FlValue) commitU = 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,
              }),
          }),
      }}),
  });

  EXPECT_CALL(messenger,
              fl_binary_messenger_send_on_channel(
                  ::testing::Eq<FlBinaryMessenger*>(messenger),
                  ::testing::StrEq("flutter/textinput"),
                  MethodCall("TextInputClient.updateEditingStateWithDeltas",
                             FlValueEq(commitU)),
                  ::testing::_, ::testing::_, ::testing::_));

  g_signal_emit_by_name(context, "commit", "u", nullptr);

  // commit t
  g_autoptr(FlValue) commitTa = 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,
              }),
          }),
      }}),
  });

  EXPECT_CALL(messenger,
              fl_binary_messenger_send_on_channel(
                  ::testing::Eq<FlBinaryMessenger*>(messenger),
                  ::testing::StrEq("flutter/textinput"),
                  MethodCall("TextInputClient.updateEditingStateWithDeltas",
                             FlValueEq(commitTa)),
                  ::testing::_, ::testing::_, ::testing::_));

  g_signal_emit_by_name(context, "commit", "t", nullptr);

  // commit t again
  g_autoptr(FlValue) commitTb = 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,
              }),
          }),
      }}),
  });

  EXPECT_CALL(messenger,
              fl_binary_messenger_send_on_channel(
                  ::testing::Eq<FlBinaryMessenger*>(messenger),
                  ::testing::StrEq("flutter/textinput"),
                  MethodCall("TextInputClient.updateEditingStateWithDeltas",
                             FlValueEq(commitTb)),
                  ::testing::_, ::testing::_, ::testing::_));

  g_signal_emit_by_name(context, "commit", "t", nullptr);

  // commit e
  g_autoptr(FlValue) commitE = 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,
              }),
          }),
      }}),
  });

  EXPECT_CALL(messenger,
              fl_binary_messenger_send_on_channel(
                  ::testing::Eq<FlBinaryMessenger*>(messenger),
                  ::testing::StrEq("flutter/textinput"),
                  MethodCall("TextInputClient.updateEditingStateWithDeltas",
                             FlValueEq(commitE)),
                  ::testing::_, ::testing::_, ::testing::_));

  g_signal_emit_by_name(context, "commit", "e", nullptr);

  // commit r
  g_autoptr(FlValue) commitR = 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,
              }),
          }),
      }}),
  });

  EXPECT_CALL(messenger,
              fl_binary_messenger_send_on_channel(
                  ::testing::Eq<FlBinaryMessenger*>(messenger),
                  ::testing::StrEq("flutter/textinput"),
                  MethodCall("TextInputClient.updateEditingStateWithDeltas",
                             FlValueEq(commitR)),
                  ::testing::_, ::testing::_, ::testing::_));

  g_signal_emit_by_name(context, "commit", "r", nullptr);
}