fl_accessible_text_field_test.cc File Reference

#include "flutter/shell/platform/linux/testing/linux_test.h"
#include "gtest/gtest.h"
#include "flutter/shell/platform/embedder/test_utils/proc_table_replacement.h"
#include "flutter/shell/platform/linux/fl_accessible_text_field.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_standard_message_codec.h"
#include "flutter/shell/platform/linux/testing/mock_signal_handler.h"

Go to the source code of this file.

Classes
class	FlAccessibleTextFieldTest

Functions
static FlValue *	decode_semantic_data (const uint8_t *data, size_t data_length)
	TEST_F (FlAccessibleTextFieldTest, SetValue)
	TEST_F (FlAccessibleTextFieldTest, SetTextSelection)
	TEST_F (FlAccessibleTextFieldTest, PerformAction)
	TEST_F (FlAccessibleTextFieldTest, GetCharacterCount)
	TEST_F (FlAccessibleTextFieldTest, GetText)
	TEST_F (FlAccessibleTextFieldTest, GetTextBoundsChecking)
	TEST_F (FlAccessibleTextFieldTest, GetCaretOffset)
	TEST_F (FlAccessibleTextFieldTest, SetCaretOffset)
	TEST_F (FlAccessibleTextFieldTest, GetNSelections)
	TEST_F (FlAccessibleTextFieldTest, GetSelection)
	TEST_F (FlAccessibleTextFieldTest, AddSelection)
	TEST_F (FlAccessibleTextFieldTest, RemoveSelection)
	TEST_F (FlAccessibleTextFieldTest, SetSelection)
	TEST_F (FlAccessibleTextFieldTest, SetTextContents)
	TEST_F (FlAccessibleTextFieldTest, InsertDeleteText)
	TEST_F (FlAccessibleTextFieldTest, CopyCutPasteText)
	TEST_F (FlAccessibleTextFieldTest, TextBoundary)
	TEST_F (FlAccessibleTextFieldTest, TextBoundaryOffsetBeyondEnd)
	TEST_F (FlAccessibleTextFieldTest, TextBoundaryOffsetAtStart)
	TEST_F (FlAccessibleTextFieldTest, TextBoundaryEmptyText)
	TEST_F (FlAccessibleTextFieldTest, TextBoundaryOffsetAtEnd)
	TEST_F (FlAccessibleTextFieldTest, TextBoundaryMultiByte)

Function Documentation

decode_semantic_data()

static FlValue * decode_semantic_data ( const uint8_t *  data, size_t  data_length  )

static

Definition at line 18 of file fl_accessible_text_field_test.cc.

                                                                              {
  g_autoptr(GBytes) bytes = g_bytes_new(data, data_length);
  g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new();
  return fl_message_codec_decode_message(FL_MESSAGE_CODEC(codec), bytes,
                                         nullptr);
}

References fl_message_codec_decode_message(), fl_standard_message_codec_new(), and g_autoptr().

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

TEST_F() [1/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		AddSelection
	)

Definition at line 323 of file fl_accessible_text_field_test.cc.

                                                {
  int base = -1;
  int extent = -1;
 
  StartEngine();
 
  fl_engine_get_embedder_api(engine)->SendSemanticsAction = MOCK_ENGINE_PROC(
      SendSemanticsAction,
      ([&base, &extent](auto engine,
                        const FlutterSendSemanticsActionInfo* info) {
        EXPECT_EQ(info->action, kFlutterSemanticsActionSetSelection);
        g_autoptr(FlValue) value =
            decode_semantic_data(info->data, info->data_length);
        EXPECT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_MAP);
        base = fl_value_get_int(fl_value_lookup_string(value, "base"));
        extent = fl_value_get_int(fl_value_lookup_string(value, "extent"));
        return kSuccess;
      }));
 
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  EXPECT_TRUE(atk_text_add_selection(ATK_TEXT(node), 2, 4));
  EXPECT_EQ(base, 2);
  EXPECT_EQ(extent, 4);
 
  fl_accessible_node_set_text_selection(node, 2, 4);
 
  // already has selection
  EXPECT_FALSE(atk_text_add_selection(ATK_TEXT(node), 6, 7));
  EXPECT_EQ(base, 2);
  EXPECT_EQ(extent, 4);
}

References FlutterSendSemanticsActionInfo::action, FlutterSendSemanticsActionInfo::data, FlutterSendSemanticsActionInfo::data_length, decode_semantic_data(), engine, fl_accessible_node_set_text_selection(), fl_accessible_text_field_new(), fl_engine_get_embedder_api(), fl_value_get_int(), fl_value_get_type(), fl_value_lookup_string(), FL_VALUE_TYPE_MAP, g_autoptr(), kFlutterSemanticsActionSetSelection, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendSemanticsAction, and value.

TEST_F() [2/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		CopyCutPasteText
	)

Definition at line 508 of file fl_accessible_text_field_test.cc.

                                                    {
  int base = -1;
  int extent = -1;
  FlutterSemanticsAction act = kFlutterSemanticsActionCustomAction;
 
  StartEngine();
 
  fl_engine_get_embedder_api(engine)->SendSemanticsAction = MOCK_ENGINE_PROC(
      SendSemanticsAction,
      ([&act, &base, &extent](auto engine,
                              const FlutterSendSemanticsActionInfo* info) {
        EXPECT_THAT(info->action,
                    ::testing::AnyOf(kFlutterSemanticsActionCut,
                                     kFlutterSemanticsActionCopy,
                                     kFlutterSemanticsActionPaste,
                                     kFlutterSemanticsActionSetSelection));
        act = info->action;
        if (info->action == kFlutterSemanticsActionSetSelection) {
          g_autoptr(FlValue) value =
              decode_semantic_data(info->data, info->data_length);
          EXPECT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_MAP);
          base = fl_value_get_int(fl_value_lookup_string(value, "base"));
          extent = fl_value_get_int(fl_value_lookup_string(value, "extent"));
        }
        return kSuccess;
      }));
 
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  atk_editable_text_copy_text(ATK_EDITABLE_TEXT(node), 2, 5);
  EXPECT_EQ(base, 2);
  EXPECT_EQ(extent, 5);
  EXPECT_EQ(act, kFlutterSemanticsActionCopy);
 
  atk_editable_text_cut_text(ATK_EDITABLE_TEXT(node), 1, 4);
  EXPECT_EQ(base, 1);
  EXPECT_EQ(extent, 4);
  EXPECT_EQ(act, kFlutterSemanticsActionCut);
 
  atk_editable_text_paste_text(ATK_EDITABLE_TEXT(node), 3);
  EXPECT_EQ(base, 3);
  EXPECT_EQ(extent, 3);
  EXPECT_EQ(act, kFlutterSemanticsActionPaste);
}

References FlutterSendSemanticsActionInfo::action, FlutterSendSemanticsActionInfo::data, FlutterSendSemanticsActionInfo::data_length, decode_semantic_data(), engine, fl_accessible_text_field_new(), fl_engine_get_embedder_api(), fl_value_get_int(), fl_value_get_type(), fl_value_lookup_string(), FL_VALUE_TYPE_MAP, g_autoptr(), kFlutterSemanticsActionCopy, kFlutterSemanticsActionCustomAction, kFlutterSemanticsActionCut, kFlutterSemanticsActionPaste, kFlutterSemanticsActionSetSelection, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendSemanticsAction, and value.

TEST_F() [3/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		GetCaretOffset
	)

Definition at line 237 of file fl_accessible_text_field_test.cc.

                                                  {
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  EXPECT_EQ(atk_text_get_caret_offset(ATK_TEXT(node)), -1);
 
  fl_accessible_node_set_text_selection(node, 1, 2);
 
  EXPECT_EQ(atk_text_get_caret_offset(ATK_TEXT(node)), 2);
}

References engine, fl_accessible_node_set_text_selection(), fl_accessible_text_field_new(), and g_autoptr().

TEST_F() [4/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		GetCharacterCount
	)

Definition at line 180 of file fl_accessible_text_field_test.cc.

                                                     {
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  EXPECT_EQ(atk_text_get_character_count(ATK_TEXT(node)), 0);
 
  fl_accessible_node_set_value(node, "Flutter!");
 
  EXPECT_EQ(atk_text_get_character_count(ATK_TEXT(node)), 8);
}

References engine, fl_accessible_node_set_value(), fl_accessible_text_field_new(), and g_autoptr().

TEST_F() [5/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		GetNSelections
	)

Definition at line 277 of file fl_accessible_text_field_test.cc.

                                                  {
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  EXPECT_EQ(atk_text_get_n_selections(ATK_TEXT(node)), 0);
 
  fl_accessible_node_set_text_selection(node, 1, 2);
 
  EXPECT_EQ(atk_text_get_n_selections(ATK_TEXT(node)), 1);
}

References engine, fl_accessible_node_set_text_selection(), fl_accessible_text_field_new(), and g_autoptr().

TEST_F() [6/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		GetSelection
	)

Definition at line 289 of file fl_accessible_text_field_test.cc.

                                                {
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  EXPECT_EQ(atk_text_get_selection(ATK_TEXT(node), 0, nullptr, nullptr),
            nullptr);
 
  fl_accessible_node_set_value(node, "Flutter");
  fl_accessible_node_set_text_selection(node, 2, 5);
 
  gint start, end;
  g_autofree gchar* selection =
      atk_text_get_selection(ATK_TEXT(node), 0, &start, &end);
  EXPECT_STREQ(selection, "utt");
  EXPECT_EQ(start, 2);
  EXPECT_EQ(end, 5);
 
  // reverse
  fl_accessible_node_set_text_selection(node, 5, 2);
  g_autofree gchar* reverse =
      atk_text_get_selection(ATK_TEXT(node), 0, &start, &end);
  EXPECT_STREQ(reverse, "utt");
  EXPECT_EQ(start, 2);
  EXPECT_EQ(end, 5);
 
  // empty
  fl_accessible_node_set_text_selection(node, 5, 5);
  EXPECT_EQ(atk_text_get_selection(ATK_TEXT(node), 0, &start, &end), nullptr);
 
  // selection num != 0
  EXPECT_EQ(atk_text_get_selection(ATK_TEXT(node), 1, &start, &end), nullptr);
}

References end, engine, fl_accessible_node_set_text_selection(), fl_accessible_node_set_value(), fl_accessible_text_field_new(), g_autoptr(), and start.

TEST_F() [7/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		GetText
	)

Definition at line 192 of file fl_accessible_text_field_test.cc.

                                           {
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  g_autofree gchar* empty = atk_text_get_text(ATK_TEXT(node), 0, -1);
  EXPECT_STREQ(empty, "");
 
  flutter::testing::MockSignalHandler text_inserted(node, "text-insert");
  EXPECT_SIGNAL(text_inserted).Times(1);
 
  fl_accessible_node_set_value(node, "Flutter!");
 
  g_autofree gchar* flutter = atk_text_get_text(ATK_TEXT(node), 0, -1);
  EXPECT_STREQ(flutter, "Flutter!");
 
  g_autofree gchar* tt = atk_text_get_text(ATK_TEXT(node), 3, 5);
  EXPECT_STREQ(tt, "tt");
}

References engine, EXPECT_SIGNAL, fl_accessible_node_set_value(), fl_accessible_text_field_new(), and g_autoptr().

TEST_F() [8/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		GetTextBoundsChecking
	)

Definition at line 212 of file fl_accessible_text_field_test.cc.

                                                         {
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  fl_accessible_node_set_value(node, "Hello");
 
  // start beyond end of text
  g_autofree gchar* beyond = atk_text_get_text(ATK_TEXT(node), 100, -1);
  EXPECT_STREQ(beyond, "");
 
  // end beyond text length
  g_autofree gchar* end_beyond = atk_text_get_text(ATK_TEXT(node), 2, 100);
  EXPECT_STREQ(end_beyond, "llo");
 
  // both beyond text length
  g_autofree gchar* both_beyond = atk_text_get_text(ATK_TEXT(node), 50, 100);
  EXPECT_STREQ(both_beyond, "");
 
  // empty buffer
  fl_accessible_node_set_value(node, "");
  g_autofree gchar* empty_beyond = atk_text_get_text(ATK_TEXT(node), 5, 10);
  EXPECT_STREQ(empty_beyond, "");
}

References engine, fl_accessible_node_set_value(), fl_accessible_text_field_new(), and g_autoptr().

TEST_F() [9/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		InsertDeleteText
	)

Definition at line 460 of file fl_accessible_text_field_test.cc.

                                                    {
  g_autofree gchar* text = nullptr;
  int base = -1;
  int extent = -1;
 
  StartEngine();
 
  fl_engine_get_embedder_api(engine)->SendSemanticsAction = MOCK_ENGINE_PROC(
      SendSemanticsAction,
      ([&text, &base, &extent](auto engine,
                               const FlutterSendSemanticsActionInfo* info) {
        EXPECT_THAT(info->action,
                    ::testing::AnyOf(kFlutterSemanticsActionSetText,
                                     kFlutterSemanticsActionSetSelection));
        if (info->action == kFlutterSemanticsActionSetText) {
          g_autoptr(FlValue) value =
              decode_semantic_data(info->data, info->data_length);
          EXPECT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
          g_free(text);
          text = g_strdup(fl_value_get_string(value));
        } else {
          g_autoptr(FlValue) value =
              decode_semantic_data(info->data, info->data_length);
          EXPECT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_MAP);
          base = fl_value_get_int(fl_value_lookup_string(value, "base"));
          extent = fl_value_get_int(fl_value_lookup_string(value, "extent"));
        }
        return kSuccess;
      }));
 
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
  fl_accessible_node_set_value(node, "Fler");
 
  gint pos = 2;
  atk_editable_text_insert_text(ATK_EDITABLE_TEXT(node), "utt", 3, &pos);
  EXPECT_EQ(pos, 5);
  EXPECT_STREQ(text, "Flutter");
  EXPECT_EQ(base, pos);
  EXPECT_EQ(extent, pos);
 
  atk_editable_text_delete_text(ATK_EDITABLE_TEXT(node), 2, 5);
  EXPECT_STREQ(text, "Fler");
  EXPECT_EQ(base, 2);
  EXPECT_EQ(extent, 2);
}

References FlutterSendSemanticsActionInfo::action, FlutterSendSemanticsActionInfo::data, FlutterSendSemanticsActionInfo::data_length, decode_semantic_data(), engine, fl_accessible_node_set_value(), fl_accessible_text_field_new(), fl_engine_get_embedder_api(), fl_value_get_int(), fl_value_get_string(), fl_value_get_type(), fl_value_lookup_string(), FL_VALUE_TYPE_MAP, FL_VALUE_TYPE_STRING, g_autoptr(), kFlutterSemanticsActionSetSelection, kFlutterSemanticsActionSetText, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendSemanticsAction, text, and value.

TEST_F() [10/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		PerformAction
	)

Definition at line 144 of file fl_accessible_text_field_test.cc.

                                                 {
  g_autoptr(GPtrArray) action_datas = g_ptr_array_new_with_free_func(
      reinterpret_cast<GDestroyNotify>(fl_value_unref));
 
  StartEngine();
 
  fl_engine_get_embedder_api(engine)->SendSemanticsAction = MOCK_ENGINE_PROC(
      SendSemanticsAction,
      ([&action_datas](auto engine,
                       const FlutterSendSemanticsActionInfo* info) {
        g_ptr_array_add(action_datas,
                        decode_semantic_data(info->data, info->data_length));
        return kSuccess;
      }));
 
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
  fl_accessible_node_set_actions(
      node, static_cast<FlutterSemanticsAction>(
                kFlutterSemanticsActionMoveCursorForwardByCharacter |
                kFlutterSemanticsActionMoveCursorBackwardByCharacter |
                kFlutterSemanticsActionMoveCursorForwardByWord |
                kFlutterSemanticsActionMoveCursorBackwardByWord));
 
  g_autoptr(FlValue) expand_selection = fl_value_new_bool(false);
 
  for (int i = 0; i < 4; ++i) {
    atk_action_do_action(ATK_ACTION(node), i);
 
    FlValue* data = static_cast<FlValue*>(g_ptr_array_index(action_datas, i));
    EXPECT_NE(data, nullptr);
    EXPECT_TRUE(fl_value_equal(data, expand_selection));
  }
}

References FlutterSendSemanticsActionInfo::data, FlutterSendSemanticsActionInfo::data_length, decode_semantic_data(), engine, fl_accessible_node_set_actions(), fl_accessible_text_field_new(), fl_engine_get_embedder_api(), fl_value_equal(), fl_value_new_bool(), fl_value_unref(), g_autoptr(), i, kFlutterSemanticsActionMoveCursorBackwardByCharacter, kFlutterSemanticsActionMoveCursorBackwardByWord, kFlutterSemanticsActionMoveCursorForwardByCharacter, kFlutterSemanticsActionMoveCursorForwardByWord, kSuccess, MOCK_ENGINE_PROC, and FlutterEngineProcTable::SendSemanticsAction.

TEST_F() [11/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		RemoveSelection
	)

Definition at line 358 of file fl_accessible_text_field_test.cc.

                                                   {
  int base = -1;
  int extent = -1;
 
  StartEngine();
 
  fl_engine_get_embedder_api(engine)->SendSemanticsAction = MOCK_ENGINE_PROC(
      SendSemanticsAction,
      ([&base, &extent](auto engine,
                        const FlutterSendSemanticsActionInfo* info) {
        EXPECT_EQ(info->action, kFlutterSemanticsActionSetSelection);
        g_autoptr(FlValue) value =
            decode_semantic_data(info->data, info->data_length);
        EXPECT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_MAP);
        base = fl_value_get_int(fl_value_lookup_string(value, "base"));
        extent = fl_value_get_int(fl_value_lookup_string(value, "extent"));
        return kSuccess;
      }));
 
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  // no selection
  EXPECT_FALSE(atk_text_remove_selection(ATK_TEXT(node), 0));
  EXPECT_EQ(base, -1);
  EXPECT_EQ(extent, -1);
 
  fl_accessible_node_set_text_selection(node, 2, 4);
 
  // selection num != 0
  EXPECT_FALSE(atk_text_remove_selection(ATK_TEXT(node), 1));
  EXPECT_EQ(base, -1);
  EXPECT_EQ(extent, -1);
 
  // ok, collapses selection
  EXPECT_TRUE(atk_text_remove_selection(ATK_TEXT(node), 0));
  EXPECT_EQ(base, 4);
  EXPECT_EQ(extent, 4);
}

References FlutterSendSemanticsActionInfo::action, FlutterSendSemanticsActionInfo::data, FlutterSendSemanticsActionInfo::data_length, decode_semantic_data(), engine, fl_accessible_node_set_text_selection(), fl_accessible_text_field_new(), fl_engine_get_embedder_api(), fl_value_get_int(), fl_value_get_type(), fl_value_lookup_string(), FL_VALUE_TYPE_MAP, g_autoptr(), kFlutterSemanticsActionSetSelection, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendSemanticsAction, and value.

TEST_F() [12/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		SetCaretOffset
	)

Definition at line 249 of file fl_accessible_text_field_test.cc.

                                                  {
  int base = -1;
  int extent = -1;
 
  StartEngine();
 
  fl_engine_get_embedder_api(engine)->SendSemanticsAction = MOCK_ENGINE_PROC(
      SendSemanticsAction,
      ([&base, &extent](auto engine,
                        const FlutterSendSemanticsActionInfo* info) {
        EXPECT_EQ(info->action, kFlutterSemanticsActionSetSelection);
        g_autoptr(FlValue) value =
            decode_semantic_data(info->data, info->data_length);
        EXPECT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_MAP);
        base = fl_value_get_int(fl_value_lookup_string(value, "base"));
        extent = fl_value_get_int(fl_value_lookup_string(value, "extent"));
        return kSuccess;
      }));
 
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  EXPECT_TRUE(atk_text_set_caret_offset(ATK_TEXT(node), 3));
  EXPECT_EQ(base, 3);
  EXPECT_EQ(extent, 3);
}

References FlutterSendSemanticsActionInfo::action, FlutterSendSemanticsActionInfo::data, FlutterSendSemanticsActionInfo::data_length, decode_semantic_data(), engine, fl_accessible_text_field_new(), fl_engine_get_embedder_api(), fl_value_get_int(), fl_value_get_type(), fl_value_lookup_string(), FL_VALUE_TYPE_MAP, g_autoptr(), kFlutterSemanticsActionSetSelection, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendSemanticsAction, and value.

TEST_F() [13/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		SetSelection
	)

Definition at line 399 of file fl_accessible_text_field_test.cc.

                                                {
  int base = -1;
  int extent = -1;
 
  StartEngine();
 
  fl_engine_get_embedder_api(engine)->SendSemanticsAction = MOCK_ENGINE_PROC(
      SendSemanticsAction,
      ([&base, &extent](auto engine,
                        const FlutterSendSemanticsActionInfo* info) {
        EXPECT_EQ(info->action, kFlutterSemanticsActionSetSelection);
        g_autoptr(FlValue) value =
            decode_semantic_data(info->data, info->data_length);
        EXPECT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_MAP);
        base = fl_value_get_int(fl_value_lookup_string(value, "base"));
        extent = fl_value_get_int(fl_value_lookup_string(value, "extent"));
        return kSuccess;
      }));
 
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  // selection num != 0
  EXPECT_FALSE(atk_text_set_selection(ATK_TEXT(node), 1, 2, 4));
  EXPECT_EQ(base, -1);
  EXPECT_EQ(extent, -1);
 
  EXPECT_TRUE(atk_text_set_selection(ATK_TEXT(node), 0, 2, 4));
  EXPECT_EQ(base, 2);
  EXPECT_EQ(extent, 4);
 
  EXPECT_TRUE(atk_text_set_selection(ATK_TEXT(node), 0, 5, 1));
  EXPECT_EQ(base, 5);
  EXPECT_EQ(extent, 1);
}

References FlutterSendSemanticsActionInfo::action, FlutterSendSemanticsActionInfo::data, FlutterSendSemanticsActionInfo::data_length, decode_semantic_data(), engine, fl_accessible_text_field_new(), fl_engine_get_embedder_api(), fl_value_get_int(), fl_value_get_type(), fl_value_lookup_string(), FL_VALUE_TYPE_MAP, g_autoptr(), kFlutterSemanticsActionSetSelection, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendSemanticsAction, and value.

TEST_F() [14/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		SetTextContents
	)

Definition at line 436 of file fl_accessible_text_field_test.cc.

                                                   {
  g_autofree gchar* text = nullptr;
 
  StartEngine();
 
  fl_engine_get_embedder_api(engine)->SendSemanticsAction = MOCK_ENGINE_PROC(
      SendSemanticsAction,
      ([&text](auto engine, const FlutterSendSemanticsActionInfo* info) {
        EXPECT_EQ(info->action, kFlutterSemanticsActionSetText);
        g_autoptr(FlValue) value =
            decode_semantic_data(info->data, info->data_length);
        EXPECT_EQ(fl_value_get_type(value), FL_VALUE_TYPE_STRING);
        text = g_strdup(fl_value_get_string(value));
        return kSuccess;
      }));
 
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  atk_editable_text_set_text_contents(ATK_EDITABLE_TEXT(node), "Flutter");
  EXPECT_STREQ(text, "Flutter");
}

References FlutterSendSemanticsActionInfo::action, FlutterSendSemanticsActionInfo::data, FlutterSendSemanticsActionInfo::data_length, decode_semantic_data(), engine, fl_accessible_text_field_new(), fl_engine_get_embedder_api(), fl_value_get_string(), fl_value_get_type(), FL_VALUE_TYPE_STRING, g_autoptr(), kFlutterSemanticsActionSetText, kSuccess, MOCK_ENGINE_PROC, FlutterEngineProcTable::SendSemanticsAction, text, and value.

TEST_F() [15/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		SetTextSelection
	)

Definition at line 85 of file fl_accessible_text_field_test.cc.

                                                    {
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  // [-1,-1] -> [2,3]
  {
    flutter::testing::MockSignalHandler text_selection_changed(
        node, "text-selection-changed");
    flutter::testing::MockSignalHandler1<int> text_caret_moved(
        node, "text-caret-moved");
 
    EXPECT_SIGNAL(text_selection_changed);
    EXPECT_SIGNAL1(text_caret_moved, ::testing::Eq(3));
 
    fl_accessible_node_set_text_selection(node, 2, 3);
  }
 
  // [2,3] -> [3,3]
  {
    flutter::testing::MockSignalHandler text_selection_changed(
        node, "text-selection-changed");
    flutter::testing::MockSignalHandler text_caret_moved(node,
                                                         "text-caret-moved");
 
    EXPECT_SIGNAL(text_selection_changed);
    EXPECT_SIGNAL(text_caret_moved).Times(0);
 
    fl_accessible_node_set_text_selection(node, 3, 3);
  }
 
  // [3,3] -> [3,3]
  {
    flutter::testing::MockSignalHandler text_selection_changed(
        node, "text-selection-changed");
    flutter::testing::MockSignalHandler text_caret_moved(node,
                                                         "text-caret-moved");
 
    EXPECT_SIGNAL(text_selection_changed).Times(0);
    EXPECT_SIGNAL(text_caret_moved).Times(0);
 
    fl_accessible_node_set_text_selection(node, 3, 3);
  }
 
  // [3,3] -> [4,4]
  {
    flutter::testing::MockSignalHandler text_selection_changed(
        node, "text-selection-changed");
    flutter::testing::MockSignalHandler1<int> text_caret_moved(
        node, "text-caret-moved");
 
    EXPECT_SIGNAL(text_selection_changed).Times(0);
    EXPECT_SIGNAL1(text_caret_moved, ::testing::Eq(4));
 
    fl_accessible_node_set_text_selection(node, 4, 4);
  }
}

References engine, EXPECT_SIGNAL, EXPECT_SIGNAL1, fl_accessible_node_set_text_selection(), fl_accessible_text_field_new(), and g_autoptr().

TEST_F() [16/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		SetValue
	)

Definition at line 29 of file fl_accessible_text_field_test.cc.

                                            {
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  // "" -> "Flutter"
  {
    flutter::testing::MockSignalHandler2<int, int> text_inserted(node,
                                                                 "text-insert");
    flutter::testing::MockSignalHandler text_removed(node, "text-remove");
 
    EXPECT_SIGNAL2(text_inserted, ::testing::Eq(0), ::testing::Eq(7));
    EXPECT_SIGNAL(text_removed).Times(0);
 
    fl_accessible_node_set_value(node, "Flutter");
  }
 
  // "Flutter" -> "Flutter"
  {
    flutter::testing::MockSignalHandler text_inserted(node, "text-insert");
    flutter::testing::MockSignalHandler text_removed(node, "text-remove");
 
    EXPECT_SIGNAL(text_inserted).Times(0);
    EXPECT_SIGNAL(text_removed).Times(0);
 
    fl_accessible_node_set_value(node, "Flutter");
  }
 
  // "Flutter" -> "engine"
  {
    flutter::testing::MockSignalHandler2<int, int> text_inserted(node,
                                                                 "text-insert");
    flutter::testing::MockSignalHandler2<int, int> text_removed(node,
                                                                "text-remove");
 
    EXPECT_SIGNAL2(text_inserted, ::testing::Eq(0), ::testing::Eq(6));
    EXPECT_SIGNAL2(text_removed, ::testing::Eq(0), ::testing::Eq(7));
 
    fl_accessible_node_set_value(node, "engine");
  }
 
  // "engine" -> ""
  {
    flutter::testing::MockSignalHandler text_inserted(node, "text-insert");
    flutter::testing::MockSignalHandler2<int, int> text_removed(node,
                                                                "text-remove");
 
    EXPECT_SIGNAL(text_inserted).Times(0);
    EXPECT_SIGNAL2(text_removed, ::testing::Eq(0), ::testing::Eq(6));
 
    fl_accessible_node_set_value(node, "");
  }
}

References engine, EXPECT_SIGNAL, EXPECT_SIGNAL2, fl_accessible_node_set_value(), fl_accessible_text_field_new(), and g_autoptr().

TEST_F() [17/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		TextBoundary
	)

Definition at line 554 of file fl_accessible_text_field_test.cc.

                                                {
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  fl_accessible_node_set_value(node,
                               "Lorem ipsum.\nDolor sit amet. Praesent commodo?"
                               "\n\nPraesent et felis dui.");
 
  // |Lorem
  gint start_offset = -1, end_offset = -1;
  g_autofree gchar* lorem_char = atk_text_get_string_at_offset(
      ATK_TEXT(node), 0, ATK_TEXT_GRANULARITY_CHAR, &start_offset, &end_offset);
  EXPECT_STREQ(lorem_char, "L");
  EXPECT_EQ(start_offset, 0);
  EXPECT_EQ(end_offset, 1);
 
  g_autofree gchar* lorem_word = atk_text_get_string_at_offset(
      ATK_TEXT(node), 0, ATK_TEXT_GRANULARITY_WORD, &start_offset, &end_offset);
  EXPECT_STREQ(lorem_word, "Lorem");
  EXPECT_EQ(start_offset, 0);
  EXPECT_EQ(end_offset, 5);
 
  g_autofree gchar* lorem_sentence = atk_text_get_string_at_offset(
      ATK_TEXT(node), 0, ATK_TEXT_GRANULARITY_SENTENCE, &start_offset,
      &end_offset);
  EXPECT_STREQ(lorem_sentence, "Lorem ipsum.");
  EXPECT_EQ(start_offset, 0);
  EXPECT_EQ(end_offset, 12);
 
  g_autofree gchar* lorem_line = atk_text_get_string_at_offset(
      ATK_TEXT(node), 0, ATK_TEXT_GRANULARITY_LINE, &start_offset, &end_offset);
  EXPECT_STREQ(lorem_line, "Lorem ipsum.");
  EXPECT_EQ(start_offset, 0);
  EXPECT_EQ(end_offset, 12);
 
  g_autofree gchar* lorem_paragraph = atk_text_get_string_at_offset(
      ATK_TEXT(node), 0, ATK_TEXT_GRANULARITY_PARAGRAPH, &start_offset,
      &end_offset);
  EXPECT_STREQ(lorem_paragraph,
               "Lorem ipsum.\nDolor sit amet. Praesent commodo?");
  EXPECT_EQ(start_offset, 0);
  EXPECT_EQ(end_offset, 46);
 
  // Pra|esent
  g_autofree gchar* praesent_char = atk_text_get_string_at_offset(
      ATK_TEXT(node), 32, ATK_TEXT_GRANULARITY_CHAR, &start_offset,
      &end_offset);
  EXPECT_STREQ(praesent_char, "e");
  EXPECT_EQ(start_offset, 32);
  EXPECT_EQ(end_offset, 33);
 
  g_autofree gchar* praesent_word = atk_text_get_string_at_offset(
      ATK_TEXT(node), 32, ATK_TEXT_GRANULARITY_WORD, &start_offset,
      &end_offset);
  EXPECT_STREQ(praesent_word, "Praesent");
  EXPECT_EQ(start_offset, 29);
  EXPECT_EQ(end_offset, 37);
 
  g_autofree gchar* praesent_sentence = atk_text_get_string_at_offset(
      ATK_TEXT(node), 32, ATK_TEXT_GRANULARITY_SENTENCE, &start_offset,
      &end_offset);
  EXPECT_STREQ(praesent_sentence, "Praesent commodo?");
  EXPECT_EQ(start_offset, 29);
  EXPECT_EQ(end_offset, 46);
 
  g_autofree gchar* praesent_line = atk_text_get_string_at_offset(
      ATK_TEXT(node), 32, ATK_TEXT_GRANULARITY_LINE, &start_offset,
      &end_offset);
  EXPECT_STREQ(praesent_line, "Dolor sit amet. Praesent commodo?");
  EXPECT_EQ(start_offset, 13);
  EXPECT_EQ(end_offset, 46);
 
  g_autofree gchar* praesent_paragraph = atk_text_get_string_at_offset(
      ATK_TEXT(node), 32, ATK_TEXT_GRANULARITY_PARAGRAPH, &start_offset,
      &end_offset);
  EXPECT_STREQ(praesent_paragraph,
               "Lorem ipsum.\nDolor sit amet. Praesent commodo?");
  EXPECT_EQ(start_offset, 0);
  EXPECT_EQ(end_offset, 46);
 
  // feli|s
  g_autofree gchar* felis_char = atk_text_get_string_at_offset(
      ATK_TEXT(node), 64, ATK_TEXT_GRANULARITY_CHAR, &start_offset,
      &end_offset);
  EXPECT_STREQ(felis_char, "s");
  EXPECT_EQ(start_offset, 64);
  EXPECT_EQ(end_offset, 65);
 
  g_autofree gchar* felis_word = atk_text_get_string_at_offset(
      ATK_TEXT(node), 64, ATK_TEXT_GRANULARITY_WORD, &start_offset,
      &end_offset);
  EXPECT_STREQ(felis_word, "felis");
  EXPECT_EQ(start_offset, 60);
  EXPECT_EQ(end_offset, 65);
 
  g_autofree gchar* felis_sentence = atk_text_get_string_at_offset(
      ATK_TEXT(node), 64, ATK_TEXT_GRANULARITY_SENTENCE, &start_offset,
      &end_offset);
  EXPECT_STREQ(felis_sentence, "Praesent et felis dui.");
  EXPECT_EQ(start_offset, 48);
  EXPECT_EQ(end_offset, 70);
 
  g_autofree gchar* felis_line = atk_text_get_string_at_offset(
      ATK_TEXT(node), 64, ATK_TEXT_GRANULARITY_LINE, &start_offset,
      &end_offset);
  EXPECT_STREQ(felis_line, "Praesent et felis dui.");
  EXPECT_EQ(start_offset, 48);
  EXPECT_EQ(end_offset, 70);
 
  g_autofree gchar* felis_paragraph = atk_text_get_string_at_offset(
      ATK_TEXT(node), 64, ATK_TEXT_GRANULARITY_PARAGRAPH, &start_offset,
      &end_offset);
  EXPECT_STREQ(felis_paragraph, "\nPraesent et felis dui.");
  EXPECT_EQ(start_offset, 47);
  EXPECT_EQ(end_offset, 70);
}

References engine, fl_accessible_node_set_value(), fl_accessible_text_field_new(), and g_autoptr().

TEST_F() [18/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		TextBoundaryEmptyText
	)

Definition at line 728 of file fl_accessible_text_field_test.cc.

                                                         {
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  // Empty text - should not crash.
  gint start_offset = -1, end_offset = -1;
  g_autofree gchar* char_result = atk_text_get_string_at_offset(
      ATK_TEXT(node), 0, ATK_TEXT_GRANULARITY_CHAR, &start_offset, &end_offset);
  EXPECT_NE(char_result, nullptr);
  EXPECT_EQ(start_offset, 0);
  EXPECT_STREQ(char_result, "");
 
  g_autofree gchar* word_result = atk_text_get_string_at_offset(
      ATK_TEXT(node), 0, ATK_TEXT_GRANULARITY_WORD, &start_offset, &end_offset);
  EXPECT_NE(word_result, nullptr);
  EXPECT_EQ(start_offset, 0);
  EXPECT_STREQ(word_result, "");
}

References engine, fl_accessible_text_field_new(), and g_autoptr().

TEST_F() [19/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		TextBoundaryMultiByte
	)

Definition at line 776 of file fl_accessible_text_field_test.cc.

                                                         {
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  // "Café" is 4 characters but 5 bytes (é is 2 bytes).
  // "Münch" is 5 characters but 6 bytes (ü is 2 bytes).
  // Character offsets: C(0) a(1) f(2) é(3) \n(4) M(5) ü(6) n(7) c(8) h(9)
  fl_accessible_node_set_value(node, "Café\nMünch");
 
  // The field has 10 characters.
  EXPECT_EQ(atk_text_get_character_count(ATK_TEXT(node)), 10);
 
  // First line: "Café" at character offsets [0, 4).
  gint start_offset = -1, end_offset = -1;
  g_autofree gchar* line0 = atk_text_get_string_at_offset(
      ATK_TEXT(node), 0, ATK_TEXT_GRANULARITY_LINE, &start_offset, &end_offset);
  EXPECT_STREQ(line0, "Café");
  EXPECT_EQ(start_offset, 0);
  EXPECT_EQ(end_offset, 4);
 
  // Second line: "Münch" at character offsets [5, 10). Query at offset 6
  // (the 'ü'), which sits in the middle of a multi-byte sequence in byte
  // space - the buggy byte-based logic would return the wrong substring here.
  g_autofree gchar* line1 = atk_text_get_string_at_offset(
      ATK_TEXT(node), 6, ATK_TEXT_GRANULARITY_LINE, &start_offset, &end_offset);
  EXPECT_STREQ(line1, "Münch");
  EXPECT_EQ(start_offset, 5);
  EXPECT_EQ(end_offset, 10);
 
  // Whole text is a single paragraph spanning both lines.
  g_autofree gchar* paragraph = atk_text_get_string_at_offset(
      ATK_TEXT(node), 6, ATK_TEXT_GRANULARITY_PARAGRAPH, &start_offset,
      &end_offset);
  EXPECT_STREQ(paragraph, "Café\nMünch");
  EXPECT_EQ(start_offset, 0);
  EXPECT_EQ(end_offset, 10);
}

References engine, fl_accessible_node_set_value(), fl_accessible_text_field_new(), and g_autoptr().

TEST_F() [20/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		TextBoundaryOffsetAtEnd
	)

Definition at line 748 of file fl_accessible_text_field_test.cc.

                                                           {
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  fl_accessible_node_set_value(node, "Hello world");
 
  // Offset at exactly the character count (one past last char).
  gint char_count = atk_text_get_character_count(ATK_TEXT(node));
  EXPECT_EQ(char_count, 11);
 
  gint start_offset = -1, end_offset = -1;
  g_autofree gchar* char_result = atk_text_get_string_at_offset(
      ATK_TEXT(node), char_count, ATK_TEXT_GRANULARITY_CHAR, &start_offset,
      &end_offset);
  EXPECT_NE(char_result, nullptr);
  EXPECT_GE(start_offset, 0);
  EXPECT_LE(end_offset, char_count);
 
  g_autofree gchar* word_result = atk_text_get_string_at_offset(
      ATK_TEXT(node), char_count, ATK_TEXT_GRANULARITY_WORD, &start_offset,
      &end_offset);
  EXPECT_NE(word_result, nullptr);
  EXPECT_GE(start_offset, 0);
  EXPECT_LE(end_offset, char_count);
}

References engine, fl_accessible_node_set_value(), fl_accessible_text_field_new(), and g_autoptr().

TEST_F() [21/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		TextBoundaryOffsetAtStart
	)

Definition at line 704 of file fl_accessible_text_field_test.cc.

                                                             {
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  fl_accessible_node_set_value(node, "Hello");
 
  // Offset at zero should return the first character/word.
  gint start_offset = -1, end_offset = -1;
  g_autofree gchar* char_result = atk_text_get_string_at_offset(
      ATK_TEXT(node), 0, ATK_TEXT_GRANULARITY_CHAR, &start_offset, &end_offset);
  EXPECT_NE(char_result, nullptr);
  EXPECT_EQ(start_offset, 0);
  EXPECT_EQ(end_offset, 1);
  EXPECT_STREQ(char_result, "H");
 
  g_autofree gchar* word_result = atk_text_get_string_at_offset(
      ATK_TEXT(node), 0, ATK_TEXT_GRANULARITY_WORD, &start_offset, &end_offset);
  EXPECT_NE(word_result, nullptr);
  EXPECT_EQ(start_offset, 0);
  EXPECT_EQ(end_offset, 5);
  EXPECT_STREQ(word_result, "Hello");
}

References engine, fl_accessible_node_set_value(), fl_accessible_text_field_new(), and g_autoptr().

TEST_F() [22/22]

TEST_F	(	FlAccessibleTextFieldTest	,
		TextBoundaryOffsetBeyondEnd
	)

Definition at line 672 of file fl_accessible_text_field_test.cc.

                                                               {
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_text_field_new(engine, 123, 1);
 
  fl_accessible_node_set_value(node, "Hello");
 
  // Offset well beyond the text length should not crash and should return
  // a valid result clamped to the text boundaries.
  gint start_offset = -1, end_offset = -1;
  g_autofree gchar* char_result = atk_text_get_string_at_offset(
      ATK_TEXT(node), 100, ATK_TEXT_GRANULARITY_CHAR, &start_offset,
      &end_offset);
  EXPECT_NE(char_result, nullptr);
  EXPECT_GE(start_offset, 0);
  EXPECT_LE(end_offset, 5);
 
  g_autofree gchar* word_result = atk_text_get_string_at_offset(
      ATK_TEXT(node), 100, ATK_TEXT_GRANULARITY_WORD, &start_offset,
      &end_offset);
  EXPECT_NE(word_result, nullptr);
  EXPECT_GE(start_offset, 0);
  EXPECT_LE(end_offset, 5);
 
  g_autofree gchar* sentence_result = atk_text_get_string_at_offset(
      ATK_TEXT(node), 100, ATK_TEXT_GRANULARITY_SENTENCE, &start_offset,
      &end_offset);
  EXPECT_NE(sentence_result, nullptr);
  EXPECT_GE(start_offset, 0);
  EXPECT_LE(end_offset, 5);
}

References engine, fl_accessible_node_set_value(), fl_accessible_text_field_new(), and g_autoptr().