fl_accessible_node_test.cc File Reference

#include "flutter/shell/platform/linux/testing/linux_test.h"
#include "gtest/gtest.h"
#include "flutter/shell/platform/linux/fl_accessible_node.h"
#include "flutter/shell/platform/linux/testing/mock_gtk.h"

Go to the source code of this file.

Classes
class	FlAccessibleNodeTest

Functions
	TEST_F (FlAccessibleNodeTest, BuildTree)
	TEST_F (FlAccessibleNodeTest, SetName)
	TEST_F (FlAccessibleNodeTest, SetExtents)
	TEST_F (FlAccessibleNodeTest, FocusedFlags)
	TEST_F (FlAccessibleNodeTest, CheckedAndToggledFlags)
	TEST_F (FlAccessibleNodeTest, SelectedFlags)
	TEST_F (FlAccessibleNodeTest, EnabledFlags)
	TEST_F (FlAccessibleNodeTest, ObscuredFlags)
	TEST_F (FlAccessibleNodeTest, HiddenFlags)
	TEST_F (FlAccessibleNodeTest, ReadOnlyFlags)
	TEST_F (FlAccessibleNodeTest, TextFieldFlags)
	TEST_F (FlAccessibleNodeTest, GetRole)
	TEST_F (FlAccessibleNodeTest, SetActions)
	TEST_F (FlAccessibleNodeTest, SurvivesEngineDestruction)
	TEST_F (FlAccessibleNodeTest, SurvivesParentDestruction)

Function Documentation

TEST_F() [1/15]

TEST_F	(	FlAccessibleNodeTest	,
		BuildTree
	)

Definition at line 18 of file fl_accessible_node_test.cc.

                                        {
  int64_t view_id = 123;
  g_autoptr(FlAccessibleNode) root = fl_accessible_node_new(engine, view_id, 0);
  g_autoptr(FlAccessibleNode) child1 =
      fl_accessible_node_new(engine, view_id, 1);
  fl_accessible_node_set_parent(child1, ATK_OBJECT(root), 0);
  g_autoptr(FlAccessibleNode) child2 =
      fl_accessible_node_new(engine, view_id, 1);
  fl_accessible_node_set_parent(child2, ATK_OBJECT(root), 1);
  g_autoptr(GPtrArray) children =
      g_ptr_array_new_with_free_func(g_object_unref);
  g_ptr_array_add(children, g_object_ref(child1));
  g_ptr_array_add(children, g_object_ref(child2));
  fl_accessible_node_set_children(root, children);
 
  EXPECT_EQ(atk_object_get_n_accessible_children(ATK_OBJECT(root)), 2);
  EXPECT_EQ(atk_object_get_index_in_parent(ATK_OBJECT(root)), 0);
  g_autoptr(AtkObject) c1 =
      atk_object_ref_accessible_child(ATK_OBJECT(root), 0);
  EXPECT_EQ(ATK_OBJECT(child1), c1);
  g_autoptr(AtkObject) c2 =
      atk_object_ref_accessible_child(ATK_OBJECT(root), 1);
  EXPECT_EQ(ATK_OBJECT(child2), c2);
  EXPECT_EQ(atk_object_get_parent(ATK_OBJECT(root)), nullptr);
 
  EXPECT_EQ(atk_object_get_parent(ATK_OBJECT(child1)), ATK_OBJECT(root));
  EXPECT_EQ(atk_object_get_index_in_parent(ATK_OBJECT(child1)), 0);
  EXPECT_EQ(atk_object_get_n_accessible_children(ATK_OBJECT(child1)), 0);
 
  EXPECT_EQ(atk_object_get_parent(ATK_OBJECT(child2)), ATK_OBJECT(root));
  EXPECT_EQ(atk_object_get_index_in_parent(ATK_OBJECT(child2)), 1);
  EXPECT_EQ(atk_object_get_n_accessible_children(ATK_OBJECT(child2)), 0);
}

References engine, fl_accessible_node_new(), fl_accessible_node_set_children(), fl_accessible_node_set_parent(), g_autoptr(), and view_id.

TEST_F() [2/15]

TEST_F	(	FlAccessibleNodeTest	,
		CheckedAndToggledFlags
	)

Definition at line 106 of file fl_accessible_node_test.cc.

                                                     {
  g_autoptr(FlAccessibleNode) node = fl_accessible_node_new(engine, 123, 0);
 
  FlutterSemanticsFlags flags1 = {};
  flags1.is_checked = kFlutterCheckStateNone;
  flags1.is_toggled = kFlutterTristateNone;
  fl_accessible_node_set_flags(node, &flags1);
  AtkStateSet* state1 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_FALSE(atk_state_set_contains_state(state1, ATK_STATE_CHECKABLE));
  EXPECT_FALSE(atk_state_set_contains_state(state1, ATK_STATE_CHECKED));
  g_object_unref(state1);
 
  FlutterSemanticsFlags flags2 = {};
  flags2.is_checked = kFlutterCheckStateFalse;
  flags2.is_toggled = kFlutterTristateFalse;
  EXPECT_CALL(mock_gtk, atk_object_notify_state_change(
                            ::testing::_, ATK_STATE_CHECKABLE, TRUE));
  fl_accessible_node_set_flags(node, &flags2);
  AtkStateSet* state2 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_TRUE(atk_state_set_contains_state(state2, ATK_STATE_CHECKABLE));
  EXPECT_FALSE(atk_state_set_contains_state(state2, ATK_STATE_CHECKED));
  g_object_unref(state2);
 
  FlutterSemanticsFlags flags3 = {};
  flags3.is_checked = kFlutterCheckStateTrue;
  flags3.is_toggled = kFlutterTristateTrue;
  EXPECT_CALL(mock_gtk, atk_object_notify_state_change(
                            ::testing::_, ATK_STATE_CHECKED, TRUE));
  fl_accessible_node_set_flags(node, &flags3);
  AtkStateSet* state3 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_TRUE(atk_state_set_contains_state(state3, ATK_STATE_CHECKABLE));
  EXPECT_TRUE(atk_state_set_contains_state(state3, ATK_STATE_CHECKED));
  g_object_unref(state3);
 
  FlutterSemanticsFlags flags4 = {};
  flags4.is_checked = kFlutterCheckStateTrue;
  flags4.is_toggled = kFlutterTristateNone;
  fl_accessible_node_set_flags(node, &flags4);
  AtkStateSet* state4 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_TRUE(atk_state_set_contains_state(state4, ATK_STATE_CHECKABLE));
  EXPECT_TRUE(atk_state_set_contains_state(state4, ATK_STATE_CHECKED));
  g_object_unref(state4);
 
  FlutterSemanticsFlags flags5 = {};
  flags5.is_checked = kFlutterCheckStateNone;
  flags5.is_toggled = kFlutterTristateTrue;
  fl_accessible_node_set_flags(node, &flags5);
  AtkStateSet* state5 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_TRUE(atk_state_set_contains_state(state5, ATK_STATE_CHECKABLE));
  EXPECT_TRUE(atk_state_set_contains_state(state5, ATK_STATE_CHECKED));
  g_object_unref(state5);
}

References atk_object_notify_state_change(), engine, fl_accessible_node_new(), fl_accessible_node_set_flags(), g_autoptr(), FlutterSemanticsFlags::is_checked, FlutterSemanticsFlags::is_toggled, kFlutterCheckStateFalse, kFlutterCheckStateNone, kFlutterCheckStateTrue, kFlutterTristateFalse, kFlutterTristateNone, kFlutterTristateTrue, and TRUE.

TEST_F() [3/15]

TEST_F	(	FlAccessibleNodeTest	,
		EnabledFlags
	)

Definition at line 188 of file fl_accessible_node_test.cc.

                                           {
  g_autoptr(FlAccessibleNode) node = fl_accessible_node_new(engine, 123, 0);
 
  FlutterSemanticsFlags flags1 = {};
  flags1.is_enabled = kFlutterTristateNone;
  fl_accessible_node_set_flags(node, &flags1);
  AtkStateSet* state1 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_FALSE(atk_state_set_contains_state(state1, ATK_STATE_SENSITIVE));
  EXPECT_FALSE(atk_state_set_contains_state(state1, ATK_STATE_ENABLED));
  g_object_unref(state1);
 
  FlutterSemanticsFlags flags2 = {};
  flags2.is_enabled = kFlutterTristateFalse;
  EXPECT_CALL(mock_gtk, atk_object_notify_state_change(
                            ::testing::_, ATK_STATE_SENSITIVE, TRUE));
  fl_accessible_node_set_flags(node, &flags2);
  AtkStateSet* state2 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_TRUE(atk_state_set_contains_state(state2, ATK_STATE_SENSITIVE));
  EXPECT_FALSE(atk_state_set_contains_state(state2, ATK_STATE_ENABLED));
  g_object_unref(state2);
 
  FlutterSemanticsFlags flags3 = {};
  flags3.is_enabled = kFlutterTristateTrue;
  EXPECT_CALL(mock_gtk, atk_object_notify_state_change(
                            ::testing::_, ATK_STATE_ENABLED, TRUE));
  fl_accessible_node_set_flags(node, &flags3);
  AtkStateSet* state3 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_TRUE(atk_state_set_contains_state(state3, ATK_STATE_SENSITIVE));
  EXPECT_TRUE(atk_state_set_contains_state(state3, ATK_STATE_ENABLED));
  g_object_unref(state3);
}

References atk_object_notify_state_change(), engine, fl_accessible_node_new(), fl_accessible_node_set_flags(), g_autoptr(), FlutterSemanticsFlags::is_enabled, kFlutterTristateFalse, kFlutterTristateNone, kFlutterTristateTrue, and TRUE.

TEST_F() [4/15]

TEST_F	(	FlAccessibleNodeTest	,
		FocusedFlags
	)

Definition at line 73 of file fl_accessible_node_test.cc.

                                           {
  g_autoptr(FlAccessibleNode) node = fl_accessible_node_new(engine, 123, 0);
 
  FlutterSemanticsFlags flags1 = {};
  flags1.is_focused = kFlutterTristateNone;
  fl_accessible_node_set_flags(node, &flags1);
  AtkStateSet* state1 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_FALSE(atk_state_set_contains_state(state1, ATK_STATE_FOCUSABLE));
  EXPECT_FALSE(atk_state_set_contains_state(state1, ATK_STATE_FOCUSED));
  g_object_unref(state1);
 
  FlutterSemanticsFlags flags2 = {};
  flags2.is_focused = kFlutterTristateFalse;
  EXPECT_CALL(mock_gtk, atk_object_notify_state_change(
                            ::testing::_, ATK_STATE_FOCUSABLE, TRUE));
  fl_accessible_node_set_flags(node, &flags2);
  AtkStateSet* state2 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_TRUE(atk_state_set_contains_state(state2, ATK_STATE_FOCUSABLE));
  EXPECT_FALSE(atk_state_set_contains_state(state2, ATK_STATE_FOCUSED));
  g_object_unref(state2);
 
  FlutterSemanticsFlags flags3 = {};
  flags3.is_focused = kFlutterTristateTrue;
  EXPECT_CALL(mock_gtk, atk_object_notify_state_change(
                            ::testing::_, ATK_STATE_FOCUSED, TRUE));
  fl_accessible_node_set_flags(node, &flags3);
  AtkStateSet* state3 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_TRUE(atk_state_set_contains_state(state3, ATK_STATE_FOCUSABLE));
  EXPECT_TRUE(atk_state_set_contains_state(state3, ATK_STATE_FOCUSED));
  g_object_unref(state3);
}

References atk_object_notify_state_change(), engine, fl_accessible_node_new(), fl_accessible_node_set_flags(), g_autoptr(), FlutterSemanticsFlags::is_focused, kFlutterTristateFalse, kFlutterTristateNone, kFlutterTristateTrue, and TRUE.

TEST_F() [5/15]

TEST_F	(	FlAccessibleNodeTest	,
		GetRole
	)

Definition at line 305 of file fl_accessible_node_test.cc.

                                      {
  g_autoptr(FlAccessibleNode) node = fl_accessible_node_new(engine, 123, 0);
 
  FlutterSemanticsFlags flags1 = {};
  flags1.is_button = true;
  fl_accessible_node_set_flags(node, &flags1);
  EXPECT_EQ(atk_object_get_role(ATK_OBJECT(node)), ATK_ROLE_PUSH_BUTTON);
 
  FlutterSemanticsFlags flags2 = {};
  flags2.is_checked = kFlutterCheckStateFalse;
  fl_accessible_node_set_flags(node, &flags2);
  EXPECT_EQ(atk_object_get_role(ATK_OBJECT(node)), ATK_ROLE_CHECK_BOX);
 
  FlutterSemanticsFlags flags3 = {};
  flags3.is_checked = kFlutterCheckStateFalse;
  flags3.is_in_mutually_exclusive_group = true;
  fl_accessible_node_set_flags(node, &flags3);
  EXPECT_EQ(atk_object_get_role(ATK_OBJECT(node)), ATK_ROLE_RADIO_BUTTON);
 
  FlutterSemanticsFlags flags4 = {};
  flags4.is_toggled = kFlutterTristateFalse;
  fl_accessible_node_set_flags(node, &flags4);
  EXPECT_EQ(atk_object_get_role(ATK_OBJECT(node)), ATK_ROLE_TOGGLE_BUTTON);
 
  FlutterSemanticsFlags flags5 = {};
  flags5.is_text_field = true;
  fl_accessible_node_set_flags(node, &flags5);
  EXPECT_EQ(atk_object_get_role(ATK_OBJECT(node)), ATK_ROLE_TEXT);
 
  FlutterSemanticsFlags flags6 = {};
  flags6.is_text_field = true;
  flags6.is_obscured = true;
  fl_accessible_node_set_flags(node, &flags6);
  EXPECT_EQ(atk_object_get_role(ATK_OBJECT(node)), ATK_ROLE_PASSWORD_TEXT);
}

References engine, fl_accessible_node_new(), fl_accessible_node_set_flags(), g_autoptr(), FlutterSemanticsFlags::is_button, FlutterSemanticsFlags::is_checked, FlutterSemanticsFlags::is_in_mutually_exclusive_group, FlutterSemanticsFlags::is_obscured, FlutterSemanticsFlags::is_text_field, FlutterSemanticsFlags::is_toggled, kFlutterCheckStateFalse, and kFlutterTristateFalse.

TEST_F() [6/15]

TEST_F	(	FlAccessibleNodeTest	,
		HiddenFlags
	)

Definition at line 242 of file fl_accessible_node_test.cc.

                                          {
  g_autoptr(FlAccessibleNode) node = fl_accessible_node_new(engine, 123, 0);
 
  FlutterSemanticsFlags flags1 = {};
  flags1.is_hidden = true;
  fl_accessible_node_set_flags(node, &flags1);
  AtkStateSet* state1 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_FALSE(atk_state_set_contains_state(state1, ATK_STATE_VISIBLE));
  g_object_unref(state1);
 
  FlutterSemanticsFlags flags2 = {};
  flags2.is_hidden = false;
  EXPECT_CALL(mock_gtk, atk_object_notify_state_change(
                            ::testing::_, ATK_STATE_VISIBLE, TRUE));
  fl_accessible_node_set_flags(node, &flags2);
  AtkStateSet* state2 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_TRUE(atk_state_set_contains_state(state2, ATK_STATE_VISIBLE));
  g_object_unref(state2);
}

References atk_object_notify_state_change(), engine, fl_accessible_node_new(), fl_accessible_node_set_flags(), g_autoptr(), FlutterSemanticsFlags::is_hidden, and TRUE.

TEST_F() [7/15]

TEST_F	(	FlAccessibleNodeTest	,
		ObscuredFlags
	)

Definition at line 221 of file fl_accessible_node_test.cc.

                                            {
  g_autoptr(FlAccessibleNode) node = fl_accessible_node_new(engine, 123, 0);
 
  FlutterSemanticsFlags flags1 = {};
  flags1.is_obscured = true;
  fl_accessible_node_set_flags(node, &flags1);
  AtkStateSet* state1 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_FALSE(atk_state_set_contains_state(state1, ATK_STATE_SHOWING));
  g_object_unref(state1);
 
  FlutterSemanticsFlags flags2 = {};
  flags2.is_obscured = false;
  EXPECT_CALL(mock_gtk, atk_object_notify_state_change(
                            ::testing::_, ATK_STATE_SHOWING, TRUE));
  fl_accessible_node_set_flags(node, &flags2);
  AtkStateSet* state2 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_TRUE(atk_state_set_contains_state(state2, ATK_STATE_SHOWING));
  g_object_unref(state2);
}

References atk_object_notify_state_change(), engine, fl_accessible_node_new(), fl_accessible_node_set_flags(), g_autoptr(), FlutterSemanticsFlags::is_obscured, and TRUE.

TEST_F() [8/15]

TEST_F	(	FlAccessibleNodeTest	,
		ReadOnlyFlags
	)

Definition at line 263 of file fl_accessible_node_test.cc.

                                            {
  g_autoptr(FlAccessibleNode) node = fl_accessible_node_new(engine, 123, 0);
 
  FlutterSemanticsFlags flags1 = {};
  flags1.is_read_only = false;
  fl_accessible_node_set_flags(node, &flags1);
  AtkStateSet* state1 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_FALSE(atk_state_set_contains_state(state1, ATK_STATE_READ_ONLY));
  g_object_unref(state1);
 
  FlutterSemanticsFlags flags2 = {};
  flags2.is_read_only = true;
  EXPECT_CALL(mock_gtk, atk_object_notify_state_change(
                            ::testing::_, ATK_STATE_READ_ONLY, TRUE));
  fl_accessible_node_set_flags(node, &flags2);
  AtkStateSet* state2 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_TRUE(atk_state_set_contains_state(state2, ATK_STATE_READ_ONLY));
  g_object_unref(state2);
}

References atk_object_notify_state_change(), engine, fl_accessible_node_new(), fl_accessible_node_set_flags(), g_autoptr(), FlutterSemanticsFlags::is_read_only, and TRUE.

TEST_F() [9/15]

TEST_F	(	FlAccessibleNodeTest	,
		SelectedFlags
	)

Definition at line 160 of file fl_accessible_node_test.cc.

                                            {
  g_autoptr(FlAccessibleNode) node = fl_accessible_node_new(engine, 123, 0);
 
  FlutterSemanticsFlags flags1 = {};
  flags1.is_selected = kFlutterTristateNone;
  fl_accessible_node_set_flags(node, &flags1);
  AtkStateSet* state1 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_FALSE(atk_state_set_contains_state(state1, ATK_STATE_SELECTED));
  g_object_unref(state1);
 
  FlutterSemanticsFlags flags2 = {};
  flags2.is_selected = kFlutterTristateFalse;
  fl_accessible_node_set_flags(node, &flags2);
  AtkStateSet* state2 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_FALSE(atk_state_set_contains_state(state2, ATK_STATE_SELECTED));
  g_object_unref(state2);
 
  FlutterSemanticsFlags flags3 = {};
  flags3.is_selected = kFlutterTristateTrue;
  EXPECT_CALL(mock_gtk, atk_object_notify_state_change(
                            ::testing::_, ATK_STATE_SELECTED, TRUE));
  fl_accessible_node_set_flags(node, &flags3);
  AtkStateSet* state3 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_TRUE(atk_state_set_contains_state(state3, ATK_STATE_SELECTED));
  g_object_unref(state3);
}

References atk_object_notify_state_change(), engine, fl_accessible_node_new(), fl_accessible_node_set_flags(), g_autoptr(), FlutterSemanticsFlags::is_selected, kFlutterTristateFalse, kFlutterTristateNone, kFlutterTristateTrue, and TRUE.

TEST_F() [10/15]

TEST_F	(	FlAccessibleNodeTest	,
		SetActions
	)

Definition at line 342 of file fl_accessible_node_test.cc.

                                         {
  g_autoptr(FlAccessibleNode) node = fl_accessible_node_new(engine, 123, 0);
  fl_accessible_node_set_actions(
      node, static_cast<FlutterSemanticsAction>(
                kFlutterSemanticsActionTap | kFlutterSemanticsActionLongPress));
 
  EXPECT_EQ(atk_action_get_n_actions(ATK_ACTION(node)), 2);
  EXPECT_STREQ(atk_action_get_name(ATK_ACTION(node), 0), "Tap");
  EXPECT_STREQ(atk_action_get_name(ATK_ACTION(node), 1), "LongPress");
}

References engine, fl_accessible_node_new(), fl_accessible_node_set_actions(), g_autoptr(), kFlutterSemanticsActionLongPress, and kFlutterSemanticsActionTap.

TEST_F() [11/15]

TEST_F	(	FlAccessibleNodeTest	,
		SetExtents
	)

Definition at line 60 of file fl_accessible_node_test.cc.

                                         {
  g_autoptr(FlAccessibleNode) node = fl_accessible_node_new(engine, 123, 0);
  fl_accessible_node_set_extents(node, 1, 2, 3, 4);
  gint x, y, width, height;
  atk_component_get_extents(ATK_COMPONENT(node), &x, &y, &width, &height,
                            ATK_XY_PARENT);
  EXPECT_EQ(x, 1);
  EXPECT_EQ(y, 2);
  EXPECT_EQ(width, 3);
  EXPECT_EQ(height, 4);
}

References engine, fl_accessible_node_new(), fl_accessible_node_set_extents(), g_autoptr(), height, width, x, and y.

TEST_F() [12/15]

TEST_F	(	FlAccessibleNodeTest	,
		SetName
	)

Definition at line 53 of file fl_accessible_node_test.cc.

                                      {
  g_autoptr(FlAccessibleNode) node = fl_accessible_node_new(engine, 123, 0);
  fl_accessible_node_set_name(node, "test");
  EXPECT_STREQ(atk_object_get_name(ATK_OBJECT(node)), "test");
}

References engine, fl_accessible_node_new(), fl_accessible_node_set_name(), and g_autoptr().

TEST_F() [13/15]

TEST_F	(	FlAccessibleNodeTest	,
		SurvivesEngineDestruction
	)

Definition at line 356 of file fl_accessible_node_test.cc.

                                                        {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  FlEngine* local_engine = fl_engine_new(project);
  g_autoptr(FlAccessibleNode) node =
      fl_accessible_node_new(local_engine, 123, 0);
  fl_accessible_node_set_actions(node, kFlutterSemanticsActionTap);
 
  // Destroy the engine while the node is still alive.
  g_object_unref(local_engine);
 
  // Performing an action no longer reaches the engine, but does not crash.
  EXPECT_FALSE(atk_action_do_action(ATK_ACTION(node), 0));
}

References fl_accessible_node_new(), fl_accessible_node_set_actions(), fl_dart_project_new(), fl_engine_new(), g_autoptr(), and kFlutterSemanticsActionTap.

TEST_F() [14/15]

TEST_F	(	FlAccessibleNodeTest	,
		SurvivesParentDestruction
	)

Definition at line 372 of file fl_accessible_node_test.cc.

                                                        {
  FlAccessibleNode* root = fl_accessible_node_new(engine, 123, 0);
  g_autoptr(FlAccessibleNode) child = fl_accessible_node_new(engine, 123, 1);
  fl_accessible_node_set_parent(child, ATK_OBJECT(root), 0);
 
  // Destroy the parent while the child is still alive.
  g_object_unref(root);
 
  // The child no longer reports a parent, but does not crash.
  EXPECT_EQ(atk_object_get_parent(ATK_OBJECT(child)), nullptr);
  gint x = 0, y = 0, width = 0, height = 0;
  atk_component_get_extents(ATK_COMPONENT(child), &x, &y, &width, &height,
                            ATK_XY_SCREEN);
}

References engine, fl_accessible_node_new(), fl_accessible_node_set_parent(), g_autoptr(), height, width, x, and y.

TEST_F() [15/15]

TEST_F	(	FlAccessibleNodeTest	,
		TextFieldFlags
	)

Definition at line 284 of file fl_accessible_node_test.cc.

                                             {
  g_autoptr(FlAccessibleNode) node = fl_accessible_node_new(engine, 123, 0);
 
  FlutterSemanticsFlags flags1 = {};
  flags1.is_text_field = false;
  fl_accessible_node_set_flags(node, &flags1);
  AtkStateSet* state1 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_FALSE(atk_state_set_contains_state(state1, ATK_STATE_EDITABLE));
  g_object_unref(state1);
 
  FlutterSemanticsFlags flags2 = {};
  flags2.is_text_field = true;
  EXPECT_CALL(mock_gtk, atk_object_notify_state_change(
                            ::testing::_, ATK_STATE_EDITABLE, TRUE));
  fl_accessible_node_set_flags(node, &flags2);
  AtkStateSet* state2 = atk_object_ref_state_set(ATK_OBJECT(node));
  EXPECT_TRUE(atk_state_set_contains_state(state2, ATK_STATE_EDITABLE));
  g_object_unref(state2);
}

References atk_object_notify_state_change(), engine, fl_accessible_node_new(), fl_accessible_node_set_flags(), g_autoptr(), FlutterSemanticsFlags::is_text_field, and TRUE.