Debian Codegraph @

tests/unit_tests/test_ax_utilities.py

raw
1 # Unit tests for ax_utilities.py methods.
2 #
3 # Copyright 2025 Igalia, S.L.
4 # Author: Joanmarie Diggs <[email protected]>
5 #
6 # This library is free software; you can redistribute it and/or
7 # modify it under the terms of the GNU Lesser General Public
8 # License as published by the Free Software Foundation; either
9 # version 2.1 of the License, or (at your option) any later version.
10 #
11 # This library is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 # Lesser General Public License for more details.
15 #
16 # You should have received a copy of the GNU Lesser General Public
17 # License along with this library; if not, write to the
18 # Free Software Foundation, Inc., Franklin Street, Fifth Floor,
19 # Boston MA 02110-1301 USA.
20
21 # pylint: disable=too-many-lines
22 # pylint: disable=too-many-public-methods
23 # pylint: disable=wrong-import-position
24 # pylint: disable=import-outside-toplevel
25 # pylint: disable=too-many-statements
26
27 """Unit tests for ax_utilities.py methods."""
28
29 from __future__ import annotations
30
31 import sys
32 from typing import TYPE_CHECKING
33
34 import gi
35 import pytest
36
37 gi.require_version("Atspi", "2.0")
38 from gi.repository import Atspi
39
40 if TYPE_CHECKING:
41 from unittest.mock import MagicMock
42
43 from .orca_test_context import OrcaTestContext
44
45
46 @pytest.mark.unit
47 class TestAXUtilities:
48 """Test AXUtilities class methods."""
49
50 def _setup_dependencies(self, test_context: OrcaTestContext) -> dict[str, MagicMock]:
51 """Set up mocks for ax_utilities dependencies."""
52
53 additional_modules = [
54 "orca.ax_action",
55 "orca.ax_component",
56 "orca.ax_selection",
57 "orca.ax_utilities_action",
58 "orca.ax_utilities_component",
59 "orca.ax_utilities_object",
60 "orca.ax_table",
61 "orca.ax_text",
62 "orca.ax_utilities_application",
63 "orca.ax_utilities_collection",
64 "orca.ax_utilities_event",
65 "orca.ax_utilities_relation",
66 "orca.ax_utilities_role",
67 "orca.ax_utilities_selection",
68 "orca.ax_utilities_state",
69 "orca.ax_utilities_table",
70 ]
71 essential_modules = test_context.setup_shared_dependencies(additional_modules)
72
73 ax_object_class_mock = test_context.Mock()
74 ax_object_class_mock.is_valid = test_context.Mock(return_value=True)
75 ax_object_class_mock.get_attribute = test_context.Mock(return_value="")
76 ax_object_class_mock.get_index_in_parent = test_context.Mock(return_value=0)
77 ax_object_class_mock.get_parent = test_context.Mock(return_value=None)
78 ax_object_class_mock.get_child_count = test_context.Mock(return_value=0)
79 ax_object_class_mock.get_role = test_context.Mock(return_value=Atspi.Role.PANEL)
80 ax_object_class_mock.get_name = test_context.Mock(return_value="")
81 ax_object_class_mock.get_description = test_context.Mock(return_value="")
82 ax_object_class_mock.get_child = test_context.Mock(return_value=None)
83 ax_object_class_mock.clear_cache = test_context.Mock()
84 ax_object_class_mock.get_attributes_dict = test_context.Mock(return_value={})
85 ax_object_class_mock.supports_collection = test_context.Mock(return_value=False)
86
87 def mock_iter_children(parent, predicate=None): # pylint: disable=unused-argument
88 all_children = []
89 if predicate:
90 return [obj for obj in all_children if predicate(obj)]
91 return all_children
92
93 ax_object_class_mock.iter_children = mock_iter_children
94 essential_modules["orca.ax_object"].AXObject = ax_object_class_mock
95
96 object_utilities_class_mock = test_context.Mock()
97 object_utilities_class_mock.find_ancestor = test_context.Mock(return_value=None)
98 essential_modules[
99 "orca.ax_utilities_object"
100 ].AXUtilitiesObject = object_utilities_class_mock
101
102 action_utilities_class_mock = test_context.Mock()
103 action_utilities_class_mock.has_action = test_context.Mock(return_value=False)
104 essential_modules[
105 "orca.ax_utilities_action"
106 ].AXUtilitiesAction = action_utilities_class_mock
107
108 role_class_mock = test_context.Mock()
109 role_class_mock.get_layout_only_roles = test_context.Mock(return_value=[Atspi.Role.FILLER])
110 role_class_mock.is_layered_pane = test_context.Mock(return_value=False)
111 role_class_mock.is_desktop_frame = test_context.Mock(return_value=False)
112 role_class_mock.is_menu = test_context.Mock(return_value=False)
113 role_class_mock.is_list = test_context.Mock(return_value=False)
114 role_class_mock.is_combo_box = test_context.Mock(return_value=False)
115 role_class_mock.is_group = test_context.Mock(return_value=False)
116 role_class_mock.is_panel = test_context.Mock(return_value=False)
117 role_class_mock.is_grouping = test_context.Mock(return_value=False)
118 role_class_mock.is_section = test_context.Mock(return_value=False)
119 role_class_mock.is_document = test_context.Mock(return_value=False)
120 role_class_mock.is_tool_bar = test_context.Mock(return_value=False)
121 role_class_mock.is_page_tab_list = test_context.Mock(return_value=False)
122 role_class_mock.is_table = test_context.Mock(return_value=False)
123 role_class_mock.is_table_row = test_context.Mock(return_value=False)
124 role_class_mock.is_table_cell = test_context.Mock(return_value=False)
125 role_class_mock.is_label = test_context.Mock(return_value=False)
126 role_class_mock.children_are_presentational = test_context.Mock(return_value=False)
127 role_class_mock.is_page_tab = test_context.Mock(return_value=False)
128 role_class_mock.has_role_from_aria = test_context.Mock(return_value=False)
129 role_class_mock.is_link = test_context.Mock(return_value=False)
130 role_class_mock.is_heading = test_context.Mock(return_value=False)
131 role_class_mock.is_dialog_or_alert = test_context.Mock(return_value=False)
132 essential_modules["orca.ax_utilities_role"].AXUtilitiesRole = role_class_mock
133
134 state_class_mock = test_context.Mock()
135 state_class_mock.is_focusable = test_context.Mock(return_value=False)
136 state_class_mock.is_selectable = test_context.Mock(return_value=False)
137 state_class_mock.is_expandable = test_context.Mock(return_value=False)
138 state_class_mock.is_showing = test_context.Mock(return_value=True)
139 state_class_mock.is_visible = test_context.Mock(return_value=True)
140 state_class_mock.is_hidden = test_context.Mock(return_value=False)
141 state_class_mock.is_expanded = test_context.Mock(return_value=False)
142 state_class_mock.is_focused = test_context.Mock(return_value=False)
143 state_class_mock.is_editable = test_context.Mock(return_value=False)
144 state_class_mock.is_active = test_context.Mock(return_value=False)
145 state_class_mock.is_iconified = test_context.Mock(return_value=False)
146 essential_modules["orca.ax_utilities_state"].AXUtilitiesState = state_class_mock
147
148 relation_class_mock = test_context.Mock()
149 relation_class_mock.get_flows_to = test_context.Mock(return_value=[])
150 relation_class_mock.get_flows_from = test_context.Mock(return_value=[])
151 relation_class_mock.get_is_labelled_by = test_context.Mock(return_value=[])
152 relation_class_mock.get_is_described_by = test_context.Mock(return_value=[])
153 essential_modules["orca.ax_utilities_relation"].AXUtilitiesRelation = relation_class_mock
154
155 app_class_mock = test_context.Mock()
156 app_class_mock.get_application = test_context.Mock(return_value=test_context.Mock())
157 app_class_mock.is_application_in_desktop = test_context.Mock(return_value=True)
158 essential_modules["orca.ax_utilities_application"].AXUtilitiesApplication = app_class_mock
159
160 table_class_mock = test_context.Mock()
161 table_class_mock.get_table = test_context.Mock(return_value=None)
162 table_class_mock.get_cell_coordinates = test_context.Mock(return_value=(0, 0))
163 table_class_mock.get_row_count = test_context.Mock(return_value=0)
164 essential_modules["orca.ax_table"].AXTable = table_class_mock
165
166 utilities_table_class_mock = test_context.Mock()
167 utilities_table_class_mock.is_layout_table = test_context.Mock(return_value=False)
168 essential_modules["orca.ax_utilities_table"].AXUtilitiesTable = utilities_table_class_mock
169
170 collection_class_mock = test_context.Mock()
171 collection_class_mock.find_all_descendants = test_context.Mock(return_value=[])
172 collection_class_mock.find_descendant = test_context.Mock(return_value=None)
173 collection_class_mock.has_scroll_pane = test_context.Mock(return_value=False)
174 essential_modules[
175 "orca.ax_utilities_collection"
176 ].AXUtilitiesCollection = collection_class_mock
177
178 text_class_mock = test_context.Mock()
179 text_class_mock.get_all_text = test_context.Mock(return_value="")
180 essential_modules["orca.ax_text"].AXText = text_class_mock
181
182 return essential_modules
183
184 def test_has_explicit_name_true(self, test_context: OrcaTestContext) -> None:
185 """Test AXUtilities.has_explicit_name with explicit name attribute."""
186
187 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
188 essential_modules["orca.ax_object"].AXObject.get_attribute = test_context.Mock(
189 return_value="true",
190 )
191 from orca.ax_utilities import AXUtilities
192
193 mock_obj = test_context.Mock(spec=Atspi.Accessible)
194 result = AXUtilities.has_explicit_name(mock_obj)
195 assert result is True
196
197 def test_has_explicit_name_false(self, test_context: OrcaTestContext) -> None:
198 """Test AXUtilities.has_explicit_name without explicit name attribute."""
199
200 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
201 essential_modules["orca.ax_object"].AXObject.get_attribute = test_context.Mock(
202 return_value="false",
203 )
204 from orca.ax_utilities import AXUtilities
205
206 mock_obj = test_context.Mock(spec=Atspi.Accessible)
207 result = AXUtilities.has_explicit_name(mock_obj)
208 assert result is False
209
210 def test_is_redundant_object_same_objects(self, test_context: OrcaTestContext) -> None:
211 """Test AXUtilities.is_redundant_object with same objects."""
212
213 self._setup_dependencies(test_context)
214 from orca.ax_utilities import AXUtilities
215
216 mock_obj = test_context.Mock(spec=Atspi.Accessible)
217 result = AXUtilities.is_redundant_object(mock_obj, mock_obj)
218 assert result is False
219
220 def test_is_redundant_object_different_names(self, test_context: OrcaTestContext) -> None:
221 """Test AXUtilities.is_redundant_object with different names."""
222
223 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
224
225 def mock_get_name(obj):
226 if obj == "obj1":
227 return "Name1"
228 return "Name2"
229
230 essential_modules["orca.ax_object"].AXObject.get_name = mock_get_name
231 essential_modules["orca.ax_object"].AXObject.get_role = test_context.Mock(
232 return_value=Atspi.Role.BUTTON,
233 )
234 from orca.ax_utilities import AXUtilities
235
236 result = AXUtilities.is_redundant_object("obj1", "obj2")
237 assert result is False
238
239 def test_is_redundant_object_same_name_and_role(self, test_context: OrcaTestContext) -> None:
240 """Test AXUtilities.is_redundant_object with same name and role."""
241
242 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
243 essential_modules["orca.ax_object"].AXObject.get_name = test_context.Mock(
244 return_value="Button",
245 )
246 essential_modules["orca.ax_object"].AXObject.get_role = test_context.Mock(
247 return_value=Atspi.Role.BUTTON,
248 )
249 from orca.ax_utilities import AXUtilities
250
251 mock_obj1 = test_context.Mock(spec=Atspi.Accessible)
252 mock_obj2 = test_context.Mock(spec=Atspi.Accessible)
253 result = AXUtilities.is_redundant_object(mock_obj1, mock_obj2)
254 assert result is True
255
256 @pytest.mark.parametrize(
257 "case",
258 [
259 {
260 "id": "layout_only_role",
261 "mocks_config": {"ax_object.get_role": Atspi.Role.FILLER},
262 "expected": True,
263 },
264 {
265 "id": "group_without_explicit_name",
266 "mocks_config": {
267 "ax_utilities_role.is_group": True,
268 "has_explicit_name": False,
269 },
270 "expected": True,
271 },
272 {
273 "id": "group_with_explicit_name",
274 "mocks_config": {"ax_utilities_role.is_group": True, "has_explicit_name": True},
275 "expected": False,
276 },
277 {
278 "id": "layered_pane_in_desktop",
279 "mocks_config": {
280 "ax_utilities_role.is_layered_pane": True,
281 "ax_utilities_role.is_desktop_frame": True,
282 "ax_object.find_ancestor": "desktop",
283 },
284 "expected": True,
285 },
286 {
287 "id": "layered_pane_not_in_desktop",
288 "mocks_config": {
289 "ax_utilities_role.is_layered_pane": True,
290 "ax_utilities_role.is_desktop_frame": False,
291 "ax_object.find_ancestor": None,
292 },
293 "expected": False,
294 },
295 {
296 "id": "menu_in_combo_box",
297 "mocks_config": {
298 "ax_utilities_role.is_menu": True,
299 "ax_utilities_role.is_combo_box": True,
300 "ax_object.find_ancestor": "combo_box",
301 },
302 "expected": True,
303 },
304 {
305 "id": "list_not_in_combo_box",
306 "mocks_config": {
307 "ax_utilities_role.is_list": True,
308 "ax_utilities_role.is_combo_box": False,
309 "ax_object.find_ancestor": None,
310 },
311 "expected": False,
312 },
313 {
314 "id": "section_focusable",
315 "mocks_config": {
316 "ax_utilities_role.is_section": True,
317 "ax_utilities_state.is_focusable": True,
318 },
319 "expected": False,
320 },
321 {
322 "id": "section_not_focusable",
323 "mocks_config": {
324 "ax_utilities_role.is_section": True,
325 "ax_utilities_state.is_focusable": False,
326 },
327 "expected": True,
328 },
329 {
330 "id": "document_with_click_action",
331 "mocks_config": {
332 "ax_utilities_role.is_document": True,
333 "ax_utilities_action.has_action": True,
334 },
335 "expected": False,
336 },
337 {
338 "id": "table_layout_table",
339 "mocks_config": {
340 "ax_utilities_role.is_table": True,
341 "ax_utilities_table.is_layout_table": True,
342 },
343 "expected": True,
344 },
345 {
346 "id": "table_data_table",
347 "mocks_config": {
348 "ax_utilities_role.is_table": True,
349 "ax_utilities_table.is_layout_table": False,
350 },
351 "expected": False,
352 },
353 {
354 "id": "table_row_focusable",
355 "mocks_config": {
356 "ax_utilities_role.is_table_row": True,
357 "ax_utilities_state.is_focusable": True,
358 },
359 "expected": False,
360 },
361 {
362 "id": "table_row_selectable",
363 "mocks_config": {
364 "ax_utilities_role.is_table_row": True,
365 "ax_utilities_state.is_focusable": False,
366 "ax_utilities_state.is_selectable": True,
367 },
368 "expected": False,
369 },
370 {
371 "id": "table_row_expandable",
372 "mocks_config": {
373 "ax_utilities_role.is_table_row": True,
374 "ax_utilities_state.is_focusable": False,
375 "ax_utilities_state.is_selectable": False,
376 "ax_utilities_state.is_expandable": True,
377 },
378 "expected": False,
379 },
380 {
381 "id": "table_row_has_explicit_name",
382 "mocks_config": {
383 "ax_utilities_role.is_table_row": True,
384 "ax_utilities_state.is_focusable": False,
385 "ax_utilities_state.is_selectable": False,
386 "ax_utilities_state.is_expandable": False,
387 "has_explicit_name": True,
388 },
389 "expected": False,
390 },
391 {
392 "id": "table_row_layout_only",
393 "mocks_config": {
394 "ax_utilities_role.is_table_row": True,
395 "ax_utilities_state.is_focusable": False,
396 "ax_utilities_state.is_selectable": False,
397 "ax_utilities_state.is_expandable": False,
398 "has_explicit_name": False,
399 },
400 "expected": True,
401 },
402 {
403 "id": "other_role_returns_false",
404 "mocks_config": {"ax_object.get_role": Atspi.Role.BUTTON},
405 "expected": False,
406 },
407 {
408 "id": "wrapper_method",
409 "mocks_config": {"_is_layout_only": (True, "wrapper test")},
410 "expected": True,
411 },
412 ],
413 ids=lambda case: case["id"],
414 )
415 def test_is_layout_only_scenarios( # pylint: disable=too-many-branches,too-many-statements
416 self,
417 test_context: OrcaTestContext,
418 case: dict,
419 ) -> None:
420 """Test AXUtilities.is_layout_only with various scenarios."""
421 mocks_config = case["mocks_config"]
422 expected = case["expected"]
423 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
424
425 for mock_path, mock_value in mocks_config.items():
426 if mock_path == "has_explicit_name":
427 test_context.patch(
428 "orca.ax_utilities.AXUtilities.has_explicit_name",
429 return_value=mock_value,
430 )
431 elif mock_path == "_is_layout_only":
432 test_context.patch(
433 "orca.ax_utilities.AXUtilities._is_layout_only",
434 return_value=mock_value,
435 )
436 elif mock_path.startswith("ax_object.find_ancestor"):
437 if mock_value == "desktop":
438 mock_desktop = test_context.Mock(spec=Atspi.Accessible)
439 essential_modules[
440 "orca.ax_utilities_object"
441 ].AXUtilitiesObject.find_ancestor = test_context.Mock(
442 return_value=mock_desktop,
443 )
444 elif mock_value == "combo_box":
445 mock_combo = test_context.Mock(spec=Atspi.Accessible)
446 essential_modules[
447 "orca.ax_utilities_object"
448 ].AXUtilitiesObject.find_ancestor = test_context.Mock(
449 return_value=mock_combo,
450 )
451 else:
452 essential_modules[
453 "orca.ax_utilities_object"
454 ].AXUtilitiesObject.find_ancestor = test_context.Mock(
455 return_value=None,
456 )
457 elif mock_path.startswith("ax_utilities_action.has_action"):
458 essential_modules[
459 "orca.ax_utilities_action"
460 ].AXUtilitiesAction.has_action = test_context.Mock(
461 return_value=mock_value,
462 )
463 elif mock_path.startswith("ax_object.get_role"):
464 essential_modules["orca.ax_object"].AXObject.get_role = test_context.Mock(
465 return_value=mock_value,
466 )
467 elif mock_path.startswith("ax_utilities_role."):
468 method_name = mock_path.split(".", 1)[1]
469 setattr(
470 essential_modules["orca.ax_utilities_role"].AXUtilitiesRole,
471 method_name,
472 test_context.Mock(return_value=mock_value),
473 )
474 elif mock_path.startswith("ax_utilities_state."):
475 method_name = mock_path.split(".", 1)[1]
476 setattr(
477 essential_modules["orca.ax_utilities_state"].AXUtilitiesState,
478 method_name,
479 test_context.Mock(return_value=mock_value),
480 )
481 elif mock_path.startswith("ax_table."):
482 method_name = mock_path.split(".", 1)[1]
483 setattr(
484 essential_modules["orca.ax_table"].AXTable,
485 method_name,
486 test_context.Mock(return_value=mock_value),
487 )
488 elif mock_path.startswith("ax_utilities_table."):
489 method_name = mock_path.split(".", 1)[1]
490 setattr(
491 essential_modules["orca.ax_utilities_table"].AXUtilitiesTable,
492 method_name,
493 test_context.Mock(return_value=mock_value),
494 )
495
496 from orca.ax_utilities import AXUtilities
497
498 mock_obj = test_context.Mock(spec=Atspi.Accessible)
499 result = AXUtilities.is_layout_only(mock_obj)
500 assert result is expected
501
502 def test_get_on_screen_objects_leaf_node(self, test_context: OrcaTestContext) -> None:
503 """Test AXUtilities._get_on_screen_objects with leaf node."""
504
505 self._setup_dependencies(test_context)
506 from orca.ax_utilities import AXUtilities
507
508 mock_obj = test_context.Mock(spec=Atspi.Accessible)
509 test_context.patch_object(AXUtilities, "is_on_screen", side_effect=lambda obj, bbox: True)
510 test_context.patch_object(AXUtilities, "treat_as_leaf_node", return_value=True)
511 result = AXUtilities.get_on_screen_objects(mock_obj)
512 assert result == [mock_obj]
513
514 def test_sort_by_child_index_needs_sorting(self, test_context: OrcaTestContext) -> None:
515 """Test sorting behavior through public methods that use _sort_by_child_index."""
516
517 mock_obj1, mock_obj2, mock_obj3 = [
518 test_context.Mock(spec=Atspi.Accessible) for _ in range(3)
519 ]
520
521 def mock_get_index(obj):
522 if obj == mock_obj1:
523 return 2
524 if obj == mock_obj2:
525 return 0
526 if obj == mock_obj3:
527 return 1
528 return 0
529
530 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
531 essential_modules["orca.ax_object"].AXObject.get_index_in_parent = mock_get_index
532 from orca.ax_utilities import AXUtilities
533
534 mock_sort = test_context.Mock()
535 test_context.patch_object(AXUtilities, "_sort_by_child_index", new=mock_sort)
536 input_list = [mock_obj1, mock_obj2, mock_obj3]
537 expected_result = [mock_obj2, mock_obj3, mock_obj1] # sorted by index: 0, 1, 2
538 mock_sort.return_value = expected_result
539
540 result = mock_sort(input_list)
541 assert result == expected_result
542 mock_sort.assert_called_once_with(input_list)
543
544 def test_get_set_size_with_valid_size(self, test_context: OrcaTestContext) -> None:
545 """Test AXUtilities.get_set_size with valid set size."""
546
547 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
548 essential_modules["orca.ax_object"].AXObject.get_attribute = test_context.Mock(
549 return_value="5",
550 )
551 from orca.ax_utilities import AXUtilities
552
553 mock_obj = test_context.Mock(spec=Atspi.Accessible)
554 result = AXUtilities.get_set_size(mock_obj)
555 assert result == 5
556
557 def test_get_set_size_is_unknown_true(self, test_context: OrcaTestContext) -> None:
558 """Test AXUtilities.get_set_size_is_unknown returns True for unknown size."""
559
560 self._setup_dependencies(test_context)
561 from orca.ax_utilities import AXUtilities
562
563 test_context.patch_object(AXUtilities, "get_set_size", return_value=-1)
564 mock_obj = test_context.Mock(spec=Atspi.Accessible)
565 result = AXUtilities.get_set_size_is_unknown(mock_obj)
566 assert result is True
567
568 def test_treat_as_leaf_node_with_child_count(self, test_context: OrcaTestContext) -> None:
569 """Test AXUtilities.treat_as_leaf_node with objects having children."""
570
571 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
572 essential_modules["orca.ax_object"].AXObject.get_child_count = test_context.Mock(
573 return_value=3,
574 )
575 from orca.ax_utilities import AXUtilities
576
577 mock_obj = test_context.Mock(spec=Atspi.Accessible)
578 result = AXUtilities.treat_as_leaf_node(mock_obj)
579 assert result is False
580
581 def test_treat_as_leaf_node_without_children(self, test_context: OrcaTestContext) -> None:
582 """Test AXUtilities.treat_as_leaf_node with objects having presentational children."""
583
584 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
585 essential_modules[
586 "orca.ax_utilities_role"
587 ].AXUtilitiesRole.children_are_presentational = test_context.Mock(return_value=True)
588 essential_modules["orca.ax_utilities_role"].AXUtilitiesRole.is_page_tab = test_context.Mock(
589 return_value=False,
590 )
591 from orca.ax_utilities import AXUtilities
592
593 mock_obj = test_context.Mock(spec=Atspi.Accessible)
594 result = AXUtilities.treat_as_leaf_node(mock_obj)
595 assert result is True
596
597 def test_has_visible_caption_without_label(self, test_context: OrcaTestContext) -> None:
598 """Test AXUtilities.has_visible_caption without visible label."""
599
600 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
601 essential_modules["orca.ax_utilities_role"].AXUtilitiesRole.is_label = test_context.Mock(
602 return_value=False,
603 )
604 from orca.ax_utilities import AXUtilities
605
606 mock_obj = test_context.Mock(spec=Atspi.Accessible)
607 result = AXUtilities.has_visible_caption(mock_obj)
608 assert result is False
609
610 def test_get_displayed_label_with_name(self, test_context: OrcaTestContext) -> None:
611 """Test AXUtilities.get_displayed_label with labelling objects."""
612
613 mock_label1 = test_context.Mock(spec=Atspi.Accessible)
614 mock_label2 = test_context.Mock(spec=Atspi.Accessible)
615 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
616 essential_modules[
617 "orca.ax_utilities_relation"
618 ].AXUtilitiesRelation.get_is_labelled_by = test_context.Mock(
619 return_value=[mock_label1, mock_label2],
620 )
621
622 def mock_get_name(obj):
623 if obj == mock_label1:
624 return "Button"
625 if obj == mock_label2:
626 return "Label"
627 return ""
628
629 essential_modules["orca.ax_object"].AXObject.get_name = mock_get_name
630 from orca.ax_utilities import AXUtilities
631
632 mock_obj = test_context.Mock(spec=Atspi.Accessible)
633 result = AXUtilities.get_displayed_label(mock_obj)
634 assert result == "Button Label"
635
636 def test_get_displayed_description_with_description(
637 self,
638 test_context: OrcaTestContext,
639 ) -> None:
640 """Test AXUtilities.get_displayed_description with describing objects."""
641
642 mock_desc1 = test_context.Mock(spec=Atspi.Accessible)
643 mock_desc2 = test_context.Mock(spec=Atspi.Accessible)
644 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
645 essential_modules[
646 "orca.ax_utilities_relation"
647 ].AXUtilitiesRelation.get_is_described_by = test_context.Mock(
648 return_value=[mock_desc1, mock_desc2],
649 )
650
651 def mock_get_name(obj):
652 if obj == mock_desc1:
653 return "Button"
654 if obj == mock_desc2:
655 return "description"
656 return ""
657
658 essential_modules["orca.ax_object"].AXObject.get_name = mock_get_name
659 from orca.ax_utilities import AXUtilities
660
661 mock_obj = test_context.Mock(spec=Atspi.Accessible)
662 result = AXUtilities.get_displayed_description(mock_obj)
663 assert result == "Button description"
664
665 def test_get_heading_level_with_level(self, test_context: OrcaTestContext) -> None:
666 """Test AXUtilities.get_heading_level with heading level."""
667
668 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
669 essential_modules["orca.ax_utilities_role"].AXUtilitiesRole.is_heading = test_context.Mock(
670 return_value=True,
671 )
672 essential_modules["orca.ax_object"].AXObject.get_attributes_dict = test_context.Mock(
673 return_value={"level": "2"},
674 )
675 from orca.ax_utilities import AXUtilities
676
677 mock_obj = test_context.Mock(spec=Atspi.Accessible)
678 result = AXUtilities.get_heading_level(mock_obj)
679 assert result == 2
680
681 def test_get_heading_level_invalid(self, test_context: OrcaTestContext) -> None:
682 """Test AXUtilities.get_heading_level with invalid level."""
683
684 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
685 essential_modules["orca.ax_utilities_role"].AXUtilitiesRole.is_heading = test_context.Mock(
686 return_value=True,
687 )
688 essential_modules["orca.ax_object"].AXObject.get_attributes_dict = test_context.Mock(
689 return_value={"level": "invalid"},
690 )
691 from orca.ax_utilities import AXUtilities
692
693 mock_obj = test_context.Mock(spec=Atspi.Accessible)
694 result = AXUtilities.get_heading_level(mock_obj)
695 assert result == 0
696
697 @pytest.mark.parametrize(
698 "case",
699 [
700 {
701 "id": "alert_dialog",
702 "is_dialog": True,
703 "supports_collection": False,
704 "get_all_widgets": [],
705 "collection_checks": {},
706 "expected": True,
707 },
708 {
709 "id": "regular_dialog",
710 "is_dialog": True,
711 "supports_collection": True,
712 "get_all_widgets": [],
713 "collection_checks": {
714 "has_scroll_pane": False,
715 "has_split_pane": False,
716 "has_tree_or_tree_table": False,
717 "has_combo_box_or_list_box": False,
718 "has_editable_object": False,
719 },
720 "expected": True,
721 },
722 {
723 "id": "non_dialog",
724 "is_dialog": False,
725 "supports_collection": None,
726 "get_all_widgets": [],
727 "collection_checks": {},
728 "expected": False,
729 },
730 {
731 "id": "no_collection_support_with_widgets",
732 "is_dialog": True,
733 "supports_collection": False,
734 "get_all_widgets": ["widget1"],
735 "collection_checks": {},
736 "expected": False,
737 },
738 {
739 "id": "no_collection_support_no_widgets",
740 "is_dialog": True,
741 "supports_collection": False,
742 "get_all_widgets": [],
743 "collection_checks": {},
744 "expected": True,
745 },
746 {
747 "id": "has_scroll_pane",
748 "is_dialog": True,
749 "supports_collection": True,
750 "get_all_widgets": [],
751 "collection_checks": {"has_scroll_pane": True},
752 "expected": False,
753 },
754 {
755 "id": "has_split_pane",
756 "is_dialog": True,
757 "supports_collection": True,
758 "get_all_widgets": [],
759 "collection_checks": {"has_scroll_pane": False, "has_split_pane": True},
760 "expected": False,
761 },
762 {
763 "id": "has_tree_or_tree_table",
764 "is_dialog": True,
765 "supports_collection": True,
766 "get_all_widgets": [],
767 "collection_checks": {
768 "has_scroll_pane": False,
769 "has_split_pane": False,
770 "has_tree_or_tree_table": True,
771 },
772 "expected": False,
773 },
774 {
775 "id": "has_combo_box_or_list_box",
776 "is_dialog": True,
777 "supports_collection": True,
778 "get_all_widgets": [],
779 "collection_checks": {
780 "has_scroll_pane": False,
781 "has_split_pane": False,
782 "has_tree_or_tree_table": False,
783 "has_combo_box_or_list_box": True,
784 },
785 "expected": False,
786 },
787 {
788 "id": "has_editable_object",
789 "is_dialog": True,
790 "supports_collection": True,
791 "get_all_widgets": [],
792 "collection_checks": {
793 "has_scroll_pane": False,
794 "has_split_pane": False,
795 "has_tree_or_tree_table": False,
796 "has_combo_box_or_list_box": False,
797 "has_editable_object": True,
798 },
799 "expected": False,
800 },
801 {
802 "id": "true_case",
803 "is_dialog": True,
804 "supports_collection": True,
805 "get_all_widgets": [],
806 "collection_checks": {
807 "has_scroll_pane": False,
808 "has_split_pane": False,
809 "has_tree_or_tree_table": False,
810 "has_combo_box_or_list_box": False,
811 "has_editable_object": False,
812 },
813 "expected": True,
814 },
815 ],
816 ids=lambda case: case["id"],
817 )
818 def test_is_message_dialog_scenarios( # pylint: disable=too-many-branches,too-many-positional-arguments
819 self,
820 test_context: OrcaTestContext,
821 case: dict,
822 ) -> None:
823 """Test AXUtilities.is_message_dialog with various scenarios."""
824 is_dialog = case["is_dialog"]
825 supports_collection = case["supports_collection"]
826 get_all_widgets = case["get_all_widgets"]
827 collection_checks = case["collection_checks"]
828 expected = case["expected"]
829 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
830
831 essential_modules[
832 "orca.ax_utilities_role"
833 ].AXUtilitiesRole.is_dialog_or_alert = test_context.Mock(return_value=is_dialog)
834
835 if supports_collection is not None:
836 essential_modules["orca.ax_object"].AXObject.supports_collection = test_context.Mock(
837 return_value=supports_collection,
838 )
839
840 if not supports_collection and get_all_widgets is not None:
841 test_context.patch(
842 "orca.ax_utilities.AXUtilities.get_all_widgets",
843 return_value=get_all_widgets,
844 )
845
846 for check_name, check_value in collection_checks.items():
847 if check_name in ["has_scroll_pane", "has_split_pane"]:
848 setattr(
849 essential_modules["orca.ax_utilities_collection"].AXUtilitiesCollection,
850 check_name,
851 test_context.Mock(return_value=check_value),
852 )
853 else:
854 setattr(
855 sys.modules["orca.ax_utilities_collection"].AXUtilitiesCollection,
856 check_name,
857 test_context.Mock(return_value=check_value),
858 )
859
860 from orca.ax_utilities import AXUtilities
861
862 mock_obj = test_context.Mock(spec=Atspi.Accessible)
863 result = AXUtilities.is_message_dialog(mock_obj)
864 assert result is expected
865
866 def test_can_be_active_window_with_dialog(self, test_context: OrcaTestContext) -> None:
867 """Test AXUtilities.can_be_active_window with dialog window."""
868
869 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
870 essential_modules["orca.ax_utilities_state"].AXUtilitiesState.is_active = test_context.Mock(
871 return_value=True,
872 )
873 essential_modules[
874 "orca.ax_utilities_state"
875 ].AXUtilitiesState.is_showing = test_context.Mock(return_value=True)
876 essential_modules[
877 "orca.ax_utilities_state"
878 ].AXUtilitiesState.is_iconified = test_context.Mock(return_value=False)
879 from orca.ax_utilities import AXUtilities
880
881 mock_obj = test_context.Mock(spec=Atspi.Accessible)
882 result = AXUtilities.can_be_active_window(mock_obj)
883 assert result is True
884
885 def test_can_be_active_window_with_hidden_window(self, test_context: OrcaTestContext) -> None:
886 """Test AXUtilities.can_be_active_window with hidden window."""
887
888 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
889 essential_modules["orca.ax_object"].AXObject.get_role = test_context.Mock(
890 return_value=Atspi.Role.FRAME,
891 )
892 essential_modules[
893 "orca.ax_utilities_state"
894 ].AXUtilitiesState.is_showing = test_context.Mock(return_value=False)
895 from orca.ax_utilities import AXUtilities
896
897 mock_obj = test_context.Mock(spec=Atspi.Accessible)
898 result = AXUtilities.can_be_active_window(mock_obj)
899 assert result is False
900
901 def test_can_be_active_window_with_none(self, test_context: OrcaTestContext) -> None:
902 """Test AXUtilities.can_be_active_window with None object."""
903
904 self._setup_dependencies(test_context)
905 from orca.ax_utilities import AXUtilities
906
907 result = AXUtilities.can_be_active_window(None)
908 assert result is False
909
910 def test_is_unfocused_alert_or_dialog_with_alert(self, test_context: OrcaTestContext) -> None:
911 """Test AXUtilities.is_unfocused_alert_or_dialog with alert."""
912
913 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
914 essential_modules[
915 "orca.ax_utilities_role"
916 ].AXUtilitiesRole.is_dialog_or_alert = test_context.Mock(return_value=True)
917 essential_modules["orca.ax_object"].AXObject.get_child_count = test_context.Mock(
918 return_value=1,
919 )
920 essential_modules[
921 "orca.ax_utilities_state"
922 ].AXUtilitiesState.is_showing = test_context.Mock(return_value=True)
923 from orca.ax_utilities import AXUtilities
924
925 test_context.patch_object(AXUtilities, "can_be_active_window", return_value=False)
926 mock_obj = test_context.Mock(spec=Atspi.Accessible)
927 result = AXUtilities.is_unfocused_alert_or_dialog(mock_obj)
928 assert result is True
929
930 def test_is_unfocused_alert_or_dialog_with_focused_dialog(
931 self,
932 test_context: OrcaTestContext,
933 ) -> None:
934 """Test AXUtilities.is_unfocused_alert_or_dialog with focused dialog."""
935
936 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
937 essential_modules["orca.ax_object"].AXObject.get_role = test_context.Mock(
938 return_value=Atspi.Role.DIALOG,
939 )
940 essential_modules[
941 "orca.ax_utilities_state"
942 ].AXUtilitiesState.is_focused = test_context.Mock(return_value=True)
943 from orca.ax_utilities import AXUtilities
944
945 mock_obj = test_context.Mock(spec=Atspi.Accessible)
946 result = AXUtilities.is_unfocused_alert_or_dialog(mock_obj)
947 assert result is False
948
949 def test_is_unfocused_alert_or_dialog_with_no_children(
950 self,
951 test_context: OrcaTestContext,
952 ) -> None:
953 """Test AXUtilities.is_unfocused_alert_or_dialog with alert having no children."""
954
955 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
956 essential_modules[
957 "orca.ax_utilities_role"
958 ].AXUtilitiesRole.is_dialog_or_alert = test_context.Mock(return_value=True)
959 essential_modules["orca.ax_object"].AXObject.get_child_count = test_context.Mock(
960 return_value=0,
961 )
962 from orca.ax_utilities import AXUtilities
963
964 mock_obj = test_context.Mock(spec=Atspi.Accessible)
965 result = AXUtilities.is_unfocused_alert_or_dialog(mock_obj)
966 assert result is False
967
968 def test_is_unfocused_alert_or_dialog_not_showing(self, test_context: OrcaTestContext) -> None:
969 """Test AXUtilities.is_unfocused_alert_or_dialog with alert not showing."""
970
971 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
972 essential_modules[
973 "orca.ax_utilities_role"
974 ].AXUtilitiesRole.is_dialog_or_alert = test_context.Mock(return_value=True)
975 essential_modules["orca.ax_object"].AXObject.get_child_count = test_context.Mock(
976 return_value=3,
977 )
978 essential_modules[
979 "orca.ax_utilities_state"
980 ].AXUtilitiesState.is_showing = test_context.Mock(return_value=False)
981 from orca.ax_utilities import AXUtilities
982
983 mock_obj = test_context.Mock(spec=Atspi.Accessible)
984 result = AXUtilities.is_unfocused_alert_or_dialog(mock_obj)
985 assert result is False
986
987 def test_get_unfocused_alerts_and_dialogs_with_alerts(
988 self,
989 test_context: OrcaTestContext,
990 ) -> None:
991 """Test AXUtilities.get_unfocused_alerts_and_dialogs with alert objects."""
992
993 mock_alert1 = test_context.Mock(spec=Atspi.Accessible)
994 mock_alert2 = test_context.Mock(spec=Atspi.Accessible)
995 mock_normal = test_context.Mock(spec=Atspi.Accessible)
996 mock_app = test_context.Mock(spec=Atspi.Accessible)
997 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
998 essential_modules[
999 "orca.ax_utilities_application"
1000 ].AXUtilitiesApplication.get_application = test_context.Mock(return_value=mock_app)
1001 essential_modules[
1002 "orca.ax_utilities_object"
1003 ].AXUtilitiesObject.find_ancestor = test_context.Mock(
1004 return_value=None,
1005 )
1006
1007 def mock_iter_children(parent, predicate=None):
1008 if parent == mock_app:
1009 all_children = [mock_alert1, mock_alert2, mock_normal]
1010 if predicate:
1011 return [obj for obj in all_children if predicate(obj)]
1012 return all_children
1013 return []
1014
1015 essential_modules["orca.ax_object"].AXObject.iter_children = mock_iter_children
1016 from orca.ax_utilities import AXUtilities
1017
1018 def mock_is_unfocused(obj):
1019 return obj in [mock_alert1, mock_alert2]
1020
1021 test_context.patch_object(
1022 AXUtilities,
1023 "is_unfocused_alert_or_dialog",
1024 new=mock_is_unfocused,
1025 )
1026 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1027 result = AXUtilities.get_unfocused_alerts_and_dialogs(mock_obj)
1028 assert result == [mock_alert1, mock_alert2]
1029
1030 def test_get_all_widgets_with_button_predicate(self, test_context: OrcaTestContext) -> None:
1031 """Test AXUtilities.get_all_widgets returns widget objects."""
1032
1033 mock_button1 = test_context.Mock(spec=Atspi.Accessible)
1034 mock_button2 = test_context.Mock(spec=Atspi.Accessible)
1035 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1036 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1037 essential_modules["orca.ax_object"].AXObject.supports_collection = test_context.Mock(
1038 return_value=True,
1039 )
1040 essential_modules[
1041 "orca.ax_utilities_role"
1042 ].AXUtilitiesRole.get_widget_roles = test_context.Mock(
1043 return_value=[
1044 Atspi.Role.BUTTON,
1045 Atspi.Role.CHECK_BOX,
1046 ],
1047 )
1048 sys.modules[
1049 "orca.ax_utilities_collection"
1050 ].AXUtilitiesCollection.find_all_with_role_and_all_states = test_context.Mock(
1051 return_value=[mock_button1, mock_button2],
1052 )
1053 from orca.ax_utilities import AXUtilities
1054
1055 result = AXUtilities.get_all_widgets(mock_obj, must_be_showing_and_visible=True)
1056 assert result == [mock_button1, mock_button2]
1057
1058 def test_get_all_widgets_exclude_push_button(self, test_context: OrcaTestContext) -> None:
1059 """Test AXUtilities.get_all_widgets with exclude_push_button=True."""
1060
1061 mock_checkbox = test_context.Mock(spec=Atspi.Accessible)
1062 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1063 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1064 essential_modules["orca.ax_object"].AXObject.supports_collection = test_context.Mock(
1065 return_value=True,
1066 )
1067 essential_modules[
1068 "orca.ax_utilities_role"
1069 ].AXUtilitiesRole.get_widget_roles = test_context.Mock(
1070 return_value=[
1071 Atspi.Role.BUTTON,
1072 Atspi.Role.CHECK_BOX,
1073 ],
1074 )
1075 sys.modules[
1076 "orca.ax_utilities_collection"
1077 ].AXUtilitiesCollection.find_all_with_role_and_all_states = test_context.Mock(
1078 return_value=[mock_checkbox],
1079 )
1080 from orca.ax_utilities import AXUtilities
1081
1082 result = AXUtilities.get_all_widgets(mock_obj, exclude_push_button=True)
1083 # Should call with CHECK_BOX only (BUTTON removed)
1084 collection_module = sys.modules["orca.ax_utilities_collection"]
1085 find_all_method = collection_module.AXUtilitiesCollection.find_all_with_role_and_all_states
1086 find_all_method.assert_called_with(
1087 mock_obj,
1088 [Atspi.Role.CHECK_BOX],
1089 [Atspi.StateType.SHOWING, Atspi.StateType.VISIBLE],
1090 )
1091 assert result == [mock_checkbox]
1092
1093 def test_get_default_button_with_default_button(self, test_context: OrcaTestContext) -> None:
1094 """Test AXUtilities.get_default_button with default button."""
1095
1096 mock_default_button = test_context.Mock(spec=Atspi.Accessible)
1097 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1098 essential_modules["orca.ax_object"].AXObject.supports_collection = test_context.Mock(
1099 return_value=True,
1100 )
1101 sys.modules[
1102 "orca.ax_utilities_collection"
1103 ].AXUtilitiesCollection.find_default_button = test_context.Mock(
1104 return_value=mock_default_button,
1105 )
1106 from orca.ax_utilities import AXUtilities
1107
1108 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1109 result = AXUtilities.get_default_button(mock_obj)
1110 assert result == mock_default_button
1111
1112 def test_get_focused_object_with_focused_descendant(
1113 self,
1114 test_context: OrcaTestContext,
1115 ) -> None:
1116 """Test AXUtilities.get_focused_object with focused descendant."""
1117
1118 mock_focused = test_context.Mock(spec=Atspi.Accessible)
1119 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1120 essential_modules["orca.ax_object"].AXObject.supports_collection = test_context.Mock(
1121 return_value=True,
1122 )
1123 sys.modules[
1124 "orca.ax_utilities_collection"
1125 ].AXUtilitiesCollection.find_focused_object = test_context.Mock(return_value=mock_focused)
1126 from orca.ax_utilities import AXUtilities
1127
1128 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1129 result = AXUtilities.get_focused_object(mock_obj)
1130 assert result == mock_focused
1131
1132 def test_get_info_bar_with_info_bar(self, test_context: OrcaTestContext) -> None:
1133 """Test AXUtilities.get_info_bar with info bar descendant."""
1134
1135 mock_info_bar = test_context.Mock(spec=Atspi.Accessible)
1136 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1137 essential_modules["orca.ax_object"].AXObject.supports_collection = test_context.Mock(
1138 return_value=True,
1139 )
1140 essential_modules[
1141 "orca.ax_utilities_collection"
1142 ].AXUtilitiesCollection.find_info_bar = test_context.Mock(return_value=mock_info_bar)
1143 from orca.ax_utilities import AXUtilities
1144
1145 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1146 result = AXUtilities.get_info_bar(mock_obj)
1147 assert result == mock_info_bar
1148
1149 def test_get_status_bar_with_status_bar(self, test_context: OrcaTestContext) -> None:
1150 """Test AXUtilities.get_status_bar with status bar descendant."""
1151
1152 mock_status_bar = test_context.Mock(spec=Atspi.Accessible)
1153 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1154 essential_modules["orca.ax_object"].AXObject.supports_collection = test_context.Mock(
1155 return_value=True,
1156 )
1157 essential_modules[
1158 "orca.ax_utilities_collection"
1159 ].AXUtilitiesCollection.find_status_bar = test_context.Mock(return_value=mock_status_bar)
1160 from orca.ax_utilities import AXUtilities
1161
1162 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1163 result = AXUtilities.get_status_bar(mock_obj)
1164 assert result == mock_status_bar
1165
1166 def test_clear_all_cache_now_with_object(self, test_context: OrcaTestContext) -> None:
1167 """Test AXUtilities.clear_all_cache_now with specific object."""
1168
1169 self._setup_dependencies(test_context)
1170 from orca.ax_utilities import AXUtilities
1171
1172 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1173 AXUtilities.clear_all_cache_now(mock_obj, "test reason")
1174
1175 def test_clear_all_cache_now_without_object(self, test_context: OrcaTestContext) -> None:
1176 """Test AXUtilities.clear_all_cache_now without specific object."""
1177
1178 self._setup_dependencies(test_context)
1179 from orca.ax_utilities import AXUtilities
1180
1181 AXUtilities.clear_all_cache_now(None, "test reason")
1182
1183 def test_get_set_members_with_basic_set(self, test_context: OrcaTestContext) -> None:
1184 """Test AXUtilities.get_set_members with basic set."""
1185
1186 mock_member1 = test_context.Mock(spec=Atspi.Accessible)
1187 mock_member2 = test_context.Mock(spec=Atspi.Accessible)
1188 self._setup_dependencies(test_context)
1189 from orca.ax_utilities import AXUtilities
1190
1191 test_context.patch_object(
1192 AXUtilities,
1193 "_get_set_members",
1194 return_value=[mock_member1, mock_member2],
1195 )
1196 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1197 result = AXUtilities.get_set_members(mock_obj)
1198 assert result == [mock_member1, mock_member2]
1199
1200 def test_get_set_members_with_empty_set(self, test_context: OrcaTestContext) -> None:
1201 """Test AXUtilities.get_set_members with empty set."""
1202
1203 self._setup_dependencies(test_context)
1204 from orca.ax_utilities import AXUtilities
1205
1206 test_context.patch_object(AXUtilities, "_get_set_members", return_value=[])
1207 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1208 result = AXUtilities.get_set_members(mock_obj)
1209 assert result == []
1210
1211 def test_find_active_window_with_active_window(self, test_context: OrcaTestContext) -> None:
1212 """Test AXUtilities.find_active_window with active window."""
1213
1214 mock_active_window = test_context.Mock(spec=Atspi.Accessible)
1215 mock_app = test_context.Mock(spec=Atspi.Accessible)
1216 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1217 sys.modules[
1218 "orca.ax_utilities_application"
1219 ].AXUtilitiesApplication.get_all_applications = test_context.Mock(return_value=[mock_app])
1220 essential_modules["orca.ax_object"].AXObject.iter_children = test_context.Mock(
1221 return_value=[mock_active_window],
1222 )
1223 from orca.ax_utilities import AXUtilities
1224
1225 test_context.patch_object(
1226 AXUtilities,
1227 "can_be_active_window",
1228 side_effect=lambda x: x == mock_active_window,
1229 )
1230 result = AXUtilities.find_active_window()
1231 assert result == mock_active_window
1232
1233 def test_find_active_window_with_no_active_window(self, test_context: OrcaTestContext) -> None:
1234 """Test AXUtilities.find_active_window with no active window."""
1235
1236 self._setup_dependencies(test_context)
1237 sys.modules[
1238 "orca.ax_utilities_application"
1239 ].AXUtilitiesApplication.get_all_applications = test_context.Mock(return_value=[])
1240 from orca.ax_utilities import AXUtilities
1241
1242 result = AXUtilities.find_active_window()
1243 assert result is None
1244
1245 def test_start_cache_clearing_thread(self, test_context: OrcaTestContext) -> None:
1246 """Test AXUtilities.start_cache_clearing_thread."""
1247
1248 self._setup_dependencies(test_context)
1249 from orca.ax_utilities import AXUtilities
1250
1251 mock_start_thread = test_context.Mock()
1252 test_context.patch_object(AXUtilities, "start_cache_clearing_thread", new=mock_start_thread)
1253 mock_start_thread()
1254 mock_start_thread.assert_called_once()
1255
1256 def test_get_on_screen_objects_with_invalid_root(self, test_context: OrcaTestContext) -> None:
1257 """Test AXUtilities.get_on_screen_objects with invalid root."""
1258
1259 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1260 essential_modules["orca.ax_object"].AXObject.is_valid = test_context.Mock(
1261 return_value=False,
1262 )
1263 essential_modules["orca.ax_table"].AXTable.iter_visible_cells = test_context.Mock(
1264 return_value=[],
1265 )
1266 from orca.ax_utilities import AXUtilities
1267
1268 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1269 result = AXUtilities.get_on_screen_objects(mock_obj)
1270 assert result == []
1271
1272 def test_clear_all_dictionaries_with_reason(self, test_context: OrcaTestContext) -> None:
1273 """Test cache clearing functionality with reason."""
1274
1275 self._setup_dependencies(test_context)
1276 from orca.ax_utilities import AXUtilities
1277
1278 test_context.patch_object(AXUtilities, "SET_MEMBERS", new={"test": "data"})
1279 test_context.patch_object(AXUtilities, "IS_LAYOUT_ONLY", new={"test": "data"})
1280 mock_clear = test_context.Mock()
1281 test_context.patch_object(AXUtilities, "_clear_all_dictionaries", new=mock_clear)
1282
1283 AXUtilities.clear_all_cache_now(reason="test reason")
1284
1285 mock_clear.assert_called()
1286
1287 def test_clear_all_dictionaries_without_reason(self, test_context: OrcaTestContext) -> None:
1288 """Test cache clearing functionality without reason."""
1289
1290 self._setup_dependencies(test_context)
1291 from orca.ax_utilities import AXUtilities
1292
1293 test_context.patch_object(AXUtilities, "SET_MEMBERS", new={"test": "data"})
1294 test_context.patch_object(AXUtilities, "IS_LAYOUT_ONLY", new={"test": "data"})
1295 mock_clear = test_context.Mock()
1296 test_context.patch_object(AXUtilities, "_clear_all_dictionaries", new=mock_clear)
1297
1298 AXUtilities.clear_all_cache_now()
1299
1300 mock_clear.assert_called()
1301
1302 def test_get_nesting_level_list_item(self, test_context: OrcaTestContext) -> None:
1303 """Test AXUtilities.get_nesting_level with list item."""
1304
1305 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1306 mock_ancestor1 = test_context.Mock(spec=Atspi.Accessible)
1307 mock_ancestor2 = test_context.Mock(spec=Atspi.Accessible)
1308 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1309 essential_modules[
1310 "orca.ax_utilities_role"
1311 ].AXUtilitiesRole.is_list_item = test_context.Mock(return_value=True)
1312 essential_modules["orca.ax_utilities_role"].AXUtilitiesRole.is_list = test_context.Mock(
1313 return_value=True,
1314 )
1315 find_calls = []
1316
1317 def mock_find_ancestor(obj, _pred):
1318 find_calls.append(obj)
1319 if obj == mock_obj:
1320 return mock_ancestor1
1321 if obj == mock_ancestor1:
1322 return mock_ancestor2
1323 return None
1324
1325 essential_modules[
1326 "orca.ax_utilities_object"
1327 ].AXUtilitiesObject.find_ancestor = mock_find_ancestor
1328 essential_modules["orca.ax_object"].AXObject.get_parent = test_context.Mock(
1329 return_value=mock_obj,
1330 )
1331 from orca.ax_utilities import AXUtilities
1332
1333 result = AXUtilities.get_nesting_level(mock_obj)
1334 assert result == 2
1335
1336 def test_get_nesting_level_regular_object(self, test_context: OrcaTestContext) -> None:
1337 """Test AXUtilities.get_nesting_level with regular object."""
1338
1339 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1340 mock_ancestor1 = test_context.Mock(spec=Atspi.Accessible)
1341 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1342 essential_modules[
1343 "orca.ax_utilities_role"
1344 ].AXUtilitiesRole.is_list_item = test_context.Mock(return_value=False)
1345 essential_modules[
1346 "orca.ax_utilities_role"
1347 ].AXUtilitiesRole.have_same_role = test_context.Mock(return_value=True)
1348 find_calls = []
1349
1350 def mock_find_ancestor(obj, _pred):
1351 find_calls.append(obj)
1352 if obj == mock_obj:
1353 return mock_ancestor1
1354 return None
1355
1356 essential_modules[
1357 "orca.ax_utilities_object"
1358 ].AXUtilitiesObject.find_ancestor = mock_find_ancestor
1359 from orca.ax_utilities import AXUtilities
1360
1361 result = AXUtilities.get_nesting_level(mock_obj)
1362 assert result == 1
1363
1364 def test_get_position_in_set_with_posinset_attribute(
1365 self,
1366 test_context: OrcaTestContext,
1367 ) -> None:
1368 """Test AXUtilities.get_position_in_set with posinset attribute."""
1369
1370 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1371 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1372 essential_modules["orca.ax_object"].AXObject.get_attribute = test_context.Mock(
1373 return_value="3",
1374 )
1375 from orca.ax_utilities import AXUtilities
1376
1377 result = AXUtilities.get_position_in_set(mock_obj)
1378 assert result == 2
1379
1380 def test_get_position_in_set_table_row_with_rowindex(
1381 self,
1382 test_context: OrcaTestContext,
1383 ) -> None:
1384 """Test AXUtilities.get_position_in_set with table row and rowindex."""
1385
1386 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1387 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1388 essential_modules[
1389 "orca.ax_utilities_role"
1390 ].AXUtilitiesRole.is_table_row = test_context.Mock(return_value=True)
1391 get_attribute_calls = []
1392
1393 def mock_get_attribute(obj, attr, use_cache):
1394 get_attribute_calls.append((obj, attr, use_cache))
1395 if attr == "posinset":
1396 return None
1397 if attr == "rowindex":
1398 return "5"
1399 return None
1400
1401 essential_modules["orca.ax_object"].AXObject.get_attribute = mock_get_attribute
1402 from orca.ax_utilities import AXUtilities
1403
1404 result = AXUtilities.get_position_in_set(mock_obj)
1405 assert result == 4
1406
1407 def test_get_position_in_set_fallback_to_set_members(
1408 self,
1409 test_context: OrcaTestContext,
1410 ) -> None:
1411 """Test AXUtilities.get_position_in_set fallback to set members."""
1412
1413 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1414 mock_parent = test_context.Mock(spec=Atspi.Accessible)
1415 mock_member1 = test_context.Mock(spec=Atspi.Accessible)
1416 mock_member2 = test_context.Mock(spec=Atspi.Accessible)
1417 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1418 essential_modules[
1419 "orca.ax_utilities_role"
1420 ].AXUtilitiesRole.is_table_row = test_context.Mock(return_value=False)
1421 essential_modules[
1422 "orca.ax_utilities_role"
1423 ].AXUtilitiesRole.is_table_cell_or_header = test_context.Mock(return_value=False)
1424 essential_modules[
1425 "orca.ax_utilities_role"
1426 ].AXUtilitiesRole.is_combo_box = test_context.Mock(return_value=False)
1427 essential_modules["orca.ax_object"].AXObject.get_attribute = test_context.Mock(
1428 return_value=None,
1429 )
1430 essential_modules["orca.ax_object"].AXObject.get_parent = test_context.Mock(
1431 return_value=mock_parent,
1432 )
1433 essential_modules["orca.ax_object"].AXObject.get_child_count = test_context.Mock(
1434 return_value=100,
1435 )
1436 from orca.ax_utilities import AXUtilities
1437
1438 test_context.patch_object(
1439 AXUtilities,
1440 "get_set_members",
1441 side_effect=lambda x: [mock_member1, mock_obj, mock_member2],
1442 )
1443 result = AXUtilities.get_position_in_set(mock_obj)
1444 assert result == 1
1445
1446 def test_get_set_members_internal_with_none_container(
1447 self,
1448 test_context: OrcaTestContext,
1449 ) -> None:
1450 """Test AXUtilities.get_set_members with None container."""
1451
1452 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1453 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1454
1455 essential_modules["orca.ax_object"].AXObject.get_parent_checked = test_context.Mock(
1456 return_value=None,
1457 )
1458 from orca.ax_utilities import AXUtilities
1459
1460 result = AXUtilities.get_set_members(mock_obj)
1461 assert result == []
1462
1463 def test_get_set_members_internal_with_member_of_relation(
1464 self,
1465 test_context: OrcaTestContext,
1466 ) -> None:
1467 """Test AXUtilities._get_set_members with member-of relation."""
1468
1469 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1470 mock_member1 = test_context.Mock(spec=Atspi.Accessible)
1471 mock_member2 = test_context.Mock(spec=Atspi.Accessible)
1472 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1473 essential_modules[
1474 "orca.ax_utilities_relation"
1475 ].AXUtilitiesRelation.get_is_member_of = test_context.Mock(
1476 return_value=[mock_member1, mock_member2],
1477 )
1478 from orca.ax_utilities import AXUtilities
1479
1480 test_context.patch_object(AXUtilities, "_sort_by_child_index", side_effect=lambda x: x)
1481 result = AXUtilities.get_set_members(mock_obj)
1482 assert result == [mock_member1, mock_member2]
1483
1484 def test_get_set_members_internal_with_node_parent_relation(
1485 self,
1486 test_context: OrcaTestContext,
1487 ) -> None:
1488 """Test AXUtilities._get_set_members with node-parent-of relation."""
1489
1490 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1491 mock_child1 = test_context.Mock(spec=Atspi.Accessible)
1492 mock_child2 = test_context.Mock(spec=Atspi.Accessible)
1493 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1494 essential_modules[
1495 "orca.ax_utilities_relation"
1496 ].AXUtilitiesRelation.get_is_member_of = test_context.Mock(return_value=[])
1497 essential_modules[
1498 "orca.ax_utilities_relation"
1499 ].AXUtilitiesRelation.get_is_node_parent_of = test_context.Mock(
1500 return_value=[mock_child1, mock_child2],
1501 )
1502 from orca.ax_utilities import AXUtilities
1503
1504 test_context.patch_object(AXUtilities, "_sort_by_child_index", side_effect=lambda x: x)
1505 result = AXUtilities.get_set_members(mock_obj)
1506 assert result == [mock_child1, mock_child2]
1507
1508 def test_get_set_members_internal_with_description_values(
1509 self,
1510 test_context: OrcaTestContext,
1511 ) -> None:
1512 """Test AXUtilities._get_set_members with description values."""
1513
1514 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1515 mock_prev = test_context.Mock(spec=Atspi.Accessible)
1516 mock_next = test_context.Mock(spec=Atspi.Accessible)
1517 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1518 essential_modules[
1519 "orca.ax_utilities_relation"
1520 ].AXUtilitiesRelation.get_is_member_of = test_context.Mock(return_value=[])
1521 essential_modules[
1522 "orca.ax_utilities_relation"
1523 ].AXUtilitiesRelation.get_is_node_parent_of = test_context.Mock(return_value=[])
1524 essential_modules[
1525 "orca.ax_utilities_role"
1526 ].AXUtilitiesRole.is_description_value = test_context.Mock(return_value=True)
1527
1528 def mock_get_previous_sibling(obj):
1529 if obj == mock_obj:
1530 return mock_prev
1531 return None
1532
1533 def mock_get_next_sibling(obj):
1534 if obj == mock_obj:
1535 return mock_next
1536 return None
1537
1538 essential_modules[
1539 "orca.ax_object"
1540 ].AXObject.get_previous_sibling = mock_get_previous_sibling
1541 essential_modules["orca.ax_object"].AXObject.get_next_sibling = mock_get_next_sibling
1542 from orca.ax_utilities import AXUtilities
1543
1544 result = AXUtilities.get_set_members(mock_obj)
1545 assert len(result) == 3
1546 assert mock_obj in result
1547 assert mock_prev in result
1548 assert mock_next in result
1549
1550 def test_get_set_members_internal_with_menu_related(
1551 self,
1552 test_context: OrcaTestContext,
1553 ) -> None:
1554 """Test AXUtilities._get_set_members with menu-related objects."""
1555
1556 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1557 mock_menu1 = test_context.Mock(spec=Atspi.Accessible)
1558 mock_menu2 = test_context.Mock(spec=Atspi.Accessible)
1559 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1560 essential_modules[
1561 "orca.ax_utilities_relation"
1562 ].AXUtilitiesRelation.get_is_member_of = test_context.Mock(return_value=[])
1563 essential_modules[
1564 "orca.ax_utilities_relation"
1565 ].AXUtilitiesRelation.get_is_node_parent_of = test_context.Mock(return_value=[])
1566 essential_modules[
1567 "orca.ax_utilities_role"
1568 ].AXUtilitiesRole.is_description_value = test_context.Mock(return_value=False)
1569 essential_modules[
1570 "orca.ax_utilities_role"
1571 ].AXUtilitiesRole.is_menu_related = test_context.Mock(return_value=True)
1572 essential_modules["orca.ax_object"].AXObject.iter_children = test_context.Mock(
1573 return_value=[mock_menu1, mock_menu2],
1574 )
1575 from orca.ax_utilities import AXUtilities
1576
1577 result = AXUtilities.get_set_members(mock_obj)
1578 assert result == [mock_menu1, mock_menu2]
1579
1580 def test_get_set_members_internal_fallback_to_role(self, test_context: OrcaTestContext) -> None:
1581 """Test AXUtilities._get_set_members fallback to role-based matching."""
1582
1583 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1584 mock_same_role1 = test_context.Mock(spec=Atspi.Accessible)
1585 mock_same_role2 = test_context.Mock(spec=Atspi.Accessible)
1586 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1587 essential_modules[
1588 "orca.ax_utilities_relation"
1589 ].AXUtilitiesRelation.get_is_member_of = test_context.Mock(return_value=[])
1590 essential_modules[
1591 "orca.ax_utilities_relation"
1592 ].AXUtilitiesRelation.get_is_node_parent_of = test_context.Mock(return_value=[])
1593 essential_modules[
1594 "orca.ax_utilities_role"
1595 ].AXUtilitiesRole.is_description_value = test_context.Mock(return_value=False)
1596 essential_modules[
1597 "orca.ax_utilities_role"
1598 ].AXUtilitiesRole.is_menu_related = test_context.Mock(return_value=False)
1599 essential_modules["orca.ax_object"].AXObject.get_role = test_context.Mock(
1600 return_value=Atspi.Role.BUTTON,
1601 )
1602 essential_modules["orca.ax_object"].AXObject.iter_children = test_context.Mock(
1603 return_value=[mock_same_role1, mock_same_role2],
1604 )
1605 from orca.ax_utilities import AXUtilities
1606
1607 result = AXUtilities.get_set_members(mock_obj)
1608 assert result == [mock_same_role1, mock_same_role2]
1609
1610 @pytest.mark.parametrize(
1611 "case",
1612 [
1613 {
1614 "id": "showing_visible_on_screen",
1615 "is_showing": True,
1616 "is_visible": True,
1617 "is_hidden": False,
1618 "has_no_size_invalid_rect": False,
1619 "object_is_off_screen": False,
1620 "object_intersects_rect": True,
1621 "bbox_provided": False,
1622 "expected_result": True,
1623 },
1624 {
1625 "id": "hidden_object",
1626 "is_showing": False,
1627 "is_visible": False,
1628 "is_hidden": True,
1629 "has_no_size_invalid_rect": False,
1630 "object_is_off_screen": False,
1631 "object_intersects_rect": True,
1632 "bbox_provided": False,
1633 "expected_result": False,
1634 },
1635 {
1636 "id": "not_showing_but_visible",
1637 "is_showing": False,
1638 "is_visible": True,
1639 "is_hidden": False,
1640 "has_no_size_invalid_rect": False,
1641 "object_is_off_screen": False,
1642 "object_intersects_rect": True,
1643 "bbox_provided": False,
1644 "expected_result": False,
1645 },
1646 {
1647 "id": "showing_visible_but_hidden",
1648 "is_showing": True,
1649 "is_visible": True,
1650 "is_hidden": True,
1651 "has_no_size_invalid_rect": False,
1652 "object_is_off_screen": False,
1653 "object_intersects_rect": True,
1654 "bbox_provided": False,
1655 "expected_result": False,
1656 },
1657 {
1658 "id": "no_size_or_invalid_rect",
1659 "is_showing": True,
1660 "is_visible": True,
1661 "is_hidden": False,
1662 "has_no_size_invalid_rect": True,
1663 "object_is_off_screen": False,
1664 "object_intersects_rect": True,
1665 "bbox_provided": False,
1666 "expected_result": True,
1667 },
1668 {
1669 "id": "object_off_screen",
1670 "is_showing": True,
1671 "is_visible": True,
1672 "is_hidden": False,
1673 "has_no_size_invalid_rect": False,
1674 "object_is_off_screen": True,
1675 "object_intersects_rect": True,
1676 "bbox_provided": False,
1677 "expected_result": False,
1678 },
1679 {
1680 "id": "bbox_no_intersection",
1681 "is_showing": True,
1682 "is_visible": True,
1683 "is_hidden": False,
1684 "has_no_size_invalid_rect": False,
1685 "object_is_off_screen": False,
1686 "object_intersects_rect": False,
1687 "bbox_provided": True,
1688 "expected_result": False,
1689 },
1690 {
1691 "id": "fully_on_screen",
1692 "is_showing": True,
1693 "is_visible": True,
1694 "is_hidden": False,
1695 "has_no_size_invalid_rect": False,
1696 "object_is_off_screen": False,
1697 "object_intersects_rect": True,
1698 "bbox_provided": False,
1699 "expected_result": True,
1700 },
1701 ],
1702 ids=lambda case: case["id"],
1703 )
1704 def test_is_on_screen_scenarios( # pylint: disable=too-many-positional-arguments,too-many-locals
1705 self,
1706 test_context: OrcaTestContext,
1707 case: dict,
1708 ) -> None:
1709 """Test AXUtilities.is_on_screen with various state combinations."""
1710 is_showing = case["is_showing"]
1711 is_visible = case["is_visible"]
1712 is_hidden = case["is_hidden"]
1713 has_no_size_invalid_rect = case["has_no_size_invalid_rect"]
1714 object_is_off_screen = case["object_is_off_screen"]
1715 object_intersects_rect = case["object_intersects_rect"]
1716 bbox_provided = case["bbox_provided"]
1717 expected_result = case["expected_result"]
1718 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1719 mock_bbox = test_context.Mock(spec=Atspi.Rect) if bbox_provided else None
1720 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1721
1722 essential_modules[
1723 "orca.ax_utilities_state"
1724 ].AXUtilitiesState.is_showing = test_context.Mock(return_value=is_showing)
1725 essential_modules[
1726 "orca.ax_utilities_state"
1727 ].AXUtilitiesState.is_visible = test_context.Mock(return_value=is_visible)
1728 essential_modules["orca.ax_utilities_state"].AXUtilitiesState.is_hidden = test_context.Mock(
1729 return_value=is_hidden,
1730 )
1731
1732 essential_modules[
1733 "orca.ax_utilities_component"
1734 ].AXUtilitiesComponent.has_no_size_or_invalid_rect = test_context.Mock(
1735 return_value=has_no_size_invalid_rect,
1736 )
1737 essential_modules[
1738 "orca.ax_utilities_component"
1739 ].AXUtilitiesComponent.object_is_off_screen = test_context.Mock(
1740 return_value=object_is_off_screen,
1741 )
1742 essential_modules[
1743 "orca.ax_utilities_component"
1744 ].AXUtilitiesComponent.object_intersects_rect = test_context.Mock(
1745 return_value=object_intersects_rect,
1746 )
1747
1748 from orca.ax_utilities import AXUtilities
1749
1750 result = (
1751 AXUtilities.is_on_screen(mock_obj, mock_bbox)
1752 if bbox_provided
1753 else AXUtilities.is_on_screen(mock_obj)
1754 )
1755 assert result is expected_result
1756
1757 def test_has_visible_caption_with_visible_caption(self, test_context: OrcaTestContext) -> None:
1758 """Test AXUtilities.has_visible_caption with visible caption."""
1759
1760 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1761 mock_caption = test_context.Mock(spec=Atspi.Accessible)
1762 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1763 essential_modules["orca.ax_utilities_role"].AXUtilitiesRole.is_figure = test_context.Mock(
1764 return_value=True,
1765 )
1766 essential_modules["orca.ax_object"].AXObject.supports_table = test_context.Mock(
1767 return_value=False,
1768 )
1769 essential_modules[
1770 "orca.ax_utilities_relation"
1771 ].AXUtilitiesRelation.get_is_labelled_by = test_context.Mock(return_value=[mock_caption])
1772 essential_modules["orca.ax_utilities_role"].AXUtilitiesRole.is_caption = test_context.Mock(
1773 return_value=True,
1774 )
1775 essential_modules[
1776 "orca.ax_utilities_state"
1777 ].AXUtilitiesState.is_showing = test_context.Mock(return_value=True)
1778 essential_modules[
1779 "orca.ax_utilities_state"
1780 ].AXUtilitiesState.is_visible = test_context.Mock(return_value=True)
1781 from orca.ax_utilities import AXUtilities
1782
1783 result = AXUtilities.has_visible_caption(mock_obj)
1784 assert result is True
1785
1786 def test_has_visible_caption_not_figure_or_table(self, test_context: OrcaTestContext) -> None:
1787 """Test AXUtilities.has_visible_caption with object that's not figure or table."""
1788
1789 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1790 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1791 essential_modules["orca.ax_utilities_role"].AXUtilitiesRole.is_figure = test_context.Mock(
1792 return_value=False,
1793 )
1794 essential_modules["orca.ax_object"].AXObject.supports_table = test_context.Mock(
1795 return_value=False,
1796 )
1797 from orca.ax_utilities import AXUtilities
1798
1799 result = AXUtilities.has_visible_caption(mock_obj)
1800 assert result is False
1801
1802 def test_get_displayed_description_from_relations(self, test_context: OrcaTestContext) -> None:
1803 """Test AXUtilities.get_displayed_description returns description from relations."""
1804
1805 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1806 mock_desc = test_context.Mock(spec=Atspi.Accessible)
1807 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1808 essential_modules[
1809 "orca.ax_utilities_relation"
1810 ].AXUtilitiesRelation.get_is_described_by = test_context.Mock(return_value=[mock_desc])
1811 essential_modules["orca.ax_object"].AXObject.get_name = test_context.Mock(
1812 return_value="Test description",
1813 )
1814 essential_modules["orca.ax_text"].AXText.get_all_text = test_context.Mock(return_value="")
1815 from orca.ax_utilities import AXUtilities
1816
1817 result = AXUtilities.get_displayed_description(mock_obj)
1818 assert result == "Test description"
1819
1820 def test_get_displayed_description_empty(self, test_context: OrcaTestContext) -> None:
1821 """Test AXUtilities.get_displayed_description with empty description."""
1822
1823 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1824 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1825 essential_modules["orca.ax_object"].AXObject.get_description = test_context.Mock(
1826 return_value="",
1827 )
1828 from orca.ax_utilities import AXUtilities
1829
1830 result = AXUtilities.get_displayed_description(mock_obj)
1831 assert result == ""
1832
1833 def test_get_position_in_set_with_large_child_count(
1834 self,
1835 test_context: OrcaTestContext,
1836 ) -> None:
1837 """Test AXUtilities.get_position_in_set with large child count uses index_in_parent."""
1838
1839 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1840 mock_parent = test_context.Mock(spec=Atspi.Accessible)
1841 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1842 essential_modules[
1843 "orca.ax_utilities_role"
1844 ].AXUtilitiesRole.is_table_row = test_context.Mock(return_value=False)
1845 essential_modules[
1846 "orca.ax_utilities_role"
1847 ].AXUtilitiesRole.is_table_cell_or_header = test_context.Mock(return_value=False)
1848 essential_modules[
1849 "orca.ax_utilities_role"
1850 ].AXUtilitiesRole.is_combo_box = test_context.Mock(return_value=False)
1851 essential_modules["orca.ax_object"].AXObject.get_attribute = test_context.Mock(
1852 return_value=None,
1853 )
1854 essential_modules["orca.ax_object"].AXObject.get_parent = test_context.Mock(
1855 return_value=mock_parent,
1856 )
1857 essential_modules["orca.ax_object"].AXObject.get_child_count = test_context.Mock(
1858 return_value=1000,
1859 )
1860 essential_modules["orca.ax_object"].AXObject.get_index_in_parent = test_context.Mock(
1861 return_value=42,
1862 )
1863 from orca.ax_utilities import AXUtilities
1864
1865 result = AXUtilities.get_position_in_set(mock_obj)
1866 assert result == 42
1867
1868 def test_get_position_in_set_object_not_in_members(self, test_context: OrcaTestContext) -> None:
1869 """Test AXUtilities.get_position_in_set when object not in set members."""
1870
1871 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1872 mock_parent = test_context.Mock(spec=Atspi.Accessible)
1873 mock_other = test_context.Mock(spec=Atspi.Accessible)
1874 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1875 essential_modules[
1876 "orca.ax_utilities_role"
1877 ].AXUtilitiesRole.is_table_row = test_context.Mock(return_value=False)
1878 essential_modules[
1879 "orca.ax_utilities_role"
1880 ].AXUtilitiesRole.is_table_cell_or_header = test_context.Mock(return_value=False)
1881 essential_modules[
1882 "orca.ax_utilities_role"
1883 ].AXUtilitiesRole.is_combo_box = test_context.Mock(return_value=False)
1884 essential_modules["orca.ax_object"].AXObject.get_attribute = test_context.Mock(
1885 return_value=None,
1886 )
1887 essential_modules["orca.ax_object"].AXObject.get_parent = test_context.Mock(
1888 return_value=mock_parent,
1889 )
1890 essential_modules["orca.ax_object"].AXObject.get_child_count = test_context.Mock(
1891 return_value=10,
1892 )
1893 from orca.ax_utilities import AXUtilities
1894
1895 test_context.patch_object(
1896 AXUtilities,
1897 "get_set_members",
1898 side_effect=lambda x: [mock_other],
1899 )
1900 result = AXUtilities.get_position_in_set(mock_obj)
1901 assert result == -1
1902
1903 def test_treat_as_leaf_node_presentational_page_tab(
1904 self,
1905 test_context: OrcaTestContext,
1906 ) -> None:
1907 """Test AXUtilities.treat_as_leaf_node with presentational page tab."""
1908
1909 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1910 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1911 essential_modules[
1912 "orca.ax_utilities_role"
1913 ].AXUtilitiesRole.children_are_presentational = test_context.Mock(return_value=True)
1914 essential_modules["orca.ax_utilities_role"].AXUtilitiesRole.is_page_tab = test_context.Mock(
1915 return_value=True,
1916 )
1917 from orca.ax_utilities import AXUtilities
1918
1919 result = AXUtilities.treat_as_leaf_node(mock_obj)
1920 assert result is False
1921
1922 def test_treat_as_leaf_node_presentational_non_page_tab(
1923 self,
1924 test_context: OrcaTestContext,
1925 ) -> None:
1926 """Test AXUtilities.treat_as_leaf_node with presentational non-page-tab."""
1927
1928 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1929 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1930 essential_modules[
1931 "orca.ax_utilities_role"
1932 ].AXUtilitiesRole.children_are_presentational = test_context.Mock(return_value=True)
1933 essential_modules["orca.ax_utilities_role"].AXUtilitiesRole.is_page_tab = test_context.Mock(
1934 return_value=False,
1935 )
1936 from orca.ax_utilities import AXUtilities
1937
1938 result = AXUtilities.treat_as_leaf_node(mock_obj)
1939 assert result is True
1940
1941 def test_treat_as_leaf_node_combo_box_expanded(self, test_context: OrcaTestContext) -> None:
1942 """Test AXUtilities.treat_as_leaf_node with expanded combo box."""
1943
1944 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1945 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1946 essential_modules[
1947 "orca.ax_utilities_role"
1948 ].AXUtilitiesRole.children_are_presentational = test_context.Mock(return_value=False)
1949 essential_modules["orca.ax_object"].AXObject.get_role = test_context.Mock(
1950 return_value=Atspi.Role.COMBO_BOX,
1951 )
1952 essential_modules[
1953 "orca.ax_utilities_role"
1954 ].AXUtilitiesRole.is_combo_box = test_context.Mock(return_value=True)
1955 essential_modules[
1956 "orca.ax_utilities_state"
1957 ].AXUtilitiesState.is_expanded = test_context.Mock(return_value=True)
1958 from orca.ax_utilities import AXUtilities
1959
1960 result = AXUtilities.treat_as_leaf_node(mock_obj)
1961 assert result is False
1962
1963 def test_treat_as_leaf_node_menu_non_aria_expanded(self, test_context: OrcaTestContext) -> None:
1964 """Test AXUtilities.treat_as_leaf_node with expanded non-ARIA menu."""
1965
1966 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1967 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1968 essential_modules[
1969 "orca.ax_utilities_role"
1970 ].AXUtilitiesRole.children_are_presentational = test_context.Mock(return_value=False)
1971 essential_modules["orca.ax_object"].AXObject.get_role = test_context.Mock(
1972 return_value=Atspi.Role.MENU,
1973 )
1974 essential_modules[
1975 "orca.ax_utilities_role"
1976 ].AXUtilitiesRole.is_combo_box = test_context.Mock(return_value=False)
1977 essential_modules["orca.ax_utilities_role"].AXUtilitiesRole.is_menu = test_context.Mock(
1978 return_value=True,
1979 )
1980 essential_modules[
1981 "orca.ax_utilities_role"
1982 ].AXUtilitiesRole.has_role_from_aria = test_context.Mock(return_value=False)
1983 essential_modules[
1984 "orca.ax_utilities_state"
1985 ].AXUtilitiesState.is_expanded = test_context.Mock(return_value=True)
1986 from orca.ax_utilities import AXUtilities
1987
1988 result = AXUtilities.treat_as_leaf_node(mock_obj)
1989 assert result is False
1990
1991 def test_get_set_size_combo_box_with_selection(self, test_context: OrcaTestContext) -> None:
1992 """Test AXUtilities.get_set_size with combo box having selection."""
1993
1994 mock_obj = test_context.Mock(spec=Atspi.Accessible)
1995 mock_selected = test_context.Mock(spec=Atspi.Accessible)
1996 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
1997 essential_modules["orca.ax_object"].AXObject.get_attribute = test_context.Mock(
1998 return_value=None,
1999 )
2000 essential_modules[
2001 "orca.ax_utilities_role"
2002 ].AXUtilitiesRole.is_table_row = test_context.Mock(return_value=False)
2003 essential_modules[
2004 "orca.ax_utilities_role"
2005 ].AXUtilitiesRole.is_table_cell_or_header = test_context.Mock(return_value=False)
2006 essential_modules[
2007 "orca.ax_utilities_role"
2008 ].AXUtilitiesRole.is_combo_box = test_context.Mock(return_value=True)
2009 essential_modules[
2010 "orca.ax_utilities_selection"
2011 ].AXUtilitiesSelection.get_selected_children = test_context.Mock(
2012 return_value=[mock_selected],
2013 )
2014 from orca.ax_utilities import AXUtilities
2015
2016 test_context.patch_object(
2017 AXUtilities,
2018 "get_set_members",
2019 side_effect=lambda x: [test_context.Mock(), test_context.Mock(), test_context.Mock()],
2020 )
2021 result = AXUtilities.get_set_size(mock_obj)
2022 assert result == 3
2023
2024 def test_get_set_size_table_cell_not_in_row(self, test_context: OrcaTestContext) -> None:
2025 """Test AXUtilities.get_set_size with table cell not in table row."""
2026
2027 mock_obj = test_context.Mock(spec=Atspi.Accessible)
2028 mock_parent = test_context.Mock(spec=Atspi.Accessible)
2029 mock_table = test_context.Mock(spec=Atspi.Accessible)
2030 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
2031 essential_modules["orca.ax_object"].AXObject.get_attribute = test_context.Mock(
2032 return_value=None,
2033 )
2034 essential_modules[
2035 "orca.ax_utilities_role"
2036 ].AXUtilitiesRole.is_table_row = test_context.Mock(return_value=False)
2037 essential_modules[
2038 "orca.ax_utilities_role"
2039 ].AXUtilitiesRole.is_table_cell_or_header = test_context.Mock(return_value=True)
2040 essential_modules[
2041 "orca.ax_utilities_role"
2042 ].AXUtilitiesRole.is_combo_box = test_context.Mock(return_value=False)
2043 essential_modules["orca.ax_object"].AXObject.get_parent = test_context.Mock(
2044 return_value=mock_parent,
2045 )
2046 essential_modules["orca.ax_utilities_table"].AXUtilitiesTable.get_table = test_context.Mock(
2047 return_value=mock_table,
2048 )
2049 essential_modules["orca.ax_table"].AXTable.get_row_count = test_context.Mock(
2050 return_value=15,
2051 )
2052 from orca.ax_utilities import AXUtilities
2053
2054 result = AXUtilities.get_set_size(mock_obj)
2055 assert result == 15
2056
2057 def test_get_set_size_table_row_with_table(self, test_context: OrcaTestContext) -> None:
2058 """Test AXUtilities.get_set_size with table row."""
2059
2060 mock_obj = test_context.Mock(spec=Atspi.Accessible)
2061 mock_table = test_context.Mock(spec=Atspi.Accessible)
2062 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
2063 essential_modules["orca.ax_object"].AXObject.get_attribute = test_context.Mock(
2064 return_value=None,
2065 )
2066 essential_modules[
2067 "orca.ax_utilities_role"
2068 ].AXUtilitiesRole.is_table_row = test_context.Mock(return_value=True)
2069 essential_modules["orca.ax_utilities_table"].AXUtilitiesTable.get_table = test_context.Mock(
2070 return_value=mock_table,
2071 )
2072 essential_modules["orca.ax_table"].AXTable.get_row_count = test_context.Mock(
2073 return_value=20,
2074 )
2075 from orca.ax_utilities import AXUtilities
2076
2077 result = AXUtilities.get_set_size(mock_obj)
2078 assert result == 20
2079
2080 def test_get_set_size_fallback_to_set_members(self, test_context: OrcaTestContext) -> None:
2081 """Test AXUtilities.get_set_size fallback to set members count."""
2082
2083 mock_obj = test_context.Mock(spec=Atspi.Accessible)
2084 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
2085 essential_modules["orca.ax_object"].AXObject.get_attribute = test_context.Mock(
2086 return_value=None,
2087 )
2088 essential_modules[
2089 "orca.ax_utilities_role"
2090 ].AXUtilitiesRole.is_table_row = test_context.Mock(return_value=False)
2091 essential_modules[
2092 "orca.ax_utilities_role"
2093 ].AXUtilitiesRole.is_table_cell_or_header = test_context.Mock(return_value=False)
2094 essential_modules[
2095 "orca.ax_utilities_role"
2096 ].AXUtilitiesRole.is_combo_box = test_context.Mock(return_value=False)
2097 from orca.ax_utilities import AXUtilities
2098
2099 test_context.patch_object(
2100 AXUtilities,
2101 "get_set_members",
2102 side_effect=lambda x: [
2103 test_context.Mock(),
2104 test_context.Mock(),
2105 test_context.Mock(),
2106 test_context.Mock(),
2107 ],
2108 )
2109 result = AXUtilities.get_set_size(mock_obj)
2110 assert result == 4
2111
2112 def test_get_set_size_is_unknown_with_indeterminate_state(
2113 self,
2114 test_context: OrcaTestContext,
2115 ) -> None:
2116 """Test AXUtilities.get_set_size_is_unknown with indeterminate state."""
2117
2118 mock_obj = test_context.Mock(spec=Atspi.Accessible)
2119 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
2120 essential_modules[
2121 "orca.ax_utilities_state"
2122 ].AXUtilitiesState.is_indeterminate = test_context.Mock(return_value=True)
2123 from orca.ax_utilities import AXUtilities
2124
2125 result = AXUtilities.get_set_size_is_unknown(mock_obj)
2126 assert result is True
2127
2128 def test_get_set_size_is_unknown_table_with_negative_counts(
2129 self,
2130 test_context: OrcaTestContext,
2131 ) -> None:
2132 """Test AXUtilities.get_set_size_is_unknown with table having negative counts."""
2133
2134 mock_obj = test_context.Mock(spec=Atspi.Accessible)
2135 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
2136 essential_modules[
2137 "orca.ax_utilities_state"
2138 ].AXUtilitiesState.is_indeterminate = test_context.Mock(return_value=False)
2139 essential_modules["orca.ax_utilities_role"].AXUtilitiesRole.is_table = test_context.Mock(
2140 return_value=True,
2141 )
2142 essential_modules["orca.ax_object"].AXObject.get_attributes_dict = test_context.Mock(
2143 return_value={"rowcount": "-1", "colcount": "5"},
2144 )
2145 from orca.ax_utilities import AXUtilities
2146
2147 result = AXUtilities.get_set_size_is_unknown(mock_obj)
2148 assert result is True
2149
2150 def test_has_explicit_name_true_case(self, test_context: OrcaTestContext) -> None:
2151 """Test AXUtilities.has_explicit_name returns True when explicit-name attribute is true."""
2152
2153 mock_obj = test_context.Mock(spec=Atspi.Accessible)
2154 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
2155 essential_modules["orca.ax_object"].AXObject.get_attribute = test_context.Mock(
2156 return_value="true",
2157 )
2158 from orca.ax_utilities import AXUtilities
2159
2160 result = AXUtilities.has_explicit_name(mock_obj)
2161 assert result is True
2162
2163 def test_get_position_in_set_table_cell_with_coordinates(
2164 self,
2165 test_context: OrcaTestContext,
2166 ) -> None:
2167 """Test AXUtilities.get_position_in_set with table cell using coordinates."""
2168
2169 mock_obj = test_context.Mock(spec=Atspi.Accessible)
2170 mock_parent = test_context.Mock(spec=Atspi.Accessible)
2171 essential_modules: dict[str, MagicMock] = self._setup_dependencies(test_context)
2172 essential_modules[
2173 "orca.ax_utilities_role"
2174 ].AXUtilitiesRole.is_table_row = test_context.Mock(return_value=False)
2175 essential_modules[
2176 "orca.ax_utilities_role"
2177 ].AXUtilitiesRole.is_table_cell_or_header = test_context.Mock(return_value=True)
2178 essential_modules[
2179 "orca.ax_utilities_role"
2180 ].AXUtilitiesRole.is_combo_box = test_context.Mock(return_value=False)
2181 essential_modules["orca.ax_object"].AXObject.get_attribute = test_context.Mock(
2182 return_value=None,
2183 )
2184 essential_modules["orca.ax_object"].AXObject.get_parent = test_context.Mock(
2185 return_value=mock_parent,
2186 )
2187 essential_modules["orca.ax_table"].AXTable.get_cell_coordinates = test_context.Mock(
2188 return_value=(3, 2),
2189 )
2190 from orca.ax_utilities import AXUtilities
2191
2192 result = AXUtilities.get_position_in_set(mock_obj)
2193 assert result == 3