Flutter Windows Embedder
accessibility_bridge_unittests.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "accessibility_bridge.h"
6 
7 #include "gmock/gmock.h"
8 #include "gtest/gtest.h"
9 
10 #include "flutter/third_party/accessibility/ax/ax_tree_manager_map.h"
12 
13 namespace flutter {
14 namespace testing {
15 
16 using ::testing::Contains;
17 
18 FlutterSemanticsFlags kEmptyFlags = FlutterSemanticsFlags{};
19 
20 FlutterSemanticsNode2 CreateSemanticsNode(
21  int32_t id,
22  const char* label,
23  const std::vector<int32_t>* children = nullptr) {
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 }
44 
45 TEST(AccessibilityBridgeTest, BasicTest) {
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  root.identifier = "identifier";
52  FlutterSemanticsNode2 child1 = CreateSemanticsNode(1, "child 1");
53  FlutterSemanticsNode2 child2 = CreateSemanticsNode(2, "child 2");
54 
55  bridge->AddFlutterSemanticsNodeUpdate(root);
56  bridge->AddFlutterSemanticsNodeUpdate(child1);
57  bridge->AddFlutterSemanticsNodeUpdate(child2);
58  bridge->CommitUpdates();
59 
60  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
61  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
62  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
63  EXPECT_EQ(root_node->GetChildCount(), 2);
64  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
65  EXPECT_EQ(root_node->GetData().child_ids[1], 2);
66  EXPECT_EQ(root_node->GetName(), "root");
67  EXPECT_EQ(root_node->GetAuthorUniqueId(), u"identifier");
68 
69  EXPECT_EQ(child1_node->GetChildCount(), 0);
70  EXPECT_EQ(child1_node->GetName(), "child 1");
71 
72  EXPECT_EQ(child2_node->GetChildCount(), 0);
73  EXPECT_EQ(child2_node->GetName(), "child 2");
74 }
75 
76 // Flutter used to assume that the accessibility root had ID 0.
77 // In a multi-view world, each view has its own accessibility root
78 // with a globally unique node ID.
79 TEST(AccessibilityBridgeTest, AccessibilityRootId) {
80  std::shared_ptr<TestAccessibilityBridge> bridge =
81  std::make_shared<TestAccessibilityBridge>();
82 
83  std::vector<int32_t> children{456, 789};
84  FlutterSemanticsNode2 root = CreateSemanticsNode(123, "root", &children);
85  FlutterSemanticsNode2 child1 = CreateSemanticsNode(456, "child 1");
86  FlutterSemanticsNode2 child2 = CreateSemanticsNode(789, "child 2");
87 
88  bridge->AddFlutterSemanticsNodeUpdate(root);
89  bridge->AddFlutterSemanticsNodeUpdate(child1);
90  bridge->AddFlutterSemanticsNodeUpdate(child2);
91  bridge->CommitUpdates();
92 
93  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(123).lock();
94  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(456).lock();
95  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(789).lock();
96  auto fake_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
97 
98  EXPECT_EQ(bridge->GetRootAsAXNode()->id(), 123);
99  EXPECT_EQ(bridge->RootDelegate()->GetName(), "root");
100 
101  EXPECT_EQ(root_node->GetChildCount(), 2);
102  EXPECT_EQ(root_node->GetData().child_ids[0], 456);
103  EXPECT_EQ(root_node->GetData().child_ids[1], 789);
104  EXPECT_EQ(root_node->GetName(), "root");
105 
106  EXPECT_EQ(child1_node->GetChildCount(), 0);
107  EXPECT_EQ(child1_node->GetName(), "child 1");
108 
109  EXPECT_EQ(child2_node->GetChildCount(), 0);
110  EXPECT_EQ(child2_node->GetName(), "child 2");
111 
112  ASSERT_FALSE(fake_delegate);
113 }
114 
115 // Semantic nodes can be added in any order.
116 TEST(AccessibilityBridgeTest, AddOrder) {
117  std::shared_ptr<TestAccessibilityBridge> bridge =
118  std::make_shared<TestAccessibilityBridge>();
119 
120  std::vector<int32_t> root_children{34, 56};
121  std::vector<int32_t> child2_children{78};
122  std::vector<int32_t> child3_children{90};
123  FlutterSemanticsNode2 root = CreateSemanticsNode(12, "root", &root_children);
124  FlutterSemanticsNode2 child1 = CreateSemanticsNode(34, "child 1");
125  FlutterSemanticsNode2 child2 =
126  CreateSemanticsNode(56, "child 2", &child2_children);
127  FlutterSemanticsNode2 child3 =
128  CreateSemanticsNode(78, "child 3", &child3_children);
129  FlutterSemanticsNode2 child4 = CreateSemanticsNode(90, "child 4");
130 
131  bridge->AddFlutterSemanticsNodeUpdate(child3);
132  bridge->AddFlutterSemanticsNodeUpdate(child2);
133  bridge->AddFlutterSemanticsNodeUpdate(root);
134  bridge->AddFlutterSemanticsNodeUpdate(child1);
135  bridge->AddFlutterSemanticsNodeUpdate(child4);
136  bridge->CommitUpdates();
137 
138  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(12).lock();
139  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(34).lock();
140  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(56).lock();
141  auto child3_node = bridge->GetFlutterPlatformNodeDelegateFromID(78).lock();
142  auto child4_node = bridge->GetFlutterPlatformNodeDelegateFromID(90).lock();
143 
144  EXPECT_EQ(bridge->GetRootAsAXNode()->id(), 12);
145  EXPECT_EQ(bridge->RootDelegate()->GetName(), "root");
146 
147  EXPECT_EQ(root_node->GetChildCount(), 2);
148  EXPECT_EQ(root_node->GetData().child_ids[0], 34);
149  EXPECT_EQ(root_node->GetData().child_ids[1], 56);
150  EXPECT_EQ(root_node->GetName(), "root");
151 
152  EXPECT_EQ(child1_node->GetChildCount(), 0);
153  EXPECT_EQ(child1_node->GetName(), "child 1");
154 
155  EXPECT_EQ(child2_node->GetChildCount(), 1);
156  EXPECT_EQ(child2_node->GetData().child_ids[0], 78);
157  EXPECT_EQ(child2_node->GetName(), "child 2");
158 
159  EXPECT_EQ(child3_node->GetChildCount(), 1);
160  EXPECT_EQ(child3_node->GetData().child_ids[0], 90);
161  EXPECT_EQ(child3_node->GetName(), "child 3");
162 
163  EXPECT_EQ(child4_node->GetChildCount(), 0);
164  EXPECT_EQ(child4_node->GetName(), "child 4");
165 }
166 
167 TEST(AccessibilityBridgeTest, CanFireChildrenChangedCorrectly) {
168  std::shared_ptr<TestAccessibilityBridge> bridge =
169  std::make_shared<TestAccessibilityBridge>();
170 
171  std::vector<int32_t> children{1};
172  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root", &children);
173  FlutterSemanticsNode2 child1 = CreateSemanticsNode(1, "child 1");
174 
175  bridge->AddFlutterSemanticsNodeUpdate(root);
176  bridge->AddFlutterSemanticsNodeUpdate(child1);
177 
178  bridge->CommitUpdates();
179 
180  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
181  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
182  EXPECT_EQ(root_node->GetChildCount(), 1);
183  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
184  EXPECT_EQ(root_node->GetName(), "root");
185 
186  EXPECT_EQ(child1_node->GetChildCount(), 0);
187  EXPECT_EQ(child1_node->GetName(), "child 1");
188  bridge->accessibility_events.clear();
189 
190  // Add a child to root.
191  root.child_count = 2;
192  int32_t new_children[] = {1, 2};
193  root.children_in_traversal_order = new_children;
194 
195  FlutterSemanticsNode2 child2 = CreateSemanticsNode(2, "child 2");
196 
197  bridge->AddFlutterSemanticsNodeUpdate(root);
198  bridge->AddFlutterSemanticsNodeUpdate(child2);
199  bridge->CommitUpdates();
200 
201  root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
202 
203  EXPECT_EQ(root_node->GetChildCount(), 2);
204  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
205  EXPECT_EQ(root_node->GetData().child_ids[1], 2);
206  EXPECT_EQ(bridge->accessibility_events.size(), size_t{2});
207  std::set<ui::AXEventGenerator::Event> actual_event{
208  bridge->accessibility_events.begin(), bridge->accessibility_events.end()};
209  EXPECT_THAT(actual_event,
210  Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED));
211  EXPECT_THAT(actual_event,
212  Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED));
213 }
214 
215 TEST(AccessibilityBridgeTest, CanHandleSelectionChangeCorrectly) {
216  std::shared_ptr<TestAccessibilityBridge> bridge =
217  std::make_shared<TestAccessibilityBridge>();
218  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
219  auto flags = FlutterSemanticsFlags{
220  .is_focused = FlutterTristate::kFlutterTristateTrue,
221  .is_text_field = true,
222  };
223  root.flags2 = &flags;
224 
225  bridge->AddFlutterSemanticsNodeUpdate(root);
226  bridge->CommitUpdates();
227 
228  const ui::AXTreeData& tree = bridge->GetAXTreeData();
229  EXPECT_EQ(tree.sel_anchor_object_id, ui::AXNode::kInvalidAXID);
230  bridge->accessibility_events.clear();
231 
232  // Update the selection.
233  root.text_selection_base = 0;
234  root.text_selection_extent = 5;
235  bridge->AddFlutterSemanticsNodeUpdate(root);
236 
237  bridge->CommitUpdates();
238 
239  EXPECT_EQ(tree.sel_anchor_object_id, 0);
240  EXPECT_EQ(tree.sel_anchor_offset, 0);
241  EXPECT_EQ(tree.sel_focus_object_id, 0);
242  EXPECT_EQ(tree.sel_focus_offset, 5);
243  ASSERT_EQ(bridge->accessibility_events.size(), size_t{2});
244  EXPECT_EQ(bridge->accessibility_events[0],
245  ui::AXEventGenerator::Event::DOCUMENT_SELECTION_CHANGED);
246  EXPECT_EQ(bridge->accessibility_events[1],
247  ui::AXEventGenerator::Event::OTHER_ATTRIBUTE_CHANGED);
248 }
249 
250 TEST(AccessibilityBridgeTest, DoesNotAssignEditableRootToSelectableText) {
251  std::shared_ptr<TestAccessibilityBridge> bridge =
252  std::make_shared<TestAccessibilityBridge>();
253  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
254  auto flags = FlutterSemanticsFlags{
255  .is_text_field = true,
256  .is_read_only = true,
257  };
258  root.flags2 = &flags;
259 
260  bridge->AddFlutterSemanticsNodeUpdate(root);
261  bridge->CommitUpdates();
262 
263  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
264 
265  EXPECT_FALSE(root_node->GetData().GetBoolAttribute(
266  ax::mojom::BoolAttribute::kEditableRoot));
267 }
268 
269 TEST(AccessibilityBridgeTest, SwitchHasSwitchRole) {
270  std::shared_ptr<TestAccessibilityBridge> bridge =
271  std::make_shared<TestAccessibilityBridge>();
272  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
273  auto flags = FlutterSemanticsFlags{
274  .is_enabled = FlutterTristate::kFlutterTristateTrue,
275  .is_toggled = FlutterTristate::kFlutterTristateFalse,
276  };
277 
278  root.flags2 = &flags;
279  bridge->AddFlutterSemanticsNodeUpdate(root);
280  bridge->CommitUpdates();
281 
282  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
283  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSwitch);
284 }
285 
286 TEST(AccessibilityBridgeTest, SliderHasSliderRole) {
287  std::shared_ptr<TestAccessibilityBridge> bridge =
288  std::make_shared<TestAccessibilityBridge>();
289  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
290  auto flags = FlutterSemanticsFlags{
291  .is_enabled = FlutterTristate::kFlutterTristateTrue,
292  .is_focused = FlutterTristate::kFlutterTristateFalse,
293  .is_slider = true,
294  };
295 
296  root.flags2 = &flags;
297 
298  bridge->AddFlutterSemanticsNodeUpdate(root);
299  bridge->CommitUpdates();
300 
301  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
302  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSlider);
303 }
304 
305 TEST(AccessibilityBridgeTest, DisabledButtonHasDisabledRestriction) {
306  std::shared_ptr<TestAccessibilityBridge> bridge =
307  std::make_shared<TestAccessibilityBridge>();
308  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
309  auto flags = FlutterSemanticsFlags{
310  .is_enabled = FlutterTristate::kFlutterTristateFalse,
311  .is_button = true,
312  };
313  root.flags2 = &flags;
314  bridge->AddFlutterSemanticsNodeUpdate(root);
315  bridge->CommitUpdates();
316 
317  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
318  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kButton);
319  EXPECT_EQ(root_node->GetData().GetRestriction(),
320  ax::mojom::Restriction::kDisabled);
321 }
322 
323 TEST(AccessibilityBridgeTest, EnabledButtonHasNoRestriction) {
324  std::shared_ptr<TestAccessibilityBridge> bridge =
325  std::make_shared<TestAccessibilityBridge>();
326  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
327  auto flags = FlutterSemanticsFlags{
328  .is_enabled = FlutterTristate::kFlutterTristateTrue,
329  .is_button = true,
330  };
331  root.flags2 = &flags;
332  bridge->AddFlutterSemanticsNodeUpdate(root);
333  bridge->CommitUpdates();
334 
335  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
336  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kButton);
337  EXPECT_EQ(root_node->GetData().GetRestriction(),
338  ax::mojom::Restriction::kNone);
339 }
340 
341 TEST(AccessibilityBridgeTest, ReadOnlyTextFieldHasReadOnlyRestriction) {
342  std::shared_ptr<TestAccessibilityBridge> bridge =
343  std::make_shared<TestAccessibilityBridge>();
344  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
345  auto flags = FlutterSemanticsFlags{
346  .is_enabled = FlutterTristate::kFlutterTristateTrue,
347  .is_text_field = true,
348  .is_read_only = true,
349  };
350  root.flags2 = &flags;
351  bridge->AddFlutterSemanticsNodeUpdate(root);
352  bridge->CommitUpdates();
353 
354  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
355  EXPECT_EQ(root_node->GetData().GetRestriction(),
356  ax::mojom::Restriction::kReadOnly);
357 }
358 
359 TEST(AccessibilityBridgeTest, ReadOnlyTextFieldHasTextFieldRole) {
360  std::shared_ptr<TestAccessibilityBridge> bridge =
361  std::make_shared<TestAccessibilityBridge>();
362  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
363  auto flags = FlutterSemanticsFlags{
364  .is_enabled = FlutterTristate::kFlutterTristateTrue,
365  .is_text_field = true,
366  .is_read_only = true,
367  };
368  root.flags2 = &flags;
369  bridge->AddFlutterSemanticsNodeUpdate(root);
370  bridge->CommitUpdates();
371 
372  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
373  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kTextField);
374 }
375 
376 TEST(AccessibilityBridgeTest, EditableTextFieldHasTextFieldRole) {
377  std::shared_ptr<TestAccessibilityBridge> bridge =
378  std::make_shared<TestAccessibilityBridge>();
379  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
380  auto flags = FlutterSemanticsFlags{
381  .is_enabled = FlutterTristate::kFlutterTristateTrue,
382  .is_text_field = true,
383  .is_read_only = false,
384  };
385  root.flags2 = &flags;
386  bridge->AddFlutterSemanticsNodeUpdate(root);
387  bridge->CommitUpdates();
388 
389  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
390  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kTextField);
391  EXPECT_TRUE(root_node->GetData().HasState(ax::mojom::State::kEditable));
392 }
393 
394 // Ensure that checkboxes have their checked status set apropriately
395 // Previously, only Radios could have this flag updated
396 // Resulted in the issue seen at
397 // https://github.com/flutter/flutter/issues/96218
398 // As this fix involved code run on all platforms, it is included here.
399 TEST(AccessibilityBridgeTest, CanSetCheckboxChecked) {
400  std::shared_ptr<TestAccessibilityBridge> bridge =
401  std::make_shared<TestAccessibilityBridge>();
402  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root");
403  auto flags = FlutterSemanticsFlags{
404  .is_checked = FlutterCheckState::kFlutterCheckStateTrue,
405  };
406 
407  root.flags2 = &flags;
408  bridge->AddFlutterSemanticsNodeUpdate(root);
409  bridge->CommitUpdates();
410 
411  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
412  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
413  EXPECT_EQ(root_node->GetData().GetCheckedState(),
414  ax::mojom::CheckedState::kTrue);
415 }
416 
417 // Verify that a node can be moved from one parent to another.
418 TEST(AccessibilityBridgeTest, CanReparentNode) {
419  std::shared_ptr<TestAccessibilityBridge> bridge =
420  std::make_shared<TestAccessibilityBridge>();
421 
422  std::vector<int32_t> root_children{1};
423  std::vector<int32_t> child1_children{2};
424  FlutterSemanticsNode2 root = CreateSemanticsNode(0, "root", &root_children);
425  FlutterSemanticsNode2 child1 =
426  CreateSemanticsNode(1, "child 1", &child1_children);
427  FlutterSemanticsNode2 child2 = CreateSemanticsNode(2, "child 2");
428 
429  bridge->AddFlutterSemanticsNodeUpdate(root);
430  bridge->AddFlutterSemanticsNodeUpdate(child1);
431  bridge->AddFlutterSemanticsNodeUpdate(child2);
432  bridge->CommitUpdates();
433  bridge->accessibility_events.clear();
434 
435  // Reparent child2 from child1 to the root.
436  child1.child_count = 0;
437  child1.children_in_traversal_order = nullptr;
438 
439  int32_t new_root_children[] = {1, 2};
440  root.child_count = 2;
441  root.children_in_traversal_order = new_root_children;
442 
443  bridge->AddFlutterSemanticsNodeUpdate(root);
444  bridge->AddFlutterSemanticsNodeUpdate(child1);
445  bridge->AddFlutterSemanticsNodeUpdate(child2);
446  bridge->CommitUpdates();
447 
448  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
449  auto child1_node = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
450  auto child2_node = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
451 
452  EXPECT_EQ(root_node->GetChildCount(), 2);
453  EXPECT_EQ(root_node->GetData().child_ids[0], 1);
454  EXPECT_EQ(root_node->GetData().child_ids[1], 2);
455  EXPECT_EQ(root_node->GetName(), "root");
456 
457  EXPECT_EQ(child1_node->GetChildCount(), 0);
458  EXPECT_EQ(child1_node->GetName(), "child 1");
459 
460  EXPECT_EQ(child2_node->GetChildCount(), 0);
461  EXPECT_EQ(child2_node->GetName(), "child 2");
462 
463  ASSERT_EQ(bridge->accessibility_events.size(), size_t{5});
464 
465  // Child2 is moved from child1 to root.
466  EXPECT_THAT(bridge->accessibility_events,
467  Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED).Times(2));
468  EXPECT_THAT(bridge->accessibility_events,
469  Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED).Times(1));
470 
471  // Child1 is no longer a parent. It loses its group role and disables its
472  // 'clip children' attribute.
473  EXPECT_THAT(
474  bridge->accessibility_events,
475  Contains(ui::AXEventGenerator::Event::OTHER_ATTRIBUTE_CHANGED).Times(1));
476  EXPECT_THAT(bridge->accessibility_events,
477  Contains(ui::AXEventGenerator::Event::ROLE_CHANGED).Times(1));
478 }
479 
480 // Verify that multiple nodes can be moved to new parents.
481 TEST(AccessibilityBridgeTest, CanReparentMultipleNodes) {
482  std::shared_ptr<TestAccessibilityBridge> bridge =
483  std::make_shared<TestAccessibilityBridge>();
484 
485  int32_t root_id = 0;
486  int32_t intermediary1_id = 1;
487  int32_t intermediary2_id = 2;
488  int32_t leaf1_id = 3;
489  int32_t leaf2_id = 4;
490  int32_t leaf3_id = 5;
491 
492  std::vector<int32_t> root_children{intermediary1_id, intermediary2_id};
493  std::vector<int32_t> intermediary1_children{leaf1_id};
494  std::vector<int32_t> intermediary2_children{leaf2_id, leaf3_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 = CreateSemanticsNode(
500  intermediary2_id, "intermediary 2", &intermediary2_children);
501  FlutterSemanticsNode2 leaf1 = CreateSemanticsNode(leaf1_id, "leaf 1");
502  FlutterSemanticsNode2 leaf2 = CreateSemanticsNode(leaf2_id, "leaf 2");
503  FlutterSemanticsNode2 leaf3 = CreateSemanticsNode(leaf3_id, "leaf 3");
504 
505  bridge->AddFlutterSemanticsNodeUpdate(root);
506  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
507  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
508  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
509  bridge->AddFlutterSemanticsNodeUpdate(leaf2);
510  bridge->AddFlutterSemanticsNodeUpdate(leaf3);
511  bridge->CommitUpdates();
512  bridge->accessibility_events.clear();
513 
514  // Swap intermediary 1's and intermediary2's children.
515  int32_t new_intermediary1_children[] = {leaf2_id, leaf3_id};
516  intermediary1.child_count = 2;
517  intermediary1.children_in_traversal_order = new_intermediary1_children;
518 
519  int32_t new_intermediary2_children[] = {leaf1_id};
520  intermediary2.child_count = 1;
521  intermediary2.children_in_traversal_order = new_intermediary2_children;
522 
523  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
524  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
525  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
526  bridge->AddFlutterSemanticsNodeUpdate(leaf2);
527  bridge->AddFlutterSemanticsNodeUpdate(leaf3);
528  bridge->CommitUpdates();
529 
530  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(root_id).lock();
531  auto intermediary1_node =
532  bridge->GetFlutterPlatformNodeDelegateFromID(intermediary1_id).lock();
533  auto intermediary2_node =
534  bridge->GetFlutterPlatformNodeDelegateFromID(intermediary2_id).lock();
535  auto leaf1_node =
536  bridge->GetFlutterPlatformNodeDelegateFromID(leaf1_id).lock();
537  auto leaf2_node =
538  bridge->GetFlutterPlatformNodeDelegateFromID(leaf2_id).lock();
539  auto leaf3_node =
540  bridge->GetFlutterPlatformNodeDelegateFromID(leaf3_id).lock();
541 
542  EXPECT_EQ(root_node->GetChildCount(), 2);
543  EXPECT_EQ(root_node->GetData().child_ids[0], intermediary1_id);
544  EXPECT_EQ(root_node->GetData().child_ids[1], intermediary2_id);
545  EXPECT_EQ(root_node->GetName(), "root");
546 
547  EXPECT_EQ(intermediary1_node->GetChildCount(), 2);
548  EXPECT_EQ(intermediary1_node->GetData().child_ids[0], leaf2_id);
549  EXPECT_EQ(intermediary1_node->GetData().child_ids[1], leaf3_id);
550  EXPECT_EQ(intermediary1_node->GetName(), "intermediary 1");
551 
552  EXPECT_EQ(intermediary2_node->GetChildCount(), 1);
553  EXPECT_EQ(intermediary2_node->GetData().child_ids[0], leaf1_id);
554  EXPECT_EQ(intermediary2_node->GetName(), "intermediary 2");
555 
556  EXPECT_EQ(leaf1_node->GetChildCount(), 0);
557  EXPECT_EQ(leaf1_node->GetName(), "leaf 1");
558 
559  EXPECT_EQ(leaf2_node->GetChildCount(), 0);
560  EXPECT_EQ(leaf2_node->GetName(), "leaf 2");
561 
562  EXPECT_EQ(leaf3_node->GetChildCount(), 0);
563  EXPECT_EQ(leaf3_node->GetName(), "leaf 3");
564 
565  // Intermediary 1 and intermediary 2 have new children.
566  // Leaf 1, 2, and 3 are all moved.
567  ASSERT_EQ(bridge->accessibility_events.size(), size_t{5});
568  EXPECT_THAT(bridge->accessibility_events,
569  Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED).Times(2));
570  EXPECT_THAT(bridge->accessibility_events,
571  Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED).Times(3));
572 }
573 
574 // Verify that a node with a child can be moved from one parent to another.
575 TEST(AccessibilityBridgeTest, CanReparentNodeWithChild) {
576  std::shared_ptr<TestAccessibilityBridge> bridge =
577  std::make_shared<TestAccessibilityBridge>();
578 
579  int32_t root_id = 0;
580  int32_t intermediary1_id = 1;
581  int32_t intermediary2_id = 2;
582  int32_t leaf1_id = 3;
583 
584  std::vector<int32_t> root_children{intermediary1_id, intermediary2_id};
585  std::vector<int32_t> intermediary1_children{leaf1_id};
586  FlutterSemanticsNode2 root =
587  CreateSemanticsNode(root_id, "root", &root_children);
588  FlutterSemanticsNode2 intermediary1 = CreateSemanticsNode(
589  intermediary1_id, "intermediary 1", &intermediary1_children);
590  FlutterSemanticsNode2 intermediary2 =
591  CreateSemanticsNode(intermediary2_id, "intermediary 2");
592  FlutterSemanticsNode2 leaf1 = CreateSemanticsNode(leaf1_id, "leaf 1");
593 
594  bridge->AddFlutterSemanticsNodeUpdate(root);
595  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
596  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
597  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
598  bridge->CommitUpdates();
599  bridge->accessibility_events.clear();
600 
601  // Move intermediary1 from root to intermediary 2.
602  int32_t new_root_children[] = {intermediary2_id};
603  root.child_count = 1;
604  root.children_in_traversal_order = new_root_children;
605 
606  int32_t new_intermediary2_children[] = {intermediary1_id};
607  intermediary2.child_count = 1;
608  intermediary2.children_in_traversal_order = new_intermediary2_children;
609 
610  bridge->AddFlutterSemanticsNodeUpdate(root);
611  bridge->AddFlutterSemanticsNodeUpdate(intermediary1);
612  bridge->AddFlutterSemanticsNodeUpdate(intermediary2);
613  bridge->AddFlutterSemanticsNodeUpdate(leaf1);
614  bridge->CommitUpdates();
615 
616  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(root_id).lock();
617  auto intermediary1_node =
618  bridge->GetFlutterPlatformNodeDelegateFromID(intermediary1_id).lock();
619  auto intermediary2_node =
620  bridge->GetFlutterPlatformNodeDelegateFromID(intermediary2_id).lock();
621  auto leaf1_node =
622  bridge->GetFlutterPlatformNodeDelegateFromID(leaf1_id).lock();
623 
624  EXPECT_EQ(root_node->GetChildCount(), 1);
625  EXPECT_EQ(root_node->GetData().child_ids[0], intermediary2_id);
626  EXPECT_EQ(root_node->GetName(), "root");
627 
628  EXPECT_EQ(intermediary2_node->GetChildCount(), 1);
629  EXPECT_EQ(intermediary2_node->GetData().child_ids[0], intermediary1_id);
630  EXPECT_EQ(intermediary2_node->GetName(), "intermediary 2");
631 
632  EXPECT_EQ(intermediary1_node->GetChildCount(), 1);
633  EXPECT_EQ(intermediary1_node->GetData().child_ids[0], leaf1_id);
634  EXPECT_EQ(intermediary1_node->GetName(), "intermediary 1");
635 
636  EXPECT_EQ(leaf1_node->GetChildCount(), 0);
637  EXPECT_EQ(leaf1_node->GetName(), "leaf 1");
638 
639  ASSERT_EQ(bridge->accessibility_events.size(), size_t{5});
640 
641  EXPECT_THAT(bridge->accessibility_events,
642  Contains(ui::AXEventGenerator::Event::CHILDREN_CHANGED).Times(2));
643  EXPECT_THAT(bridge->accessibility_events,
644  Contains(ui::AXEventGenerator::Event::SUBTREE_CREATED).Times(1));
645 
646  // Intermediary 2 becomes a parent node. It updates to group role and enables
647  // its 'clip children' attribute.
648  EXPECT_THAT(
649  bridge->accessibility_events,
650  Contains(ui::AXEventGenerator::Event::OTHER_ATTRIBUTE_CHANGED).Times(1));
651  EXPECT_THAT(bridge->accessibility_events,
652  Contains(ui::AXEventGenerator::Event::ROLE_CHANGED).Times(1));
653 }
654 
655 TEST(AccessibilityBridgeTest, AXTreeManagerTest) {
656  std::shared_ptr<TestAccessibilityBridge> bridge =
657  std::make_shared<TestAccessibilityBridge>();
658 
659  ui::AXTreeID tree_id = bridge->GetTreeID();
660  ui::AXTreeManager* manager =
661  ui::AXTreeManagerMap::GetInstance().GetManager(tree_id);
662  ASSERT_EQ(manager, static_cast<ui::AXTreeManager*>(bridge.get()));
663 }
664 
665 TEST(AccessibilityBridgeTest, LineBreakingObjectTest) {
666  std::shared_ptr<TestAccessibilityBridge> bridge =
667  std::make_shared<TestAccessibilityBridge>();
668 
669  const int32_t root_id = 0;
670 
671  FlutterSemanticsNode2 root = CreateSemanticsNode(root_id, "root", {});
672 
673  bridge->AddFlutterSemanticsNodeUpdate(root);
674  bridge->CommitUpdates();
675 
676  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(root_id).lock();
677  auto root_data = root_node->GetData();
678  EXPECT_TRUE(root_data.HasBoolAttribute(
679  ax::mojom::BoolAttribute::kIsLineBreakingObject));
680  EXPECT_TRUE(root_data.GetBoolAttribute(
681  ax::mojom::BoolAttribute::kIsLineBreakingObject));
682 }
683 
684 TEST(AccessibilityBridgeTest, IsSelectedAttribute) {
685  std::shared_ptr<TestAccessibilityBridge> bridge =
686  std::make_shared<TestAccessibilityBridge>();
687 
688  std::vector<int32_t> children{1, 2};
689  FlutterSemanticsNode2 node0 = CreateSemanticsNode(0, "node 0", &children);
690  auto flags0 = FlutterSemanticsFlags{
691  .is_selected = FlutterTristate::kFlutterTristateNone,
692  };
693  node0.flags2 = &flags0;
694 
695  FlutterSemanticsNode2 node1 = CreateSemanticsNode(1, "node 1");
696  auto flags1 = FlutterSemanticsFlags{
697  .is_selected = FlutterTristate::kFlutterTristateTrue,
698  };
699  node1.flags2 = &flags1;
700 
701  FlutterSemanticsNode2 node2 = CreateSemanticsNode(2, "node 2");
702  auto flags2 = FlutterSemanticsFlags{
703  .is_selected = FlutterTristate::kFlutterTristateFalse,
704  };
705  node2.flags2 = &flags2;
706 
707  bridge->AddFlutterSemanticsNodeUpdate(node0);
708  bridge->AddFlutterSemanticsNodeUpdate(node1);
709  bridge->AddFlutterSemanticsNodeUpdate(node2);
710  bridge->CommitUpdates();
711 
712  auto delegate0 = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
713  auto delegate1 = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
714  auto delegate2 = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
715 
716  // For kFlutterTristateNone, selected should be false.
717  EXPECT_FALSE(delegate0->GetData().GetBoolAttribute(
718  ax::mojom::BoolAttribute::kSelected));
719  // For kFlutterTristateTrue, selected should be true.
720  EXPECT_TRUE(delegate1->GetData().GetBoolAttribute(
721  ax::mojom::BoolAttribute::kSelected));
722  // For kFlutterTristateFalse, selected should be false.
723  EXPECT_FALSE(delegate2->GetData().GetBoolAttribute(
724  ax::mojom::BoolAttribute::kSelected));
725 }
726 
727 } // namespace testing
728 } // namespace flutter
TEST(AccessibilityBridgeWindows, GetParent)
FlutterSemanticsNode2 CreateSemanticsNode(int32_t id, const char *label, const std::vector< int32_t > *children=nullptr)
FlutterSemanticsFlags kEmptyFlags