Flutter Linux Embedder
Classes | Functions
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_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"

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 86 of file fl_text_input_handler_test.cc.

86  {
87  return build_map({
88  {"oldText", fl_value_new_string(delta.old_text)},
89  {"deltaText", fl_value_new_string(delta.delta_text)},
90  {"deltaStart", fl_value_new_int(delta.delta_start)},
91  {"deltaEnd", fl_value_new_int(delta.delta_end)},
92  {"selectionBase", fl_value_new_int(delta.selection_base)},
93  {"selectionExtent", fl_value_new_int(delta.selection_extent)},
94  {"selectionAffinity", fl_value_new_string("TextAffinity.downstream")},
95  {"selectionIsDirectional", fl_value_new_bool(false)},
96  {"composingBase", fl_value_new_int(delta.composing_base)},
97  {"composingExtent", fl_value_new_int(delta.composing_extent)},
98  });
99 }

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().

◆ build_editing_state()

static FlValue* build_editing_state ( EditingState  state)
static

Definition at line 63 of file fl_text_input_handler_test.cc.

63  {
64  return build_map({
65  {"text", fl_value_new_string(state.text)},
66  {"selectionBase", fl_value_new_int(state.selection_base)},
67  {"selectionExtent", fl_value_new_int(state.selection_extent)},
68  {"selectionAffinity", fl_value_new_string("TextAffinity.downstream")},
69  {"selectionIsDirectional", fl_value_new_bool(false)},
70  {"composingBase", fl_value_new_int(state.composing_base)},
71  {"composingExtent", fl_value_new_int(state.composing_extent)},
72  });
73 }

References build_map(), fl_value_new_bool(), fl_value_new_int(), fl_value_new_string(), and state.

Referenced by set_editing_state(), and TEST().

◆ build_input_config()

static FlValue* build_input_config ( InputConfig  config)
static

Definition at line 42 of file fl_text_input_handler_test.cc.

42  {
43  return build_list({
44  fl_value_new_int(config.client_id),
45  build_map({
46  {"inputAction", fl_value_new_string(config.input_action)},
47  {"inputType", build_map({
48  {"name", fl_value_new_string(config.input_type)},
49  })},
50  {"enableDeltaModel", fl_value_new_bool(config.enable_delta_model)},
51  }),
52  });
53 }

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 27 of file fl_text_input_handler_test.cc.

27  {
28  FlValue* value = fl_value_new_list();
29  for (auto it = args.begin(); it != args.end(); ++it) {
30  fl_value_append_take(value, *it);
31  }
32  return value;
33 }

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

Referenced by build_input_config(), and TEST().

◆ build_map()

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

Definition at line 19 of file fl_text_input_handler_test.cc.

19  {
20  FlValue* value = fl_value_new_map();
21  for (auto it = args.begin(); it != args.end(); ++it) {
22  fl_value_set_string_take(value, it->first, it->second);
23  }
24  return value;
25 }

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

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

◆ send_key_event()

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

Definition at line 144 of file fl_text_input_handler_test.cc.

146  {
147  GdkEvent* gdk_event = gdk_event_new(GDK_KEY_PRESS);
148  gdk_event->key.keyval = keyval;
149  gdk_event->key.state = state;
150  g_autoptr(FlKeyEvent) key_event = fl_key_event_new_from_gdk_event(gdk_event);
151  fl_text_input_handler_filter_keypress(handler, key_event);
152 }

References fl_key_event_new_from_gdk_event(), fl_text_input_handler_filter_keypress(), and state.

Referenced by fl_key_embedder_responder_new(), and TEST().

◆ set_client()

static void set_client ( FlMockBinaryMessenger *  messenger,
InputConfig  config 
)
static

Definition at line 101 of file fl_text_input_handler_test.cc.

101  {
102  gboolean called = FALSE;
103  g_autoptr(FlValue) args = build_input_config(config);
104  fl_mock_binary_messenger_invoke_json_method(
105  messenger, "flutter/textinput", "TextInput.setClient", args,
106  [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
107  gpointer user_data) {
108  gboolean* called = static_cast<gboolean*>(user_data);
109  *called = TRUE;
110 
111  EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
112 
113  g_autoptr(FlValue) expected_result = fl_value_new_null();
114  EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
115  FL_METHOD_SUCCESS_RESPONSE(response)),
116  expected_result));
117  },
118  &called);
119  EXPECT_TRUE(called);
120 }

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

Referenced by TEST().

◆ set_editing_state()

static void set_editing_state ( FlMockBinaryMessenger *  messenger,
EditingState  state 
)
static

Definition at line 122 of file fl_text_input_handler_test.cc.

123  {
124  gboolean called = FALSE;
125  g_autoptr(FlValue) args = build_editing_state(state);
126  fl_mock_binary_messenger_invoke_json_method(
127  messenger, "flutter/textinput", "TextInput.setEditingState", args,
128  [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
129  gpointer user_data) {
130  gboolean* called = static_cast<gboolean*>(user_data);
131  *called = TRUE;
132 
133  EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
134 
135  g_autoptr(FlValue) expected_result = fl_value_new_null();
136  EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
137  FL_METHOD_SUCCESS_RESPONSE(response)),
138  expected_result));
139  },
140  &called);
141  EXPECT_TRUE(called);
142 }

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

Referenced by TEST().

◆ TEST() [1/16]

TEST ( FlTextInputHandlerTest  ,
ClearClient   
)

Definition at line 249 of file fl_text_input_handler_test.cc.

249  {
250  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
251  ::testing::NiceMock<flutter::testing::MockIMContext> context;
252  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
253 
254  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
255  FL_BINARY_MESSENGER(messenger), context, delegate);
256  EXPECT_NE(handler, nullptr);
257 
258  gboolean called = FALSE;
259  fl_mock_binary_messenger_invoke_json_method(
260  messenger, "flutter/textinput", "TextInput.clearClient", nullptr,
261  [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
262  gpointer user_data) {
263  gboolean* called = static_cast<gboolean*>(user_data);
264  *called = TRUE;
265 
266  EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
267 
268  g_autoptr(FlValue) expected_result = fl_value_new_null();
269  EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
270  FL_METHOD_SUCCESS_RESPONSE(response)),
271  expected_result));
272  },
273  &called);
274  EXPECT_TRUE(called);
275 
276  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
277 }

References fl_binary_messenger_shutdown(), fl_method_success_response_get_result(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_null(), TRUE, and user_data.

◆ TEST() [2/16]

TEST ( FlTextInputHandlerTest  ,
Composing   
)

Definition at line 531 of file fl_text_input_handler_test.cc.

531  {
532  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
533  ::testing::NiceMock<flutter::testing::MockIMContext> context;
534  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
535 
536  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
537  FL_BINARY_MESSENGER(messenger), context, delegate);
538  EXPECT_NE(handler, nullptr);
539 
540  // update
541  EXPECT_CALL(context,
542  gtk_im_context_get_preedit_string(
543  ::testing::Eq<GtkIMContext*>(context),
544  ::testing::A<gchar**>(), ::testing::_, ::testing::A<gint*>()))
545  .WillOnce(
546  ::testing::DoAll(::testing::SetArgPointee<1>(g_strdup("Flutter")),
547  ::testing::SetArgPointee<3>(0)));
548 
549  int call_count = 0;
550  fl_mock_binary_messenger_set_json_method_channel(
551  messenger, "flutter/textinput",
552  [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
553  FlValue* args, gpointer user_data) {
554  int* call_count = static_cast<int*>(user_data);
555 
556  EXPECT_STREQ(name, "TextInputClient.updateEditingState");
557  g_autoptr(FlValue) expected_args = nullptr;
558  switch (*call_count) {
559  case 0:
560  expected_args = build_list({
561  fl_value_new_int(-1), // client_id
562  build_editing_state({
563  .text = "Flutter",
564  .selection_base = 0,
565  .selection_extent = 0,
566  .composing_base = 0,
567  .composing_extent = 7,
568  }),
569  });
570  break;
571  case 1:
572  // commit
573  expected_args = build_list({
574  fl_value_new_int(-1), // client_id
575  build_editing_state({
576  .text = "engine",
577  .selection_base = 6,
578  .selection_extent = 6,
579  }),
580  });
581  break;
582  case 2:
583  // end
584  expected_args = build_list({
585  fl_value_new_int(-1), // client_id
586  build_editing_state({
587  .text = "engine",
588  .selection_base = 6,
589  .selection_extent = 6,
590  }),
591  });
592  break;
593  default:
594  g_assert_not_reached();
595  break;
596  }
597  EXPECT_TRUE(fl_value_equal(args, expected_args));
598  (*call_count)++;
599 
600  return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
601  },
602  &call_count);
603 
604  g_signal_emit_by_name(context, "preedit-start", nullptr);
605  g_signal_emit_by_name(context, "preedit-changed", nullptr);
606  g_signal_emit_by_name(context, "commit", "engine", nullptr);
607  g_signal_emit_by_name(context, "preedit-end", nullptr);
608  EXPECT_EQ(call_count, 3);
609 
610  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
611 }

References args, build_editing_state(), build_list(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), and user_data.

◆ TEST() [3/16]

TEST ( FlTextInputHandlerTest  ,
ComposingDelta   
)

Definition at line 881 of file fl_text_input_handler_test.cc.

881  {
882  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
883  ::testing::NiceMock<flutter::testing::MockIMContext> context;
884  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
885 
886  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
887  FL_BINARY_MESSENGER(messenger), context, delegate);
888  EXPECT_NE(handler, nullptr);
889 
890  // set config
891  set_client(messenger, {
892  .client_id = 1,
893  .enable_delta_model = true,
894  });
895 
896  g_signal_emit_by_name(context, "preedit-start", nullptr);
897 
898  // update
899  EXPECT_CALL(context,
900  gtk_im_context_get_preedit_string(
901  ::testing::Eq<GtkIMContext*>(context),
902  ::testing::A<gchar**>(), ::testing::_, ::testing::A<gint*>()))
903  .WillOnce(
904  ::testing::DoAll(::testing::SetArgPointee<1>(g_strdup("Flutter ")),
905  ::testing::SetArgPointee<3>(8)));
906 
907  int call_count = 0;
908  fl_mock_binary_messenger_set_json_method_channel(
909  messenger, "flutter/textinput",
910  [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
911  FlValue* args, gpointer user_data) {
912  int* call_count = static_cast<int*>(user_data);
913 
914  EXPECT_STREQ(name, "TextInputClient.updateEditingStateWithDeltas");
915  g_autoptr(FlValue) expected_args = nullptr;
916  switch (*call_count) {
917  case 0:
918  expected_args = build_list({
919  fl_value_new_int(1), // client_id
920  build_map({{
921  "deltas",
922  build_list({
923  build_editing_delta({
924  .old_text = "",
925  .delta_text = "Flutter ",
926  .delta_start = 0,
927  .delta_end = 0,
928  .selection_base = 8,
929  .selection_extent = 8,
930  .composing_base = 0,
931  .composing_extent = 8,
932  }),
933  }),
934  }}),
935  });
936  break;
937  case 1:
938  // commit
939  expected_args = build_list({
940  fl_value_new_int(1), // client_id
941  build_map({{
942  "deltas",
943  build_list({
944  build_editing_delta({
945  .old_text = "Flutter ",
946  .delta_text = "Flutter engine",
947  .delta_start = 0,
948  .delta_end = 8,
949  .selection_base = 14,
950  .selection_extent = 14,
951  .composing_base = -1,
952  .composing_extent = -1,
953  }),
954  }),
955  }}),
956  });
957  break;
958  case 2:
959  // end
960  expected_args = build_list({
961  fl_value_new_int(1), // client_id
962  build_map({{
963  "deltas",
964  build_list({
965  build_editing_delta({
966  .old_text = "Flutter engine",
967  .selection_base = 14,
968  .selection_extent = 14,
969  }),
970  }),
971  }}),
972  });
973  break;
974  default:
975  g_assert_not_reached();
976  break;
977  }
978  EXPECT_TRUE(fl_value_equal(args, expected_args));
979  (*call_count)++;
980 
981  return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
982  },
983  &call_count);
984 
985  g_signal_emit_by_name(context, "preedit-changed", nullptr);
986  g_signal_emit_by_name(context, "commit", "Flutter engine", nullptr);
987  g_signal_emit_by_name(context, "preedit-end", nullptr);
988  EXPECT_EQ(call_count, 3);
989 
990  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
991 }

References args, build_editing_delta(), build_list(), build_map(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), set_client(), and user_data.

◆ TEST() [4/16]

TEST ( FlTextInputHandlerTest  ,
Hide   
)

Definition at line 216 of file fl_text_input_handler_test.cc.

216  {
217  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
218  ::testing::NiceMock<flutter::testing::MockIMContext> context;
219  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
220 
221  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
222  FL_BINARY_MESSENGER(messenger), context, delegate);
223  EXPECT_NE(handler, nullptr);
224 
225  EXPECT_CALL(context,
226  gtk_im_context_focus_out(::testing::Eq<GtkIMContext*>(context)));
227 
228  gboolean called = FALSE;
229  fl_mock_binary_messenger_invoke_json_method(
230  messenger, "flutter/textinput", "TextInput.hide", nullptr,
231  [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
232  gpointer user_data) {
233  gboolean* called = static_cast<gboolean*>(user_data);
234  *called = TRUE;
235 
236  EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
237 
238  g_autoptr(FlValue) expected_result = fl_value_new_null();
239  EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
240  FL_METHOD_SUCCESS_RESPONSE(response)),
241  expected_result));
242  },
243  &called);
244  EXPECT_TRUE(called);
245 
246  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
247 }

References fl_binary_messenger_shutdown(), fl_method_success_response_get_result(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_null(), TRUE, and user_data.

◆ TEST() [5/16]

TEST ( FlTextInputHandlerTest  ,
MessageHandler   
)

Definition at line 154 of file fl_text_input_handler_test.cc.

154  {
155  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
156  ::testing::NiceMock<flutter::testing::MockIMContext> context;
157  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
158 
159  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
160  FL_BINARY_MESSENGER(messenger), context, delegate);
161  EXPECT_NE(handler, nullptr);
162 
163  EXPECT_TRUE(
164  fl_mock_binary_messenger_has_handler(messenger, "flutter/textinput"));
165 
166  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
167 }

References fl_binary_messenger_shutdown(), and fl_text_input_handler_new().

◆ TEST() [6/16]

TEST ( FlTextInputHandlerTest  ,
MoveCursor   
)

Definition at line 399 of file fl_text_input_handler_test.cc.

399  {
400  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
401  ::testing::NiceMock<flutter::testing::MockIMContext> context;
402  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
403 
404  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
405  FL_BINARY_MESSENGER(messenger), context, delegate);
406  EXPECT_NE(handler, nullptr);
407 
408  set_client(messenger, {.client_id = 1});
409  set_editing_state(messenger, {
410  .text = "Flutter",
411  .selection_base = 4,
412  .selection_extent = 4,
413  });
414 
415  int call_count = 0;
416  fl_mock_binary_messenger_set_json_method_channel(
417  messenger, "flutter/textinput",
418  [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
419  FlValue* args, gpointer user_data) {
420  int* call_count = static_cast<int*>(user_data);
421 
422  EXPECT_STREQ(name, "TextInputClient.updateEditingState");
423  g_autoptr(FlValue) expected_args = nullptr;
424  switch (*call_count) {
425  case 0:
426  // move cursor to beginning
427  expected_args = build_list({
428  fl_value_new_int(1), // client_id
429  build_editing_state({
430  .text = "Flutter",
431  .selection_base = 0,
432  .selection_extent = 0,
433  }),
434  });
435  break;
436  case 1:
437  // move cursor to end
438  expected_args = build_list({
439  fl_value_new_int(1), // client_id
440  build_editing_state({
441  .text = "Flutter",
442  .selection_base = 7,
443  .selection_extent = 7,
444  }),
445  });
446  break;
447  default:
448  g_assert_not_reached();
449  break;
450  }
451  EXPECT_TRUE(fl_value_equal(args, expected_args));
452  (*call_count)++;
453 
454  return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
455  },
456  &call_count);
457 
458  send_key_event(handler, GDK_KEY_Home);
459  send_key_event(handler, GDK_KEY_End);
460  EXPECT_EQ(call_count, 2);
461 
462  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
463 }

References args, build_editing_state(), build_list(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), send_key_event(), set_client(), set_editing_state(), and user_data.

◆ TEST() [7/16]

TEST ( FlTextInputHandlerTest  ,
MultilineWithSendAction   
)

Definition at line 340 of file fl_text_input_handler_test.cc.

340  {
341  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
342  ::testing::NiceMock<flutter::testing::MockIMContext> context;
343  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
344 
345  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
346  FL_BINARY_MESSENGER(messenger), context, delegate);
347  EXPECT_NE(handler, nullptr);
348 
349  set_client(messenger, {
350  .client_id = 1,
351  .input_type = "TextInputType.multiline",
352  .input_action = "TextInputAction.send",
353  });
354  set_editing_state(messenger, {
355  .text = "Flutter",
356  .selection_base = 7,
357  .selection_extent = 7,
358  });
359 
360  // Because the input action is not set to TextInputAction.newline, the next
361  // expected call is "TextInputClient.performAction". If the input action was
362  // set to TextInputAction.newline the next call would be
363  // "TextInputClient.updateEditingState" (this case is tested in the test named
364  // 'PerformAction').
365  int call_count = 0;
366  fl_mock_binary_messenger_set_json_method_channel(
367  messenger, "flutter/textinput",
368  [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
369  FlValue* args, gpointer user_data) {
370  int* call_count = static_cast<int*>(user_data);
371 
372  EXPECT_STREQ(name, "TextInputClient.performAction");
373  g_autoptr(FlValue) expected_args = nullptr;
374  switch (*call_count) {
375  case 0:
376  // Perform action.
377  expected_args = build_list({
378  fl_value_new_int(1), // client_id
379  fl_value_new_string("TextInputAction.send"),
380  });
381  break;
382  default:
383  g_assert_not_reached();
384  break;
385  }
386  EXPECT_TRUE(fl_value_equal(args, expected_args));
387  (*call_count)++;
388 
389  return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
390  },
391  &call_count);
392 
393  send_key_event(handler, GDK_KEY_Return);
394  EXPECT_EQ(call_count, 1);
395 
396  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
397 }

References args, build_list(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), fl_value_new_string(), send_key_event(), set_client(), set_editing_state(), and user_data.

◆ TEST() [8/16]

TEST ( FlTextInputHandlerTest  ,
NonComposingDelta   
)

Definition at line 993 of file fl_text_input_handler_test.cc.

993  {
994  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
995  ::testing::NiceMock<flutter::testing::MockIMContext> context;
996  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
997 
998  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
999  FL_BINARY_MESSENGER(messenger), context, delegate);
1000  EXPECT_NE(handler, nullptr);
1001 
1002  // set config
1003  set_client(messenger, {
1004  .client_id = 1,
1005  .enable_delta_model = true,
1006  });
1007 
1008  int call_count = 0;
1009  fl_mock_binary_messenger_set_json_method_channel(
1010  messenger, "flutter/textinput",
1011  [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
1012  FlValue* args, gpointer user_data) {
1013  int* call_count = static_cast<int*>(user_data);
1014 
1015  EXPECT_STREQ(name, "TextInputClient.updateEditingStateWithDeltas");
1016  g_autoptr(FlValue) expected_args = nullptr;
1017  switch (*call_count) {
1018  case 0:
1019  // commit F
1020  expected_args = build_list({
1021  fl_value_new_int(1), // client_id
1022  build_map({{
1023  "deltas",
1024  build_list({
1025  build_editing_delta({
1026  .old_text = "",
1027  .delta_text = "F",
1028  .delta_start = 0,
1029  .delta_end = 0,
1030  .selection_base = 1,
1031  .selection_extent = 1,
1032  .composing_base = -1,
1033  .composing_extent = -1,
1034  }),
1035  }),
1036  }}),
1037  });
1038  break;
1039  case 1:
1040  // commit l
1041  expected_args = build_list({
1042  fl_value_new_int(1), // client_id
1043  build_map({{
1044  "deltas",
1045  build_list({
1046  build_editing_delta({
1047  .old_text = "F",
1048  .delta_text = "l",
1049  .delta_start = 1,
1050  .delta_end = 1,
1051  .selection_base = 2,
1052  .selection_extent = 2,
1053  .composing_base = -1,
1054  .composing_extent = -1,
1055  }),
1056  }),
1057  }}),
1058  });
1059  break;
1060  case 2:
1061  // commit u
1062  expected_args = build_list({
1063  fl_value_new_int(1), // client_id
1064  build_map({{
1065  "deltas",
1066  build_list({
1067  build_editing_delta({
1068  .old_text = "Fl",
1069  .delta_text = "u",
1070  .delta_start = 2,
1071  .delta_end = 2,
1072  .selection_base = 3,
1073  .selection_extent = 3,
1074  .composing_base = -1,
1075  .composing_extent = -1,
1076  }),
1077  }),
1078  }}),
1079  });
1080  break;
1081  case 3:
1082  // commit t
1083  expected_args = build_list({
1084  fl_value_new_int(1), // client_id
1085  build_map({{
1086  "deltas",
1087  build_list({
1088  build_editing_delta({
1089  .old_text = "Flu",
1090  .delta_text = "t",
1091  .delta_start = 3,
1092  .delta_end = 3,
1093  .selection_base = 4,
1094  .selection_extent = 4,
1095  .composing_base = -1,
1096  .composing_extent = -1,
1097  }),
1098  }),
1099  }}),
1100  });
1101  break;
1102  case 4:
1103  // commit t again
1104  expected_args = build_list({
1105  fl_value_new_int(1), // client_id
1106  build_map({{
1107  "deltas",
1108  build_list({
1109  build_editing_delta({
1110  .old_text = "Flut",
1111  .delta_text = "t",
1112  .delta_start = 4,
1113  .delta_end = 4,
1114  .selection_base = 5,
1115  .selection_extent = 5,
1116  .composing_base = -1,
1117  .composing_extent = -1,
1118  }),
1119  }),
1120  }}),
1121  });
1122  break;
1123  case 5:
1124  // commit e
1125  expected_args = build_list({
1126  fl_value_new_int(1), // client_id
1127  build_map({{
1128  "deltas",
1129  build_list({
1130  build_editing_delta({
1131  .old_text = "Flutt",
1132  .delta_text = "e",
1133  .delta_start = 5,
1134  .delta_end = 5,
1135  .selection_base = 6,
1136  .selection_extent = 6,
1137  .composing_base = -1,
1138  .composing_extent = -1,
1139  }),
1140  }),
1141  }}),
1142  });
1143  break;
1144  case 6:
1145  // commit r
1146  expected_args = build_list({
1147  fl_value_new_int(1), // client_id
1148  build_map({{
1149  "deltas",
1150  build_list({
1151  build_editing_delta({
1152  .old_text = "Flutte",
1153  .delta_text = "r",
1154  .delta_start = 6,
1155  .delta_end = 6,
1156  .selection_base = 7,
1157  .selection_extent = 7,
1158  .composing_base = -1,
1159  .composing_extent = -1,
1160  }),
1161  }),
1162  }}),
1163  });
1164  break;
1165  default:
1166  g_assert_not_reached();
1167  break;
1168  }
1169  EXPECT_TRUE(fl_value_equal(args, expected_args));
1170  (*call_count)++;
1171 
1172  return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
1173  },
1174  &call_count);
1175 
1176  g_signal_emit_by_name(context, "commit", "F", nullptr);
1177  g_signal_emit_by_name(context, "commit", "l", nullptr);
1178  g_signal_emit_by_name(context, "commit", "u", nullptr);
1179  g_signal_emit_by_name(context, "commit", "t", nullptr);
1180  g_signal_emit_by_name(context, "commit", "t", nullptr);
1181  g_signal_emit_by_name(context, "commit", "e", nullptr);
1182  g_signal_emit_by_name(context, "commit", "r", nullptr);
1183  EXPECT_EQ(call_count, 7);
1184 
1185  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
1186 }

References args, build_editing_delta(), build_list(), build_map(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), set_client(), and user_data.

◆ TEST() [9/16]

TEST ( FlTextInputHandlerTest  ,
PerformAction   
)

Definition at line 279 of file fl_text_input_handler_test.cc.

279  {
280  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
281  ::testing::NiceMock<flutter::testing::MockIMContext> context;
282  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
283 
284  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
285  FL_BINARY_MESSENGER(messenger), context, delegate);
286  EXPECT_NE(handler, nullptr);
287 
288  set_client(messenger, {
289  .client_id = 1,
290  .input_type = "TextInputType.multiline",
291  .input_action = "TextInputAction.newline",
292  });
293  set_editing_state(messenger, {
294  .text = "Flutter",
295  .selection_base = 7,
296  .selection_extent = 7,
297  });
298 
299  // Client will update editing state and perform action
300  int call_count = 0;
301  fl_mock_binary_messenger_set_json_method_channel(
302  messenger, "flutter/textinput",
303  [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
304  FlValue* args, gpointer user_data) {
305  int* call_count = static_cast<int*>(user_data);
306 
307  if (strcmp(name, "TextInputClient.updateEditingState") == 0) {
308  g_autoptr(FlValue) expected_args = build_list({
309  fl_value_new_int(1), // client_id
310  build_editing_state({
311  .text = "Flutter\n",
312  .selection_base = 8,
313  .selection_extent = 8,
314  }),
315  });
316  EXPECT_TRUE(fl_value_equal(args, expected_args));
317  EXPECT_EQ(*call_count, 0);
318  (*call_count)++;
319  } else if (strcmp(name, "TextInputClient.performAction") == 0) {
320  g_autoptr(FlValue) expected_args = build_list({
321  fl_value_new_int(1), // client_id
322  fl_value_new_string("TextInputAction.newline"),
323  });
324  EXPECT_TRUE(fl_value_equal(args, expected_args));
325  EXPECT_EQ(*call_count, 1);
326  (*call_count)++;
327  }
328 
329  return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
330  },
331  &call_count);
332 
333  send_key_event(handler, GDK_KEY_Return);
334  EXPECT_EQ(call_count, 2);
335 
336  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
337 }

References args, build_editing_state(), build_list(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), fl_value_new_string(), send_key_event(), set_client(), set_editing_state(), and user_data.

◆ TEST() [10/16]

TEST ( FlTextInputHandlerTest  ,
Select   
)

Definition at line 465 of file fl_text_input_handler_test.cc.

465  {
466  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
467  ::testing::NiceMock<flutter::testing::MockIMContext> context;
468  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
469 
470  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
471  FL_BINARY_MESSENGER(messenger), context, delegate);
472  EXPECT_NE(handler, nullptr);
473 
474  set_client(messenger, {.client_id = 1});
475  set_editing_state(messenger, {
476  .text = "Flutter",
477  .selection_base = 4,
478  .selection_extent = 4,
479  });
480 
481  int call_count = 0;
482  fl_mock_binary_messenger_set_json_method_channel(
483  messenger, "flutter/textinput",
484  [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
485  FlValue* args, gpointer user_data) {
486  int* call_count = static_cast<int*>(user_data);
487 
488  EXPECT_STREQ(name, "TextInputClient.updateEditingState");
489  g_autoptr(FlValue) expected_args = nullptr;
490  switch (*call_count) {
491  case 0:
492  // select to end
493  expected_args = build_list({
494  fl_value_new_int(1), // client_id
495  build_editing_state({
496  .text = "Flutter",
497  .selection_base = 4,
498  .selection_extent = 7,
499  }),
500  });
501  break;
502  case 1:
503  // select to beginning
504  expected_args = build_list({
505  fl_value_new_int(1), // client_id
506  build_editing_state({
507  .text = "Flutter",
508  .selection_base = 4,
509  .selection_extent = 0,
510  }),
511  });
512  break;
513  default:
514  g_assert_not_reached();
515  break;
516  }
517  EXPECT_TRUE(fl_value_equal(args, expected_args));
518  (*call_count)++;
519 
520  return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
521  },
522  &call_count);
523 
524  send_key_event(handler, GDK_KEY_End, GDK_SHIFT_MASK);
525  send_key_event(handler, GDK_KEY_Home, GDK_SHIFT_MASK);
526  EXPECT_EQ(call_count, 2);
527 
528  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
529 }

References args, build_editing_state(), build_list(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), send_key_event(), set_client(), set_editing_state(), and user_data.

◆ TEST() [11/16]

TEST ( FlTextInputHandlerTest  ,
SetClient   
)

Definition at line 169 of file fl_text_input_handler_test.cc.

169  {
170  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
171  ::testing::NiceMock<flutter::testing::MockIMContext> context;
172  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
173 
174  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
175  FL_BINARY_MESSENGER(messenger), context, delegate);
176  EXPECT_NE(handler, nullptr);
177 
178  set_client(messenger, {.client_id = 1});
179 
180  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
181 }

References fl_binary_messenger_shutdown(), fl_text_input_handler_new(), and set_client().

◆ TEST() [12/16]

TEST ( FlTextInputHandlerTest  ,
SetMarkedTextRect   
)

Definition at line 678 of file fl_text_input_handler_test.cc.

678  {
679  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
680  ::testing::NiceMock<flutter::testing::MockIMContext> context;
681  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
682 
683  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
684  FL_BINARY_MESSENGER(messenger), context, delegate);
685  EXPECT_NE(handler, nullptr);
686 
687  g_signal_emit_by_name(context, "preedit-start", nullptr);
688 
689  // set editable size and transform
690  g_autoptr(FlValue) size_and_transform = build_map({
691  {
692  "transform",
693  build_list({
694  fl_value_new_float(1),
695  fl_value_new_float(2),
696  fl_value_new_float(3),
697  fl_value_new_float(4),
698  fl_value_new_float(5),
699  fl_value_new_float(6),
700  fl_value_new_float(7),
701  fl_value_new_float(8),
702  fl_value_new_float(9),
703  fl_value_new_float(10),
704  fl_value_new_float(11),
705  fl_value_new_float(12),
706  fl_value_new_float(13),
707  fl_value_new_float(14),
708  fl_value_new_float(15),
709  fl_value_new_float(16),
710  }),
711  },
712  });
713  gboolean called = FALSE;
714  fl_mock_binary_messenger_invoke_json_method(
715  messenger, "flutter/textinput", "TextInput.setEditableSizeAndTransform",
716  size_and_transform,
717  [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
718  gpointer user_data) {
719  gboolean* called = static_cast<gboolean*>(user_data);
720  *called = TRUE;
721 
722  EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
723 
724  g_autoptr(FlValue) expected_result = fl_value_new_null();
725  EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
726  FL_METHOD_SUCCESS_RESPONSE(response)),
727  expected_result));
728  },
729  &called);
730  EXPECT_TRUE(called);
731 
732  EXPECT_CALL(delegate, fl_text_input_view_delegate_translate_coordinates(
733  ::testing::Eq<FlTextInputViewDelegate*>(delegate),
734  ::testing::Eq(27), ::testing::Eq(32), ::testing::_,
735  ::testing::_))
736  .WillOnce(::testing::DoAll(::testing::SetArgPointee<3>(123),
737  ::testing::SetArgPointee<4>(456)));
738 
739  EXPECT_CALL(context, gtk_im_context_set_cursor_location(
740  ::testing::Eq<GtkIMContext*>(context),
741  ::testing::Pointee(::testing::AllOf(
742  ::testing::Field(&GdkRectangle::x, 123),
743  ::testing::Field(&GdkRectangle::y, 456),
744  ::testing::Field(&GdkRectangle::width, 0),
745  ::testing::Field(&GdkRectangle::height, 0)))));
746 
747  // set marked text rect
748  g_autoptr(FlValue) rect = build_map({
749  {"x", fl_value_new_float(1)},
750  {"y", fl_value_new_float(2)},
751  {"width", fl_value_new_float(3)},
752  {"height", fl_value_new_float(4)},
753  });
754  called = FALSE;
755  fl_mock_binary_messenger_invoke_json_method(
756  messenger, "flutter/textinput", "TextInput.setMarkedTextRect", rect,
757  [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
758  gpointer user_data) {
759  gboolean* called = static_cast<gboolean*>(user_data);
760  *called = TRUE;
761 
762  EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
763 
764  g_autoptr(FlValue) expected_result = fl_value_new_null();
765  EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
766  FL_METHOD_SUCCESS_RESPONSE(response)),
767  expected_result));
768  },
769  &called);
770  EXPECT_TRUE(called);
771 
772  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
773 }

References build_list(), build_map(), fl_binary_messenger_shutdown(), fl_method_success_response_get_result(), fl_text_input_handler_new(), fl_text_input_view_delegate_translate_coordinates(), fl_value_equal(), fl_value_new_float(), fl_value_new_null(), height, TRUE, user_data, and width.

◆ TEST() [13/16]

TEST ( FlTextInputHandlerTest  ,
Show   
)

Definition at line 183 of file fl_text_input_handler_test.cc.

183  {
184  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
185  ::testing::NiceMock<flutter::testing::MockIMContext> context;
186  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
187 
188  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
189  FL_BINARY_MESSENGER(messenger), context, delegate);
190  EXPECT_NE(handler, nullptr);
191 
192  EXPECT_CALL(context,
193  gtk_im_context_focus_in(::testing::Eq<GtkIMContext*>(context)));
194 
195  gboolean called = FALSE;
196  fl_mock_binary_messenger_invoke_json_method(
197  messenger, "flutter/textinput", "TextInput.show", nullptr,
198  [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
199  gpointer user_data) {
200  gboolean* called = static_cast<gboolean*>(user_data);
201  *called = TRUE;
202 
203  EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
204 
205  g_autoptr(FlValue) expected_result = fl_value_new_null();
206  EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
207  FL_METHOD_SUCCESS_RESPONSE(response)),
208  expected_result));
209  },
210  &called);
211  EXPECT_TRUE(called);
212 
213  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
214 }

References fl_binary_messenger_shutdown(), fl_method_success_response_get_result(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_null(), TRUE, and user_data.

◆ TEST() [14/16]

TEST ( FlTextInputHandlerTest  ,
SurroundingText   
)

Definition at line 613 of file fl_text_input_handler_test.cc.

613  {
614  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
615  ::testing::NiceMock<flutter::testing::MockIMContext> context;
616  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
617 
618  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
619  FL_BINARY_MESSENGER(messenger), context, delegate);
620  EXPECT_NE(handler, nullptr);
621 
622  set_client(messenger, {.client_id = 1});
623  set_editing_state(messenger, {
624  .text = "Flutter",
625  .selection_base = 3,
626  .selection_extent = 3,
627  });
628 
629  // retrieve
630  EXPECT_CALL(context, gtk_im_context_set_surrounding(
631  ::testing::Eq<GtkIMContext*>(context),
632  ::testing::StrEq("Flutter"), 7, 3));
633 
634  gboolean retrieved = false;
635  g_signal_emit_by_name(context, "retrieve-surrounding", &retrieved, nullptr);
636  EXPECT_TRUE(retrieved);
637 
638  int call_count = 0;
639  fl_mock_binary_messenger_set_json_method_channel(
640  messenger, "flutter/textinput",
641  [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
642  FlValue* args, gpointer user_data) {
643  int* call_count = static_cast<int*>(user_data);
644 
645  EXPECT_STREQ(name, "TextInputClient.updateEditingState");
646  g_autoptr(FlValue) expected_args = nullptr;
647  switch (*call_count) {
648  case 0:
649  // delete
650  expected_args = build_list({
651  fl_value_new_int(1), // client_id
652  build_editing_state({
653  .text = "Flutr",
654  .selection_base = 3,
655  .selection_extent = 3,
656  }),
657  });
658  break;
659  default:
660  g_assert_not_reached();
661  break;
662  }
663  EXPECT_TRUE(fl_value_equal(args, expected_args));
664  (*call_count)++;
665 
666  return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
667  },
668  &call_count);
669 
670  gboolean deleted = false;
671  g_signal_emit_by_name(context, "delete-surrounding", 1, 2, &deleted, nullptr);
672  EXPECT_TRUE(deleted);
673  EXPECT_EQ(call_count, 1);
674 
675  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
676 }

References args, build_editing_state(), build_list(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), set_client(), set_editing_state(), and user_data.

◆ TEST() [15/16]

TEST ( FlTextInputHandlerTest  ,
TextEditingDelta   
)

Definition at line 816 of file fl_text_input_handler_test.cc.

816  {
817  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
818  ::testing::NiceMock<flutter::testing::MockIMContext> context;
819  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
820 
821  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
822  FL_BINARY_MESSENGER(messenger), context, delegate);
823  EXPECT_NE(handler, nullptr);
824 
825  set_client(messenger, {
826  .client_id = 1,
827  .enable_delta_model = true,
828  });
829  set_editing_state(messenger, {
830  .text = "Flutter",
831  .selection_base = 7,
832  .selection_extent = 7,
833  });
834 
835  // update editing state with deltas
836  int call_count = 0;
837  fl_mock_binary_messenger_set_json_method_channel(
838  messenger, "flutter/textinput",
839  [](FlMockBinaryMessenger* messenger, GTask* task, const gchar* name,
840  FlValue* args, gpointer user_data) {
841  int* call_count = static_cast<int*>(user_data);
842 
843  EXPECT_STREQ(name, "TextInputClient.updateEditingStateWithDeltas");
844  g_autoptr(FlValue) expected_args = nullptr;
845  switch (*call_count) {
846  case 0:
847  expected_args = build_list({
848  fl_value_new_int(1), // client_id
849  build_map({{
850  "deltas",
851  build_list({
852  build_editing_delta({
853  .old_text = "Flutter",
854  .delta_text = "Flutter",
855  .delta_start = 7,
856  .delta_end = 7,
857  .selection_base = 0,
858  .selection_extent = 0,
859  }),
860  }),
861  }}),
862  });
863  break;
864  default:
865  g_assert_not_reached();
866  break;
867  }
868  EXPECT_TRUE(fl_value_equal(args, expected_args));
869  (*call_count)++;
870 
871  return FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
872  },
873  &call_count);
874 
875  send_key_event(handler, GDK_KEY_Home);
876  EXPECT_EQ(call_count, 1);
877 
878  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
879 }

References args, build_editing_delta(), build_list(), build_map(), fl_binary_messenger_shutdown(), fl_method_success_response_new(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_int(), send_key_event(), set_client(), set_editing_state(), and user_data.

◆ TEST() [16/16]

TEST ( FlTextInputHandlerTest  ,
TextInputTypeNone   
)

Definition at line 775 of file fl_text_input_handler_test.cc.

775  {
776  g_autoptr(FlMockBinaryMessenger) messenger = fl_mock_binary_messenger_new();
777  ::testing::NiceMock<flutter::testing::MockIMContext> context;
778  ::testing::NiceMock<flutter::testing::MockTextInputViewDelegate> delegate;
779 
780  g_autoptr(FlTextInputHandler) handler = fl_text_input_handler_new(
781  FL_BINARY_MESSENGER(messenger), context, delegate);
782  EXPECT_NE(handler, nullptr);
783 
784  set_client(messenger, {
785  .client_id = 1,
786  .input_type = "TextInputType.none",
787  });
788 
789  EXPECT_CALL(context,
790  gtk_im_context_focus_in(::testing::Eq<GtkIMContext*>(context)))
791  .Times(0);
792  EXPECT_CALL(context,
793  gtk_im_context_focus_out(::testing::Eq<GtkIMContext*>(context)));
794 
795  gboolean called = FALSE;
796  fl_mock_binary_messenger_invoke_json_method(
797  messenger, "flutter/textinput", "TextInput.show", nullptr,
798  [](FlMockBinaryMessenger* messenger, FlMethodResponse* response,
799  gpointer user_data) {
800  gboolean* called = static_cast<gboolean*>(user_data);
801  *called = TRUE;
802 
803  EXPECT_TRUE(FL_IS_METHOD_SUCCESS_RESPONSE(response));
804 
805  g_autoptr(FlValue) expected_result = fl_value_new_null();
806  EXPECT_TRUE(fl_value_equal(fl_method_success_response_get_result(
807  FL_METHOD_SUCCESS_RESPONSE(response)),
808  expected_result));
809  },
810  &called);
811  EXPECT_TRUE(called);
812 
813  fl_binary_messenger_shutdown(FL_BINARY_MESSENGER(messenger));
814 }

References fl_binary_messenger_shutdown(), fl_method_success_response_get_result(), fl_text_input_handler_new(), fl_value_equal(), fl_value_new_null(), set_client(), TRUE, and user_data.

EditingDelta::delta_end
int delta_end
Definition: fl_text_input_handler_test.cc:79
build_list
static FlValue * build_list(std::vector< FlValue * > args)
Definition: fl_text_input_handler_test.cc:27
set_editing_state
static void set_editing_state(FlMockBinaryMessenger *messenger, EditingState state)
Definition: fl_text_input_handler_test.cc:122
fl_binary_messenger_shutdown
void fl_binary_messenger_shutdown(FlBinaryMessenger *self)
Definition: fl_binary_messenger.cc:500
fl_key_event_new_from_gdk_event
FlKeyEvent * fl_key_event_new_from_gdk_event(GdkEvent *event)
Definition: fl_key_event.cc:53
InputConfig::enable_delta_model
gboolean enable_delta_model
Definition: fl_text_input_handler_test.cc:39
fl_text_input_view_delegate_translate_coordinates
void fl_text_input_view_delegate_translate_coordinates(FlTextInputViewDelegate *self, gint view_x, gint view_y, gint *window_x, gint *window_y)
Definition: fl_text_input_view_delegate.cc:14
fl_value_set_string_take
G_MODULE_EXPORT void fl_value_set_string_take(FlValue *self, const gchar *key, FlValue *value)
Definition: fl_value.cc:650
fl_value_new_list
G_MODULE_EXPORT FlValue * fl_value_new_list()
Definition: fl_value.cc:349
EditingDelta::composing_extent
int composing_extent
Definition: fl_text_input_handler_test.cc:83
set_client
static void set_client(FlMockBinaryMessenger *messenger, InputConfig config)
Definition: fl_text_input_handler_test.cc:101
fl_value_new_bool
G_MODULE_EXPORT FlValue * fl_value_new_bool(bool value)
Definition: fl_value.cc:255
FlValue
typedefG_BEGIN_DECLS struct _FlValue FlValue
Definition: fl_value.h:42
fl_value_new_null
G_MODULE_EXPORT FlValue * fl_value_new_null()
Definition: fl_value.cc:251
fl_text_input_handler_new
FlTextInputHandler * fl_text_input_handler_new(FlBinaryMessenger *messenger, GtkIMContext *im_context, FlTextInputViewDelegate *view_delegate)
Definition: fl_text_input_handler.cc:455
InputConfig::client_id
int64_t client_id
Definition: fl_text_input_handler_test.cc:36
EditingDelta::delta_text
const gchar * delta_text
Definition: fl_text_input_handler_test.cc:77
EditingDelta::delta_start
int delta_start
Definition: fl_text_input_handler_test.cc:78
fl_value_new_int
G_MODULE_EXPORT FlValue * fl_value_new_int(int64_t value)
Definition: fl_value.cc:262
EditingDelta::selection_extent
int selection_extent
Definition: fl_text_input_handler_test.cc:81
fl_method_success_response_new
G_MODULE_EXPORT FlMethodSuccessResponse * fl_method_success_response_new(FlValue *result)
Definition: fl_method_response.cc:126
state
AtkStateType state
Definition: fl_accessible_node.cc:10
user_data
G_BEGIN_DECLS G_MODULE_EXPORT FlValue gpointer user_data
Definition: fl_event_channel.h:90
build_map
static FlValue * build_map(std::map< const gchar *, FlValue * > args)
Definition: fl_text_input_handler_test.cc:19
fl_value_new_map
G_MODULE_EXPORT FlValue * fl_value_new_map()
Definition: fl_value.cc:366
fl_text_input_handler_filter_keypress
gboolean fl_text_input_handler_filter_keypress(FlTextInputHandler *self, FlKeyEvent *event)
Definition: fl_text_input_handler.cc:476
EditingDelta::old_text
const gchar * old_text
Definition: fl_text_input_handler_test.cc:76
fl_method_success_response_get_result
G_MODULE_EXPORT FlValue * fl_method_success_response_get_result(FlMethodSuccessResponse *self)
Definition: fl_method_response.cc:138
TRUE
return TRUE
Definition: fl_pixel_buffer_texture_test.cc:53
fl_value_append_take
G_MODULE_EXPORT void fl_value_append_take(FlValue *self, FlValue *value)
Definition: fl_value.cc:600
fl_value_equal
G_MODULE_EXPORT bool fl_value_equal(FlValue *a, FlValue *b)
Definition: fl_value.cc:471
EditingDelta::composing_base
int composing_base
Definition: fl_text_input_handler_test.cc:82
height
const uint8_t uint32_t uint32_t * height
Definition: fl_pixel_buffer_texture_test.cc:39
send_key_event
static void send_key_event(FlTextInputHandler *handler, gint keyval, gint state=0)
Definition: fl_text_input_handler_test.cc:144
build_input_config
static FlValue * build_input_config(InputConfig config)
Definition: fl_text_input_handler_test.cc:42
args
G_BEGIN_DECLS G_MODULE_EXPORT FlValue * args
Definition: fl_event_channel.h:89
build_editing_state
static FlValue * build_editing_state(EditingState state)
Definition: fl_text_input_handler_test.cc:63
InputConfig::input_type
const gchar * input_type
Definition: fl_text_input_handler_test.cc:37
InputConfig::input_action
const gchar * input_action
Definition: fl_text_input_handler_test.cc:38
fl_value_new_float
G_MODULE_EXPORT FlValue * fl_value_new_float(double value)
Definition: fl_value.cc:269
width
const uint8_t uint32_t * width
Definition: fl_pixel_buffer_texture_test.cc:38
build_editing_delta
static FlValue * build_editing_delta(EditingDelta delta)
Definition: fl_text_input_handler_test.cc:86
value
uint8_t value
Definition: fl_standard_message_codec.cc:36
fl_value_new_string
G_MODULE_EXPORT FlValue * fl_value_new_string(const gchar *value)
Definition: fl_value.cc:276
EditingDelta::selection_base
int selection_base
Definition: fl_text_input_handler_test.cc:80