Flutter Linux Embedder
Functions | Variables
flutter::testing Namespace Reference

Functions

FlutterSemanticsNode2 CreateSemanticsNode (int32_t id, const char *label, const std::vector< int32_t > *children=nullptr)
 
 TEST (AccessibilityBridgeTest, BasicTest)
 
 TEST (AccessibilityBridgeTest, AccessibilityRootId)
 
 TEST (AccessibilityBridgeTest, AddOrder)
 
 TEST (AccessibilityBridgeTest, CanFireChildrenChangedCorrectly)
 
 TEST (AccessibilityBridgeTest, CanHandleSelectionChangeCorrectly)
 
 TEST (AccessibilityBridgeTest, DoesNotAssignEditableRootToSelectableText)
 
 TEST (AccessibilityBridgeTest, SwitchHasSwitchRole)
 
 TEST (AccessibilityBridgeTest, SliderHasSliderRole)
 
 TEST (AccessibilityBridgeTest, CanSetCheckboxChecked)
 
 TEST (AccessibilityBridgeTest, CanReparentNode)
 
 TEST (AccessibilityBridgeTest, CanReparentMultipleNodes)
 
 TEST (AccessibilityBridgeTest, CanReparentNodeWithChild)
 
 TEST (AccessibilityBridgeTest, AXTreeManagerTest)
 
 TEST (AccessibilityBridgeTest, LineBreakingObjectTest)
 
 TEST (FlutterPlatformNodeDelegateTest, NodeDelegateHasUniqueId)
 
 TEST (FlutterPlatformNodeDelegateTest, canPerfomActions)
 
 TEST (FlutterPlatformNodeDelegateTest, canGetAXNode)
 
 TEST (FlutterPlatformNodeDelegateTest, canCalculateBoundsCorrectly)
 
 TEST (FlutterPlatformNodeDelegateTest, canCalculateOffScreenBoundsCorrectly)
 
 TEST (FlutterPlatformNodeDelegateTest, canUseOwnerBridge)
 
 TEST (FlutterPlatformNodeDelegateTest, selfIsLowestPlatformAncestor)
 
 TEST (FlutterPlatformNodeDelegateTest, canGetFromNodeID)
 

Variables

FlutterSemanticsFlags kEmptyFlags = FlutterSemanticsFlags{}
 

Function Documentation

◆ CreateSemanticsNode()

FlutterSemanticsNode2 flutter::testing::CreateSemanticsNode ( int32_t  id,
const char *  label,
const std::vector< int32_t > *  children = nullptr 
)

Definition at line 20 of file accessibility_bridge_unittests.cc.

23  {
24  return {
25  .id = id,
26  // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
27  .flags__deprecated__ = static_cast<FlutterSemanticsFlag>(0),
28  // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
29  .actions = static_cast<FlutterSemanticsAction>(0),
30  .text_selection_base = -1,
31  .text_selection_extent = -1,
32  .label = label,
33  .hint = "",
34  .value = "",
35  .increased_value = "",
36  .decreased_value = "",
37  .child_count = children ? children->size() : 0,
38  .children_in_traversal_order = children ? children->data() : nullptr,
39  .custom_accessibility_actions_count = 0,
40  .tooltip = "",
41  .flags2 = &kEmptyFlags,
42  };
43 }
id
int64_t id
Definition: fl_pixel_buffer_texture.cc:28
flutter::testing::kEmptyFlags
FlutterSemanticsFlags kEmptyFlags
Definition: accessibility_bridge_unittests.cc:18

References id, and kEmptyFlags.

Referenced by TEST().

◆ TEST() [1/22]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
AccessibilityRootId   
)

Definition at line 77 of file accessibility_bridge_unittests.cc.

77  {
78  std::shared_ptr<TestAccessibilityBridge> bridge =
79  std::make_shared<TestAccessibilityBridge>();
80 
81  std::vector<int32_t> children{456, 789};
82  FlutterSemanticsNode2 root = CreateSemanticsNode(123, "root", &children);
83  FlutterSemanticsNode2 child1 = CreateSemanticsNode(456, "child 1");
84  FlutterSemanticsNode2 child2 = CreateSemanticsNode(789, "child 2");
85 
86  bridge->AddFlutterSemanticsNodeUpdate(root);
87  bridge->AddFlutterSemanticsNodeUpdate(child1);
88  bridge->AddFlutterSemanticsNodeUpdate(child2);
89  bridge->CommitUpdates();
90 
91  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(123).lock();
92  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(456).lock();
93  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(789).lock();
94  auto fake_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
95 
96  EXPECT_EQ(bridge->GetRootAsAXNode()->id(), 123);
97  EXPECT_EQ(bridge->RootDelegate()->GetName(), "root");
98 
99  EXPECT_EQ(root_node->GetChildCount(), 2);
100  EXPECT_EQ(root_node->GetData().child_ids[0], 456);
101  EXPECT_EQ(root_node->GetData().child_ids[1], 789);
102  EXPECT_EQ(root_node->GetName(), "root");
103 
104  EXPECT_EQ(child1_node->GetChildCount(), 0);
105  EXPECT_EQ(child1_node->GetName(), "child 1");
106 
107  EXPECT_EQ(child2_node->GetChildCount(), 0);
108  EXPECT_EQ(child2_node->GetName(), "child 2");
109 
110  ASSERT_FALSE(fake_delegate);
111 }
flutter::testing::CreateSemanticsNode
FlutterSemanticsNode2 CreateSemanticsNode(int32_t id, const char *label, const std::vector< int32_t > *children=nullptr)
Definition: accessibility_bridge_unittests.cc:20

References CreateSemanticsNode().

◆ TEST() [2/22]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
AddOrder   
)

Definition at line 114 of file accessibility_bridge_unittests.cc.

114  {
115  std::shared_ptr<TestAccessibilityBridge> bridge =
116  std::make_shared<TestAccessibilityBridge>();
117 
118  std::vector<int32_t> root_children{34, 56};
119  std::vector<int32_t> child2_children{78};
120  std::vector<int32_t> child3_children{90};
121  FlutterSemanticsNode2 root = CreateSemanticsNode(12, "root", &root_children);
122  FlutterSemanticsNode2 child1 = CreateSemanticsNode(34, "child 1");
123  FlutterSemanticsNode2 child2 =
124  CreateSemanticsNode(56, "child 2", &child2_children);
125  FlutterSemanticsNode2 child3 =
126  CreateSemanticsNode(78, "child 3", &child3_children);
127  FlutterSemanticsNode2 child4 = CreateSemanticsNode(90, "child 4");
128 
129  bridge->AddFlutterSemanticsNodeUpdate(child3);
130  bridge->AddFlutterSemanticsNodeUpdate(child2);
131  bridge->AddFlutterSemanticsNodeUpdate(root);
132  bridge->AddFlutterSemanticsNodeUpdate(child1);
133  bridge->AddFlutterSemanticsNodeUpdate(child4);
134  bridge->CommitUpdates();
135 
136  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(12).lock();
137  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(34).lock();
138  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(56).lock();
139  auto child3_node = bridge->GetFlutterPlatformNodeDelegateFromID(78).lock();
140  auto child4_node = bridge->GetFlutterPlatformNodeDelegateFromID(90).lock();
141 
142  EXPECT_EQ(bridge->GetRootAsAXNode()->id(), 12);
143  EXPECT_EQ(bridge->RootDelegate()->GetName(), "root");
144 
145  EXPECT_EQ(root_node->GetChildCount(), 2);
146  EXPECT_EQ(root_node->GetData().child_ids[0], 34);
147  EXPECT_EQ(root_node->GetData().child_ids[1], 56);
148  EXPECT_EQ(root_node->GetName(), "root");
149 
150  EXPECT_EQ(child1_node->GetChildCount(), 0);
151  EXPECT_EQ(child1_node->GetName(), "child 1");
152 
153  EXPECT_EQ(child2_node->GetChildCount(), 1);
154  EXPECT_EQ(child2_node->GetData().child_ids[0], 78);
155  EXPECT_EQ(child2_node->GetName(), "child 2");
156 
157  EXPECT_EQ(child3_node->GetChildCount(), 1);
158  EXPECT_EQ(child3_node->GetData().child_ids[0], 90);
159  EXPECT_EQ(child3_node->GetName(), "child 3");
160 
161  EXPECT_EQ(child4_node->GetChildCount(), 0);
162  EXPECT_EQ(child4_node->GetName(), "child 4");
163 }

References CreateSemanticsNode().

◆ TEST() [3/22]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
AXTreeManagerTest   
)

Definition at line 564 of file accessibility_bridge_unittests.cc.

564  {
565  std::shared_ptr<TestAccessibilityBridge> bridge =
566  std::make_shared<TestAccessibilityBridge>();
567 
568  ui::AXTreeID tree_id = bridge->GetTreeID();
569  ui::AXTreeManager* manager =
570  ui::AXTreeManagerMap::GetInstance().GetManager(tree_id);
571  ASSERT_EQ(manager, static_cast<ui::AXTreeManager*>(bridge.get()));
572 }

◆ TEST() [4/22]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
BasicTest   
)

Definition at line 45 of file accessibility_bridge_unittests.cc.

45  {
46  std::shared_ptr<TestAccessibilityBridge> bridge =
47  std::make_shared<TestAccessibilityBridge>();
48 
49  std::vector<int32_t> children{1, 2};
50  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root", &children);
51  FlutterSemanticsNode2 child1 = CreateSemanticsNode(1, "child 1");
52  FlutterSemanticsNode2 child2 = CreateSemanticsNode(2, "child 2");
53 
54  bridge->AddFlutterSemanticsNodeUpdate(root);
55  bridge->AddFlutterSemanticsNodeUpdate(child1);
56  bridge->AddFlutterSemanticsNodeUpdate(child2);
57  bridge->CommitUpdates();
58 
59  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
60  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
61  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
62  EXPECT_EQ(root_node->GetChildCount(), 2);
63  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
64  EXPECT_EQ(root_node->GetData().child_ids[1], 2);
65  EXPECT_EQ(root_node->GetName(), "root");
66 
67  EXPECT_EQ(child1_node->GetChildCount(), 0);
68  EXPECT_EQ(child1_node->GetName(), "child 1");
69 
70  EXPECT_EQ(child2_node->GetChildCount(), 0);
71  EXPECT_EQ(child2_node->GetName(), "child 2");
72 }

References CreateSemanticsNode().

◆ TEST() [5/22]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
CanFireChildrenChangedCorrectly   
)

Definition at line 165 of file accessibility_bridge_unittests.cc.

165  {
166  std::shared_ptr<TestAccessibilityBridge> bridge =
167  std::make_shared<TestAccessibilityBridge>();
168 
169  std::vector<int32_t> children{1};
170  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root", &children);
171  FlutterSemanticsNode2 child1 = CreateSemanticsNode(1, "child 1");
172 
173  bridge->AddFlutterSemanticsNodeUpdate(root);
174  bridge->AddFlutterSemanticsNodeUpdate(child1);
175 
176  bridge->CommitUpdates();
177 
178  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
179  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
180  EXPECT_EQ(root_node->GetChildCount(), 1);
181  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
182  EXPECT_EQ(root_node->GetName(), "root");
183 
184  EXPECT_EQ(child1_node->GetChildCount(), 0);
185  EXPECT_EQ(child1_node->GetName(), "child 1");
186  bridge->accessibility_events.clear();
187 
188  // Add a child to root.
189  root.child_count = 2;
190  int32_t new_children[] = {1, 2};
191  root.children_in_traversal_order = new_children;
192 
193  FlutterSemanticsNode2 child2 = CreateSemanticsNode(2, "child 2");
194 
195  bridge->AddFlutterSemanticsNodeUpdate(root);
196  bridge->AddFlutterSemanticsNodeUpdate(child2);
197  bridge->CommitUpdates();
198 
199  root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
200 
201  EXPECT_EQ(root_node->GetChildCount(), 2);
202  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
203  EXPECT_EQ(root_node->GetData().child_ids[1], 2);
204  EXPECT_EQ(bridge->accessibility_events.size(), size_t{2});
205  std::set<ui::AXEventGenerator::Event> actual_event{
206  bridge->accessibility_events.begin(), bridge->accessibility_events.end()};
207  EXPECT_THAT(actual_event,
208  Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED));
209  EXPECT_THAT(actual_event,
210  Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED));
211 }

References CreateSemanticsNode().

◆ TEST() [6/22]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
CanHandleSelectionChangeCorrectly   
)

Definition at line 213 of file accessibility_bridge_unittests.cc.

213  {
214  std::shared_ptr<TestAccessibilityBridge> bridge =
215  std::make_shared<TestAccessibilityBridge>();
216  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
217  auto flags = FlutterSemanticsFlags{
218  .is_focused = FlutterTristate::kFlutterTristateTrue,
219  .is_text_field = true,
220  };
221  root.flags2 = &flags;
222 
223  bridge->AddFlutterSemanticsNodeUpdate(root);
224  bridge->CommitUpdates();
225 
226  const ui::AXTreeData& tree = bridge->GetAXTreeData();
227  EXPECT_EQ(tree.sel_anchor_object_id, ui::AXNode::kInvalidAXID);
228  bridge->accessibility_events.clear();
229 
230  // Update the selection.
231  root.text_selection_base = 0;
232  root.text_selection_extent = 5;
233  bridge->AddFlutterSemanticsNodeUpdate(root);
234 
235  bridge->CommitUpdates();
236 
237  EXPECT_EQ(tree.sel_anchor_object_id, 0);
238  EXPECT_EQ(tree.sel_anchor_offset, 0);
239  EXPECT_EQ(tree.sel_focus_object_id, 0);
240  EXPECT_EQ(tree.sel_focus_offset, 5);
241  ASSERT_EQ(bridge->accessibility_events.size(), size_t{2});
242  EXPECT_EQ(bridge->accessibility_events[0],
243  ui::AXEventGenerator::Event::DOCUMENT_SELECTION_CHANGED);
244  EXPECT_EQ(bridge->accessibility_events[1],
245  ui::AXEventGenerator::Event::OTHER_ATTRIBUTE_CHANGED);
246 }

References CreateSemanticsNode().

◆ TEST() [7/22]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
CanReparentMultipleNodes   
)

Definition at line 390 of file accessibility_bridge_unittests.cc.

390  {
391  std::shared_ptr<TestAccessibilityBridge> bridge =
392  std::make_shared<TestAccessibilityBridge>();
393 
394  int32_t root_id = 0;
395  int32_t intermediary1_id = 1;
396  int32_t intermediary2_id = 2;
397  int32_t leaf1_id = 3;
398  int32_t leaf2_id = 4;
399  int32_t leaf3_id = 5;
400 
401  std::vector<int32_t> root_children{intermediary1_id, intermediary2_id};
402  std::vector<int32_t> intermediary1_children{leaf1_id};
403  std::vector<int32_t> intermediary2_children{leaf2_id, leaf3_id};
404  FlutterSemanticsNode2 root =
405  CreateSemanticsNode(root_id, "root", &root_children);
406  FlutterSemanticsNode2 intermediary1 = CreateSemanticsNode(
407  intermediary1_id, "intermediary 1", &intermediary1_children);
408  FlutterSemanticsNode2 intermediary2 = CreateSemanticsNode(
409  intermediary2_id, "intermediary 2", &intermediary2_children);
410  FlutterSemanticsNode2 leaf1 = CreateSemanticsNode(leaf1_id, "leaf 1");
411  FlutterSemanticsNode2 leaf2 = CreateSemanticsNode(leaf2_id, "leaf 2");
412  FlutterSemanticsNode2 leaf3 = CreateSemanticsNode(leaf3_id, "leaf 3");
413 
414  bridge->AddFlutterSemanticsNodeUpdate(root);
415  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
416  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
417  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
418  bridge->AddFlutterSemanticsNodeUpdate(leaf2);
419  bridge->AddFlutterSemanticsNodeUpdate(leaf3);
420  bridge->CommitUpdates();
421  bridge->accessibility_events.clear();
422 
423  // Swap intermediary 1's and intermediary2's children.
424  int32_t new_intermediary1_children[] = {leaf2_id, leaf3_id};
425  intermediary1.child_count = 2;
426  intermediary1.children_in_traversal_order = new_intermediary1_children;
427 
428  int32_t new_intermediary2_children[] = {leaf1_id};
429  intermediary2.child_count = 1;
430  intermediary2.children_in_traversal_order = new_intermediary2_children;
431 
432  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
433  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
434  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
435  bridge->AddFlutterSemanticsNodeUpdate(leaf2);
436  bridge->AddFlutterSemanticsNodeUpdate(leaf3);
437  bridge->CommitUpdates();
438 
439  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(root_id).lock();
440  auto intermediary1_node =
441  bridge->GetFlutterPlatformNodeDelegateFromID(intermediary1_id).lock();
442  auto intermediary2_node =
443  bridge->GetFlutterPlatformNodeDelegateFromID(intermediary2_id).lock();
444  auto leaf1_node =
445  bridge->GetFlutterPlatformNodeDelegateFromID(leaf1_id).lock();
446  auto leaf2_node =
447  bridge->GetFlutterPlatformNodeDelegateFromID(leaf2_id).lock();
448  auto leaf3_node =
449  bridge->GetFlutterPlatformNodeDelegateFromID(leaf3_id).lock();
450 
451  EXPECT_EQ(root_node->GetChildCount(), 2);
452  EXPECT_EQ(root_node->GetData().child_ids[0], intermediary1_id);
453  EXPECT_EQ(root_node->GetData().child_ids[1], intermediary2_id);
454  EXPECT_EQ(root_node->GetName(), "root");
455 
456  EXPECT_EQ(intermediary1_node->GetChildCount(), 2);
457  EXPECT_EQ(intermediary1_node->GetData().child_ids[0], leaf2_id);
458  EXPECT_EQ(intermediary1_node->GetData().child_ids[1], leaf3_id);
459  EXPECT_EQ(intermediary1_node->GetName(), "intermediary 1");
460 
461  EXPECT_EQ(intermediary2_node->GetChildCount(), 1);
462  EXPECT_EQ(intermediary2_node->GetData().child_ids[0], leaf1_id);
463  EXPECT_EQ(intermediary2_node->GetName(), "intermediary 2");
464 
465  EXPECT_EQ(leaf1_node->GetChildCount(), 0);
466  EXPECT_EQ(leaf1_node->GetName(), "leaf 1");
467 
468  EXPECT_EQ(leaf2_node->GetChildCount(), 0);
469  EXPECT_EQ(leaf2_node->GetName(), "leaf 2");
470 
471  EXPECT_EQ(leaf3_node->GetChildCount(), 0);
472  EXPECT_EQ(leaf3_node->GetName(), "leaf 3");
473 
474  // Intermediary 1 and intermediary 2 have new children.
475  // Leaf 1, 2, and 3 are all moved.
476  ASSERT_EQ(bridge->accessibility_events.size(), size_t{5});
477  EXPECT_THAT(bridge->accessibility_events,
478  Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED).Times(2));
479  EXPECT_THAT(bridge->accessibility_events,
480  Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED).Times(3));
481 }

References CreateSemanticsNode().

◆ TEST() [8/22]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
CanReparentNode   
)

Definition at line 327 of file accessibility_bridge_unittests.cc.

327  {
328  std::shared_ptr<TestAccessibilityBridge> bridge =
329  std::make_shared<TestAccessibilityBridge>();
330 
331  std::vector<int32_t> root_children{1};
332  std::vector<int32_t> child1_children{2};
333  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root", &root_children);
334  FlutterSemanticsNode2 child1 =
335  CreateSemanticsNode(1, "child 1", &child1_children);
336  FlutterSemanticsNode2 child2 = CreateSemanticsNode(2, "child 2");
337 
338  bridge->AddFlutterSemanticsNodeUpdate(root);
339  bridge->AddFlutterSemanticsNodeUpdate(child1);
340  bridge->AddFlutterSemanticsNodeUpdate(child2);
341  bridge->CommitUpdates();
342  bridge->accessibility_events.clear();
343 
344  // Reparent child2 from child1 to the root.
345  child1.child_count = 0;
346  child1.children_in_traversal_order = nullptr;
347 
348  int32_t new_root_children[] = {1, 2};
349  root.child_count = 2;
350  root.children_in_traversal_order = new_root_children;
351 
352  bridge->AddFlutterSemanticsNodeUpdate(root);
353  bridge->AddFlutterSemanticsNodeUpdate(child1);
354  bridge->AddFlutterSemanticsNodeUpdate(child2);
355  bridge->CommitUpdates();
356 
357  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
358  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
359  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
360 
361  EXPECT_EQ(root_node->GetChildCount(), 2);
362  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
363  EXPECT_EQ(root_node->GetData().child_ids[1], 2);
364  EXPECT_EQ(root_node->GetName(), "root");
365 
366  EXPECT_EQ(child1_node->GetChildCount(), 0);
367  EXPECT_EQ(child1_node->GetName(), "child 1");
368 
369  EXPECT_EQ(child2_node->GetChildCount(), 0);
370  EXPECT_EQ(child2_node->GetName(), "child 2");
371 
372  ASSERT_EQ(bridge->accessibility_events.size(), size_t{5});
373 
374  // Child2 is moved from child1 to root.
375  EXPECT_THAT(bridge->accessibility_events,
376  Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED).Times(2));
377  EXPECT_THAT(bridge->accessibility_events,
378  Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED).Times(1));
379 
380  // Child1 is no longer a parent. It loses its group role and disables its
381  // 'clip children' attribute.
382  EXPECT_THAT(
383  bridge->accessibility_events,
384  Contains(ui::AXEventGenerator::Event::OTHER_ATTRIBUTE_CHANGED).Times(1));
385  EXPECT_THAT(bridge->accessibility_events,
386  Contains(ui::AXEventGenerator::Event::ROLE_CHANGED).Times(1));
387 }

References CreateSemanticsNode().

◆ TEST() [9/22]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
CanReparentNodeWithChild   
)

Definition at line 484 of file accessibility_bridge_unittests.cc.

484  {
485  std::shared_ptr<TestAccessibilityBridge> bridge =
486  std::make_shared<TestAccessibilityBridge>();
487 
488  int32_t root_id = 0;
489  int32_t intermediary1_id = 1;
490  int32_t intermediary2_id = 2;
491  int32_t leaf1_id = 3;
492 
493  std::vector<int32_t> root_children{intermediary1_id, intermediary2_id};
494  std::vector<int32_t> intermediary1_children{leaf1_id};
495  FlutterSemanticsNode2 root =
496  CreateSemanticsNode(root_id, "root", &root_children);
497  FlutterSemanticsNode2 intermediary1 = CreateSemanticsNode(
498  intermediary1_id, "intermediary 1", &intermediary1_children);
499  FlutterSemanticsNode2 intermediary2 =
500  CreateSemanticsNode(intermediary2_id, "intermediary 2");
501  FlutterSemanticsNode2 leaf1 = CreateSemanticsNode(leaf1_id, "leaf 1");
502 
503  bridge->AddFlutterSemanticsNodeUpdate(root);
504  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
505  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
506  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
507  bridge->CommitUpdates();
508  bridge->accessibility_events.clear();
509 
510  // Move intermediary1 from root to intermediary 2.
511  int32_t new_root_children[] = {intermediary2_id};
512  root.child_count = 1;
513  root.children_in_traversal_order = new_root_children;
514 
515  int32_t new_intermediary2_children[] = {intermediary1_id};
516  intermediary2.child_count = 1;
517  intermediary2.children_in_traversal_order = new_intermediary2_children;
518 
519  bridge->AddFlutterSemanticsNodeUpdate(root);
520  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
521  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
522  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
523  bridge->CommitUpdates();
524 
525  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(root_id).lock();
526  auto intermediary1_node =
527  bridge->GetFlutterPlatformNodeDelegateFromID(intermediary1_id).lock();
528  auto intermediary2_node =
529  bridge->GetFlutterPlatformNodeDelegateFromID(intermediary2_id).lock();
530  auto leaf1_node =
531  bridge->GetFlutterPlatformNodeDelegateFromID(leaf1_id).lock();
532 
533  EXPECT_EQ(root_node->GetChildCount(), 1);
534  EXPECT_EQ(root_node->GetData().child_ids[0], intermediary2_id);
535  EXPECT_EQ(root_node->GetName(), "root");
536 
537  EXPECT_EQ(intermediary2_node->GetChildCount(), 1);
538  EXPECT_EQ(intermediary2_node->GetData().child_ids[0], intermediary1_id);
539  EXPECT_EQ(intermediary2_node->GetName(), "intermediary 2");
540 
541  EXPECT_EQ(intermediary1_node->GetChildCount(), 1);
542  EXPECT_EQ(intermediary1_node->GetData().child_ids[0], leaf1_id);
543  EXPECT_EQ(intermediary1_node->GetName(), "intermediary 1");
544 
545  EXPECT_EQ(leaf1_node->GetChildCount(), 0);
546  EXPECT_EQ(leaf1_node->GetName(), "leaf 1");
547 
548  ASSERT_EQ(bridge->accessibility_events.size(), size_t{5});
549 
550  EXPECT_THAT(bridge->accessibility_events,
551  Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED).Times(2));
552  EXPECT_THAT(bridge->accessibility_events,
553  Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED).Times(1));
554 
555  // Intermediary 2 becomes a parent node. It updates to group role and enables
556  // its 'clip children' attribute.
557  EXPECT_THAT(
558  bridge->accessibility_events,
559  Contains(ui::AXEventGenerator::Event::OTHER_ATTRIBUTE_CHANGED).Times(1));
560  EXPECT_THAT(bridge->accessibility_events,
561  Contains(ui::AXEventGenerator::Event::ROLE_CHANGED).Times(1));
562 }

References CreateSemanticsNode().

◆ TEST() [10/22]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
CanSetCheckboxChecked   
)

Definition at line 308 of file accessibility_bridge_unittests.cc.

308  {
309  std::shared_ptr<TestAccessibilityBridge> bridge =
310  std::make_shared<TestAccessibilityBridge>();
311  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
312  auto flags = FlutterSemanticsFlags{
313  .is_checked = FlutterCheckState::kFlutterCheckStateTrue,
314  };
315 
316  root.flags2 = &flags;
317  bridge->AddFlutterSemanticsNodeUpdate(root);
318  bridge->CommitUpdates();
319 
320  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
321  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
322  EXPECT_EQ(root_node->GetData().GetCheckedState(),
323  ax::mojom::CheckedState::kTrue);
324 }

References CreateSemanticsNode().

◆ TEST() [11/22]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
DoesNotAssignEditableRootToSelectableText   
)

Definition at line 248 of file accessibility_bridge_unittests.cc.

248  {
249  std::shared_ptr<TestAccessibilityBridge> bridge =
250  std::make_shared<TestAccessibilityBridge>();
251  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
252  auto flags = FlutterSemanticsFlags{
253  .is_text_field = true,
254  .is_read_only = true,
255  };
256  root.flags2 = &flags;
257 
258  bridge->AddFlutterSemanticsNodeUpdate(root);
259  bridge->CommitUpdates();
260 
261  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
262 
263  EXPECT_FALSE(root_node->GetData().GetBoolAttribute(
264  ax::mojom::BoolAttribute::kEditableRoot));
265 }

References CreateSemanticsNode().

◆ TEST() [12/22]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
LineBreakingObjectTest   
)

Definition at line 574 of file accessibility_bridge_unittests.cc.

574  {
575  std::shared_ptr<TestAccessibilityBridge> bridge =
576  std::make_shared<TestAccessibilityBridge>();
577 
578  const int32_t root_id = 0;
579 
580  FlutterSemanticsNode2 root = CreateSemanticsNode(root_id, "root", {});
581 
582  bridge->AddFlutterSemanticsNodeUpdate(root);
583  bridge->CommitUpdates();
584 
585  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(root_id).lock();
586  auto root_data = root_node->GetData();
587  EXPECT_TRUE(root_data.HasBoolAttribute(
588  ax::mojom::BoolAttribute::kIsLineBreakingObject));
589  EXPECT_TRUE(root_data.GetBoolAttribute(
590  ax::mojom::BoolAttribute::kIsLineBreakingObject));
591 }

References CreateSemanticsNode().

◆ TEST() [13/22]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
SliderHasSliderRole   
)

Definition at line 284 of file accessibility_bridge_unittests.cc.

284  {
285  std::shared_ptr<TestAccessibilityBridge> bridge =
286  std::make_shared<TestAccessibilityBridge>();
287  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
288  auto flags = FlutterSemanticsFlags{
289  .is_enabled = FlutterTristate::kFlutterTristateTrue,
290  .is_focused = FlutterTristate::kFlutterTristateFalse,
291  .is_slider = true,
292  };
293 
294  root.flags2 = &flags;
295 
296  bridge->AddFlutterSemanticsNodeUpdate(root);
297  bridge->CommitUpdates();
298 
299  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
300  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSlider);
301 }

References CreateSemanticsNode().

◆ TEST() [14/22]

flutter::testing::TEST ( AccessibilityBridgeTest  ,
SwitchHasSwitchRole   
)

Definition at line 267 of file accessibility_bridge_unittests.cc.

267  {
268  std::shared_ptr<TestAccessibilityBridge> bridge =
269  std::make_shared<TestAccessibilityBridge>();
270  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
271  auto flags = FlutterSemanticsFlags{
272  .is_enabled = FlutterTristate::kFlutterTristateTrue,
273  .is_toggled = FlutterTristate::kFlutterTristateFalse,
274  };
275 
276  root.flags2 = &flags;
277  bridge->AddFlutterSemanticsNodeUpdate(root);
278  bridge->CommitUpdates();
279 
280  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
281  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSwitch);
282 }

References CreateSemanticsNode().

◆ TEST() [15/22]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
canCalculateBoundsCorrectly   
)

Definition at line 119 of file flutter_platform_node_delegate_unittests.cc.

119  {
120  std::shared_ptr<TestAccessibilityBridge> bridge =
121  std::make_shared<TestAccessibilityBridge>();
122  FlutterSemanticsFlags flags = FlutterSemanticsFlags{0};
123  FlutterSemanticsNode2 root;
124  root.id = 0;
125  root.label = "root";
126  root.hint = "";
127  root.value = "";
128  root.increased_value = "";
129  root.decreased_value = "";
130  root.tooltip = "";
131  root.child_count = 1;
132  root.flags2 = &flags;
133  int32_t children[] = {1};
134  root.children_in_traversal_order = children;
135  root.custom_accessibility_actions_count = 0;
136  root.rect = {0, 0, 100, 100}; // LTRB
137  root.transform = {1, 0, 0, 0, 1, 0, 0, 0, 1};
138  bridge->AddFlutterSemanticsNodeUpdate(root);
139 
140  FlutterSemanticsNode2 child1;
141  child1.id = 1;
142  child1.label = "child 1";
143  child1.hint = "";
144  child1.value = "";
145  child1.increased_value = "";
146  child1.decreased_value = "";
147  child1.tooltip = "";
148  child1.child_count = 0;
149  child1.flags2 = &flags;
150  child1.custom_accessibility_actions_count = 0;
151  child1.rect = {0, 0, 50, 50}; // LTRB
152  child1.transform = {0.5, 0, 0, 0, 0.5, 0, 0, 0, 1};
153  bridge->AddFlutterSemanticsNodeUpdate(child1);
154 
155  bridge->CommitUpdates();
156  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
157  ui::AXOffscreenResult result;
158  gfx::Rect bounds =
159  child1_node->GetBoundsRect(ui::AXCoordinateSystem::kScreenDIPs,
160  ui::AXClippingBehavior::kClipped, &result);
161  EXPECT_EQ(bounds.x(), 0);
162  EXPECT_EQ(bounds.y(), 0);
163  EXPECT_EQ(bounds.width(), 25);
164  EXPECT_EQ(bounds.height(), 25);
165  EXPECT_EQ(result, ui::AXOffscreenResult::kOnscreen);
166 }

◆ TEST() [16/22]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
canCalculateOffScreenBoundsCorrectly   
)

Definition at line 168 of file flutter_platform_node_delegate_unittests.cc.

168  {
169  std::shared_ptr<TestAccessibilityBridge> bridge =
170  std::make_shared<TestAccessibilityBridge>();
171  FlutterSemanticsFlags flags = FlutterSemanticsFlags{0};
172  FlutterSemanticsNode2 root;
173  root.id = 0;
174  root.label = "root";
175  root.hint = "";
176  root.value = "";
177  root.increased_value = "";
178  root.decreased_value = "";
179  root.tooltip = "";
180  root.child_count = 1;
181  root.flags2 = &flags;
182  int32_t children[] = {1};
183  root.children_in_traversal_order = children;
184  root.custom_accessibility_actions_count = 0;
185  root.rect = {0, 0, 100, 100}; // LTRB
186  root.transform = {1, 0, 0, 0, 1, 0, 0, 0, 1};
187  bridge->AddFlutterSemanticsNodeUpdate(root);
188 
189  FlutterSemanticsNode2 child1;
190  child1.id = 1;
191  child1.label = "child 1";
192  child1.hint = "";
193  child1.value = "";
194  child1.increased_value = "";
195  child1.decreased_value = "";
196  child1.tooltip = "";
197  child1.child_count = 0;
198  child1.flags2 = &flags;
199  child1.custom_accessibility_actions_count = 0;
200  child1.rect = {90, 90, 100, 100}; // LTRB
201  child1.transform = {2, 0, 0, 0, 2, 0, 0, 0, 1};
202  bridge->AddFlutterSemanticsNodeUpdate(child1);
203 
204  bridge->CommitUpdates();
205  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
206  ui::AXOffscreenResult result;
207  gfx::Rect bounds =
208  child1_node->GetBoundsRect(ui::AXCoordinateSystem::kScreenDIPs,
209  ui::AXClippingBehavior::kUnclipped, &result);
210  EXPECT_EQ(bounds.x(), 180);
211  EXPECT_EQ(bounds.y(), 180);
212  EXPECT_EQ(bounds.width(), 20);
213  EXPECT_EQ(bounds.height(), 20);
214  EXPECT_EQ(result, ui::AXOffscreenResult::kOffscreen);
215 }

◆ TEST() [17/22]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
canGetAXNode   
)

Definition at line 90 of file flutter_platform_node_delegate_unittests.cc.

90  {
91  // Set up a flutter accessibility node.
92  std::shared_ptr<TestAccessibilityBridge> bridge =
93  std::make_shared<TestAccessibilityBridge>();
94  FlutterSemanticsNode2 root;
95  root.id = 0;
96  FlutterSemanticsFlags flags = FlutterSemanticsFlags{0};
97  flags.is_text_field = true;
98  root.flags2 = &flags;
99  // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
100  root.actions = static_cast<FlutterSemanticsAction>(0);
101  root.text_selection_base = -1;
102  root.text_selection_extent = -1;
103  root.label = "root";
104  root.hint = "";
105  root.value = "";
106  root.increased_value = "";
107  root.decreased_value = "";
108  root.tooltip = "";
109  root.child_count = 0;
110  root.custom_accessibility_actions_count = 0;
111  bridge->AddFlutterSemanticsNodeUpdate(root);
112 
113  bridge->CommitUpdates();
114 
115  auto accessibility = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
116  EXPECT_EQ(accessibility->GetData().id, 0);
117 }

◆ TEST() [18/22]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
canGetFromNodeID   
)

Definition at line 291 of file flutter_platform_node_delegate_unittests.cc.

291  {
292  std::shared_ptr<TestAccessibilityBridge> bridge =
293  std::make_shared<TestAccessibilityBridge>();
294  FlutterSemanticsFlags flags = FlutterSemanticsFlags{0};
295  FlutterSemanticsNode2 root;
296  root.id = 0;
297  root.label = "root";
298  root.hint = "";
299  root.value = "";
300  root.increased_value = "";
301  root.decreased_value = "";
302  root.tooltip = "";
303  root.child_count = 1;
304  root.flags2 = &flags;
305  int32_t children[] = {1};
306  root.children_in_traversal_order = children;
307  root.custom_accessibility_actions_count = 0;
308  bridge->AddFlutterSemanticsNodeUpdate(root);
309 
310  FlutterSemanticsNode2 child1;
311  child1.id = 1;
312  child1.label = "child 1";
313  child1.hint = "";
314  child1.value = "";
315  child1.increased_value = "";
316  child1.decreased_value = "";
317  child1.tooltip = "";
318  child1.child_count = 0;
319  child1.flags2 = &flags;
320  child1.custom_accessibility_actions_count = 0;
321  bridge->AddFlutterSemanticsNodeUpdate(child1);
322 
323  bridge->CommitUpdates();
324  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
325  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
326  auto node_by_id = root_node->GetFromNodeID(1);
327  EXPECT_EQ(child1_node->GetPlatformNode(), node_by_id);
328 }

◆ TEST() [19/22]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
canPerfomActions   
)

Definition at line 43 of file flutter_platform_node_delegate_unittests.cc.

43  {
44  std::shared_ptr<TestAccessibilityBridge> bridge =
45  std::make_shared<TestAccessibilityBridge>();
46  FlutterSemanticsNode2 root;
47  root.id = 0;
48  FlutterSemanticsFlags flags = FlutterSemanticsFlags{0};
49  flags.is_text_field = true;
50  root.flags2 = &flags;
51  // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
52  root.actions = static_cast<FlutterSemanticsAction>(0);
53  root.text_selection_base = -1;
54  root.text_selection_extent = -1;
55  root.label = "root";
56  root.hint = "";
57  root.value = "";
58  root.increased_value = "";
59  root.decreased_value = "";
60  root.tooltip = "";
61  root.child_count = 0;
62  root.custom_accessibility_actions_count = 0;
63  bridge->AddFlutterSemanticsNodeUpdate(root);
64 
65  bridge->CommitUpdates();
66 
67  auto accessibility = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
68  // Performs an AXAction.
69  ui::AXActionData action_data;
70  action_data.action = ax::mojom::Action::kDoDefault;
71  accessibility->AccessibilityPerformAction(action_data);
72  EXPECT_EQ(bridge->performed_actions.size(), size_t{1});
73  EXPECT_EQ(bridge->performed_actions[0],
74  FlutterSemanticsAction::kFlutterSemanticsActionTap);
75 
76  action_data.action = ax::mojom::Action::kFocus;
77  accessibility->AccessibilityPerformAction(action_data);
78  EXPECT_EQ(bridge->performed_actions.size(), size_t{2});
79  EXPECT_EQ(
80  bridge->performed_actions[1],
81  FlutterSemanticsAction::kFlutterSemanticsActionDidGainAccessibilityFocus);
82 
83  action_data.action = ax::mojom::Action::kScrollToMakeVisible;
84  accessibility->AccessibilityPerformAction(action_data);
85  EXPECT_EQ(bridge->performed_actions.size(), size_t{3});
86  EXPECT_EQ(bridge->performed_actions[2],
87  FlutterSemanticsAction::kFlutterSemanticsActionShowOnScreen);
88 }

◆ TEST() [20/22]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
canUseOwnerBridge   
)

Definition at line 217 of file flutter_platform_node_delegate_unittests.cc.

217  {
218  std::shared_ptr<TestAccessibilityBridge> bridge =
219  std::make_shared<TestAccessibilityBridge>();
220  FlutterSemanticsFlags flags = FlutterSemanticsFlags{0};
221  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
222  root.label = "root";
223  root.hint = "";
224  root.value = "";
225  root.increased_value = "";
226  root.decreased_value = "";
227  root.tooltip = "";
228  root.heading_level = 0;
229  root.child_count = 1;
230  root.flags2 = &flags;
231  int32_t children[] = {1};
232  root.children_in_traversal_order = children;
233  root.custom_accessibility_actions_count = 0;
234  root.rect = {0, 0, 100, 100}; // LTRB
235  root.transform = {1, 0, 0, 0, 1, 0, 0, 0, 1};
236  bridge->AddFlutterSemanticsNodeUpdate(root);
237 
238  FlutterSemanticsNode2 child1{sizeof(FlutterSemanticsNode2), 1};
239  child1.label = "child 1";
240  child1.hint = "";
241  child1.value = "";
242  child1.increased_value = "";
243  child1.decreased_value = "";
244  child1.tooltip = "";
245  child1.heading_level = 0;
246  child1.child_count = 0;
247  child1.flags2 = &flags;
248  child1.custom_accessibility_actions_count = 0;
249  child1.rect = {0, 0, 50, 50}; // LTRB
250  child1.transform = {0.5, 0, 0, 0, 0.5, 0, 0, 0, 1};
251  bridge->AddFlutterSemanticsNodeUpdate(child1);
252 
253  bridge->CommitUpdates();
254  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
255  auto owner_bridge = child1_node->GetOwnerBridge().lock();
256 
257  bool result;
258  gfx::RectF bounds = owner_bridge->RelativeToGlobalBounds(
259  child1_node->GetAXNode(), result, true);
260  EXPECT_EQ(bounds.x(), 0);
261  EXPECT_EQ(bounds.y(), 0);
262  EXPECT_EQ(bounds.width(), 25);
263  EXPECT_EQ(bounds.height(), 25);
264  EXPECT_EQ(result, false);
265 }

◆ TEST() [21/22]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
NodeDelegateHasUniqueId   
)

Definition at line 15 of file flutter_platform_node_delegate_unittests.cc.

15  {
16  std::shared_ptr<TestAccessibilityBridge> bridge =
17  std::make_shared<TestAccessibilityBridge>();
18 
19  // Add node 0: root.
20  FlutterSemanticsNode2 node0{sizeof(FlutterSemanticsNode2), 0};
21  std::vector<int32_t> node0_children{1};
22  FlutterSemanticsFlags emptyFlags = FlutterSemanticsFlags{};
23  node0.child_count = node0_children.size();
24  node0.children_in_traversal_order = node0_children.data();
25  node0.children_in_hit_test_order = node0_children.data();
26  node0.flags2 = &emptyFlags;
27 
28  // Add node 1: text child of node 0.
29  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
30  node1.label = "prefecture";
31  node1.value = "Kyoto";
32  node1.flags2 = &emptyFlags;
33 
34  bridge->AddFlutterSemanticsNodeUpdate(node0);
35  bridge->AddFlutterSemanticsNodeUpdate(node1);
36  bridge->CommitUpdates();
37 
38  auto node0_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
39  auto node1_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
40  EXPECT_TRUE(node0_delegate->GetUniqueId() != node1_delegate->GetUniqueId());
41 }

◆ TEST() [22/22]

flutter::testing::TEST ( FlutterPlatformNodeDelegateTest  ,
selfIsLowestPlatformAncestor   
)

Definition at line 267 of file flutter_platform_node_delegate_unittests.cc.

267  {
268  std::shared_ptr<TestAccessibilityBridge> bridge =
269  std::make_shared<TestAccessibilityBridge>();
270  FlutterSemanticsFlags flags = FlutterSemanticsFlags{0};
271  FlutterSemanticsNode2 root;
272  root.id = 0;
273  root.label = "root";
274  root.hint = "";
275  root.value = "";
276  root.increased_value = "";
277  root.decreased_value = "";
278  root.tooltip = "";
279  root.child_count = 0;
280  root.flags2 = &flags;
281  root.children_in_traversal_order = nullptr;
282  root.custom_accessibility_actions_count = 0;
283  bridge->AddFlutterSemanticsNodeUpdate(root);
284 
285  bridge->CommitUpdates();
286  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
287  auto lowest_platform_ancestor = root_node->GetLowestPlatformAncestor();
288  EXPECT_EQ(root_node->GetNativeViewAccessible(), lowest_platform_ancestor);
289 }

Variable Documentation

◆ kEmptyFlags

FlutterSemanticsFlags flutter::testing::kEmptyFlags = FlutterSemanticsFlags{}

Definition at line 18 of file accessibility_bridge_unittests.cc.

Referenced by CreateSemanticsNode().