xa11y 0.7.0

//! Tree-structure, role coverage, element/state fields, selector queries,
//! and serialization integration tests.
//!
//! Read-only observations of the test app. Action dispatch and error paths
//! live in `integ::actions`; event subscription tests live in
//! `integ::events_<platform>`.

#[cfg(test)]
mod tests {
    use crate::integ as h;
    use xa11y::*;

    // ════════════════════════════════════════════════════════════════
    // Provider Operations (2 tests)
    // ════════════════════════════════════════════════════════════════

    #[test]
    #[ignore]
    fn check_permissions_granted() {
        // Permissions are checked automatically by App constructors.
        // If this fails with PermissionDenied, accessibility or screen
        // recording permissions are not granted.
        let _app = h::app_root();
    }

    #[test]
    #[ignore]
    fn apps_returns_nonempty() {
        let apps = App::list().unwrap();
        assert!(!apps.is_empty(), "should find at least one application");
        let has_test_app = apps.iter().any(|a| a.name.contains("xa11y"));
        assert!(
            has_test_app,
            "apps should include the test app. Apps: {:?}",
            apps.iter().map(|a| &a.name).collect::<Vec<_>>()
        );
    }

    // ════════════════════════════════════════════════════════════════
    // Tree Structure — Element Discovery (14 tests)
    // ════════════════════════════════════════════════════════════════

    #[test]
    #[ignore]
    fn tree_has_root_node() {
        let app = h::app_root();
        assert!(
            app.data.role == Role::Application || app.data.role == Role::Window,
            "Root role: {:?}",
            app.data.role
        );
    }

    #[test]
    #[ignore]
    fn tree_has_window() {
        let app = h::app_root();
        // On Windows (UIA), the app root IS the window — there's no nested
        // Window child element. Verify root is a Window or find child windows.
        if app.data.role == Role::Window {
            return; // App root is the window — pass
        }
        let windows = app.locator("window").elements().unwrap();
        assert!(!windows.is_empty(), "No windows found. App: {}", app);
    }

    #[test]
    #[ignore]
    fn tree_has_buttons() {
        let app = h::app_root();
        let buttons = app.locator("button").elements().unwrap();
        assert!(
            buttons.len() >= 2,
            "Expected >=2 buttons, found {}. App: {}",
            buttons.len(),
            app
        );
    }

    #[test]
    #[ignore]
    fn tree_has_submit_button() {
        let app = h::app_root();
        let submit = h::named(&app, "Submit");
        assert_eq!(submit.role, Role::Button);
    }

    #[test]
    #[ignore]
    fn tree_has_cancel_button_disabled() {
        let app = h::app_root();
        let cancel = h::named(&app, "Cancel");
        // Cancel may have been enabled by a prior toggle test; just verify it exists as a button
        assert_eq!(cancel.role, Role::Button);
        // Check that the enabled state is a valid boolean (not that it's a specific value)
        let _ = cancel.states.enabled;
    }

    #[test]
    #[ignore]
    fn tree_has_checkbox_unchecked() {
        let app = h::app_root();
        let cb = h::named(&app, "I agree to terms");
        assert_eq!(cb.role, Role::CheckBox);
        // Checkbox may have been toggled by prior tests; just verify it has a checked state
        assert!(
            cb.states.checked.is_some(),
            "Checkbox should have checked state"
        );
    }

    #[test]
    #[ignore]
    fn tree_has_text_entry_with_value() {
        let app = h::app_root();
        // Prior action tests (TypeText, SetValue) may have changed or cleared the value.
        // Just verify a text field exists (by role + name), value may or may not be present.
        let text_elements = app
            .locator(r#"[role="text_field"]"#)
            .elements()
            .unwrap_or_default();
        let textarea_elements = app
            .locator(r#"[role="text_area"]"#)
            .elements()
            .unwrap_or_default();
        let has_text = text_elements
            .iter()
            .chain(textarea_elements.iter())
            .any(|n| n.value.is_some() || n.name.as_deref() == Some("Name"));
        assert!(has_text, "Text entry not found. App: {}", app);
    }

    #[test]
    #[ignore]
    fn tree_has_welcome_label() {
        let app = h::app_root();
        // On Linux/AT-SPI with AccessKit, Label nodes may not expose their text
        // through the Name property or Text interface. Look for the node by name
        // first, then fall back to checking that StaticText nodes exist.
        let welcome = app.locator(r#"[name*="Welcome"]"#).elements().unwrap();
        if welcome.is_empty() {
            // Fall back: verify that static text nodes exist (labels are present even if unnamed)
            let labels = app.locator("static_text").elements().unwrap();
            assert!(
                !labels.is_empty(),
                "No StaticText/label nodes found. App: {}",
                app
            );
        } else {
            assert!(
                welcome[0].role == Role::StaticText || welcome[0].role == Role::Group,
                "Welcome node role: {:?}",
                welcome[0].role
            );
        }
    }

    #[test]
    #[ignore]
    fn tree_has_slider_at_50() {
        let app = h::app_root();
        let sliders = app.locator("slider").elements().unwrap();
        assert!(!sliders.is_empty(), "No sliders found. App: {}", app);
        // Slider value may have been changed by prior tests; just verify it has a numeric value
        assert!(sliders[0].value.is_some(), "Slider should have a value");
        let val: f64 = sliders[0].value.as_deref().unwrap().parse().unwrap_or(0.0);
        assert!(
            (0.0..=100.0).contains(&val),
            "Slider value should be in [0,100], got {}",
            val
        );
    }

    #[test]
    #[ignore]
    fn tree_has_progress_bar() {
        let app = h::app_root();
        let progress = app.locator("progress_bar").elements().unwrap();
        assert!(!progress.is_empty(), "No progress bars found. App: {}", app);
    }

    #[test]
    #[ignore]
    fn tree_has_radio_buttons() {
        let app = h::app_root();
        let radios = app.locator("radio_button").elements().unwrap();
        assert!(
            radios.len() >= 2,
            "Expected >=2 radio buttons, found {}. App: {}",
            radios.len(),
            app
        );
    }

    #[test]
    #[ignore]
    fn tree_has_combo_box() {
        let app = h::app_root();
        let combos = app.locator("combo_box").elements().unwrap();
        assert!(!combos.is_empty(), "ComboBox not found. App: {}", app);
    }

    #[test]
    #[ignore]
    fn tree_has_list_with_items() {
        let app = h::app_root();
        let lists = app.locator("list").elements().unwrap();
        let items = app.locator("list_item").elements().unwrap();
        assert!(
            !lists.is_empty() || !items.is_empty(),
            "Neither List nor ListItem found. App: {}",
            app
        );
    }

    #[test]
    #[ignore]
    fn tree_has_table_with_cells() {
        let app = h::app_root();
        let tables = app.locator("table").elements().unwrap();
        let cells = app.locator("table_cell").elements().unwrap();
        assert!(
            !tables.is_empty() || !cells.is_empty(),
            "Neither Table nor TableCell found. App: {}",
            app
        );
    }

    // ════════════════════════════════════════════════════════════════
    // Role Coverage (14 tests)
    // ════════════════════════════════════════════════════════════════

    #[test]
    #[ignore]
    fn role_menu_bar() {
        let app = h::app_root();
        let nodes = app.locator("menu_bar").elements().unwrap();
        assert!(!nodes.is_empty(), "MenuBar not found. App: {}", app);
    }

    #[test]
    #[ignore]
    fn role_menu_item() {
        let app = h::app_root();
        let nodes = app.locator("menu_item").elements().unwrap();
        assert!(!nodes.is_empty(), "MenuItem not found. App: {}", app);
        let has_file = nodes.iter().any(|n| n.name.as_deref() == Some("File"));
        assert!(has_file, "File menu item not found");
    }

    #[test]
    #[ignore]
    fn role_toolbar() {
        let app = h::app_root();
        let nodes = app.locator("toolbar").elements().unwrap();
        assert!(!nodes.is_empty(), "Toolbar not found. App: {}", app);
    }

    #[test]
    #[ignore]
    fn role_tab_and_tab_group() {
        let app = h::app_root();
        let tab_groups = app.locator("tab_group").elements().unwrap();
        let tabs = app.locator("tab").elements().unwrap();
        assert!(
            !tab_groups.is_empty() || !tabs.is_empty(),
            "Neither TabGroup nor Tab found. App: {}",
            app
        );
    }

    #[test]
    #[ignore]
    fn role_separator() {
        let app = h::app_root();
        let seps = app.locator("separator").elements().unwrap();
        assert!(!seps.is_empty(), "Separator not found. App: {}", app);
    }

    #[test]
    #[ignore]
    fn role_image() {
        let app = h::app_root();
        let images = app.locator("image").elements().unwrap();
        assert!(!images.is_empty(), "Image not found. App: {}", app);
    }

    #[test]
    #[ignore]
    fn role_link() {
        let app = h::app_root();
        let links = app.locator("link").elements().unwrap();
        assert!(!links.is_empty(), "Link not found. App: {}", app);
    }

    #[test]
    #[ignore]
    fn role_tree_item() {
        let app = h::app_root();
        let items = app.locator("tree_item").elements().unwrap();
        assert!(!items.is_empty(), "TreeItem not found. App: {}", app);
    }

    #[test]
    #[ignore]
    fn role_dialog() {
        let app = h::app_root();
        let dialogs = app.locator("dialog").elements().unwrap();
        assert!(!dialogs.is_empty(), "Dialog not found. App: {}", app);
    }

    #[test]
    #[ignore]
    fn role_alert() {
        let app = h::app_root();
        let alerts = app.locator("alert").elements().unwrap();
        assert!(!alerts.is_empty(), "Alert not found. App: {}", app);
    }

    #[test]
    #[ignore]
    fn role_heading() {
        let app = h::app_root();
        let headings = app.locator("heading").elements().unwrap();
        assert!(!headings.is_empty(), "Heading not found. App: {}", app);
    }

    #[test]
    #[ignore]
    fn role_scroll_bar() {
        let app = h::app_root();
        let scrollbars = app.locator("scroll_bar").elements().unwrap();
        assert!(!scrollbars.is_empty(), "ScrollBar not found. App: {}", app);
    }

    #[test]
    #[ignore]
    fn role_split_group() {
        let app = h::app_root();
        // SplitGroup may map through AT-SPI as Group due to accesskit's Pane role
        let node = app.locator(r#"[name*="SplitGroup"]"#).elements().unwrap();
        assert!(!node.is_empty(), "SplitGroup node not found. App: {}", app);
    }

    #[test]
    #[ignore]
    fn role_static_text() {
        let app = h::app_root();
        let labels = app.locator("static_text").elements().unwrap();
        assert!(!labels.is_empty(), "StaticText not found. App: {}", app);
    }

    // ════════════════════════════════════════════════════════════════
    // Tree Methods (5 tests)
    // ════════════════════════════════════════════════════════════════

    #[test]
    #[ignore]
    fn tree_children_of_root() {
        let app = h::app_root();
        let children = app.children().unwrap();
        assert!(!children.is_empty(), "Root should have children");
        // Verify grandchildren have parents (direct children of app root
        // may report None parent on AT-SPI where the parent is the registry root).
        if !children.is_empty() {
            let grandchildren = children[0].children().unwrap();
            for gc in &grandchildren {
                let parent = gc.parent().unwrap();
                assert!(parent.is_some(), "Grandchild should have parent");
            }
        }
    }

    #[test]
    #[ignore]
    fn tree_children_of_leaf() {
        let app = h::app_root();
        // Find a leaf node (e.g. a static text or button that has no children)
        let buttons = app.locator("button").elements().unwrap();
        for btn in &buttons {
            let children = btn.children().unwrap();
            if children.is_empty() {
                // Found a leaf — verify children returns empty vec, not error
                assert!(btn.children().unwrap().is_empty());
                return;
            }
        }
        // If all buttons have children, that's fine too — just verify children() works
    }

    #[test]
    #[ignore]
    fn tree_is_not_empty() {
        let app = h::app_root();
        let children = app.children().unwrap();
        assert!(!children.is_empty(), "Root should have at least one child");
    }

    #[test]
    #[ignore]
    fn tree_display_readable() {
        let app = h::app_root();
        let display = app.to_string();
        assert!(!display.is_empty());
        // Display should include the app name
        assert!(
            display.contains(&app.name),
            "Display should include app name: {}",
            display
        );
    }

    #[test]
    #[ignore]
    fn tree_locator_finds_elements() {
        let app = h::app_root();
        let buttons = app.locator("button").elements().unwrap();
        assert!(buttons.len() >= 2, "Expected >=2 buttons via locator");
        let count = app.locator("button").count().unwrap();
        assert_eq!(count, buttons.len());
    }

    // ════════════════════════════════════════════════════════════════
    // Element Fields (7 tests)
    // ════════════════════════════════════════════════════════════════

    #[test]
    #[ignore]
    fn element_description_on_image() {
        let app = h::app_root();
        let images = app.locator("image").elements().unwrap();
        if !images.is_empty() {
            let img = images.iter().find(|n| {
                n.name.as_deref() == Some("Info Icon")
                    || n.description.as_deref() == Some("An informational icon")
            });
            if let Some(img) = img {
                assert!(img.description.is_some(), "Image should have description");
                assert_eq!(img.description.as_deref(), Some("An informational icon"));
            }
        }
    }

    #[test]
    #[ignore]
    fn element_bounds_present() {
        let app = h::app_root();
        let submit = h::named(&app, "Submit");
        assert!(submit.bounds.is_some(), "Submit should have bounds");
        let b = submit.bounds.unwrap();
        assert!(b.width > 0, "width > 0");
        assert!(b.height > 0, "height > 0");
    }

    /// Nodes without the Component interface (e.g. Application root) should
    /// have `bounds: None` without triggering GTK CRITICAL warnings.
    #[test]
    #[ignore]
    fn element_bounds_none_for_non_component_elements() {
        let app = h::app_root();
        // On Linux/macOS, Application elements don't implement Component so
        // bounds is None. On Windows (UIA), the app root is a Window element
        // that does have bounds.
        #[cfg(not(target_os = "windows"))]
        assert!(
            app.data.bounds.is_none(),
            "Application root should not have bounds (no Component interface)"
        );
        // But a visible widget like a button should still have bounds
        let submit = h::named(&app, "Submit");
        assert!(submit.bounds.is_some(), "Submit button should have bounds");
    }

    #[test]
    #[ignore]
    fn element_actions_list_on_button() {
        let app = h::app_root();
        let submit = h::named(&app, "Submit");
        assert!(!submit.actions.is_empty());
        assert!(
            submit.actions.iter().any(|a| a == "press"),
            "Submit should support press, got: {:?}",
            submit.actions
        );
    }

    #[test]
    #[ignore]
    fn element_children_ids_valid() {
        let app = h::app_root();
        let children = app.children().unwrap();
        assert!(!children.is_empty());
        for child in &children {
            // Verify child is a valid element (role may be Unknown for unrecognized elements)
            let _ = child.role;
        }
    }

    #[test]
    #[ignore]
    fn element_parent_field() {
        let app = h::app_root();
        // Direct children of app root may report parent as None on some platforms
        // (AT-SPI maps parent to registry root which we treat as None).
        // Test parent on a deeper element instead.
        let children = app.children().unwrap();
        if !children.is_empty() {
            let grandchildren = children[0].children().unwrap();
            if !grandchildren.is_empty() {
                let parent = grandchildren[0].parent().unwrap();
                assert!(parent.is_some(), "Grandchild should have parent");
            }
        }
    }

    #[test]
    #[ignore]
    fn element_handle_nonzero() {
        let app = h::app_root();
        // The opaque handle should be non-zero for a valid element
        assert!(app.data.handle != 0, "Root handle should be nonzero");
    }

    // ════════════════════════════════════════════════════════════════
    // StateSet Fields (9 tests)
    // ════════════════════════════════════════════════════════════════

    #[test]
    #[ignore]
    fn state_enabled_default() {
        let app = h::app_root();
        let submit = h::named(&app, "Submit");
        assert!(submit.states.enabled, "Submit should be enabled");
    }

    #[test]
    #[ignore]
    fn state_disabled_on_cancel() {
        let app = h::app_root();
        let cancel = h::named(&app, "Cancel");
        // Some AT-SPI adapters (AccessKit) may not expose disabled state properly;
        // in that case, the toggle test (action_toggle_enables_cancel) verifies
        // the enabled state can change. Here we just verify the node exists and
        // has a valid enabled state.
        #[cfg(not(target_os = "linux"))]
        assert!(!cancel.states.enabled, "Cancel should be disabled");
        #[cfg(target_os = "linux")]
        {
            // On Linux with AccessKit, disabled state may not be reflected.
            // Just verify the Cancel button exists as a button.
            assert_eq!(cancel.role, Role::Button);
            let _ = cancel.states.enabled; // valid boolean either way
        }
    }

    #[test]
    #[ignore]
    fn state_visible_on_shown_widget() {
        let app = h::app_root();
        let submit = h::named(&app, "Submit");
        assert!(submit.states.visible, "Submit should be visible");
    }

    #[test]
    #[ignore]
    fn state_focused_after_focus_action() {
        let app = h::app_root();
        let submit = h::named(&app, "Submit");
        // Focus action may succeed or fail depending on AT-SPI adapter support
        let result = h::try_act(&submit, "focus");
        if result.is_ok() {
            std::thread::sleep(std::time::Duration::from_millis(100));
            let app2 = h::app_root();
            let submit2 = h::named(&app2, "Submit");
            // Some adapters may not reflect focused state change
            if !submit2.states.focused {
                println!("Focus action succeeded but focused state not reflected (AT-SPI adapter limitation)");
            }
        } else {
            println!("Focus action not supported: {:?}", result.err());
        }
    }

    #[test]
    #[ignore]
    fn state_checked_off_on_checkbox() {
        let app = h::app_root();
        let cb = h::named(&app, "I agree to terms");
        assert_eq!(cb.states.checked, Some(Toggled::Off));
    }

    #[test]
    #[ignore]
    fn state_checked_on_radio() {
        let app = h::app_root();
        let radios = app.locator("radio_button").elements().unwrap();
        let opt_a = radios
            .iter()
            .find(|n| n.name.as_deref() == Some("Option A"));
        assert!(opt_a.is_some());
        assert_eq!(opt_a.unwrap().states.checked, Some(Toggled::On));
    }

    #[test]
    #[ignore]
    fn state_expanded_collapsed_on_expander() {
        let app = h::app_root();
        // Look for expandable elements by name
        let expander_by_name = app.locator(r#"[name*="Expander"]"#).elements().unwrap();
        // On macOS, GenericContainer with expanded state may not expose AXExpanded.
        // The expand/collapse actions still work (tested by action_expand_collapse).
        if expander_by_name.is_empty() {
            // Verify expand/collapse actions work even if state isn't reported
            println!(
                "No expandable elements found by name. \
                 Expand/collapse actions tested separately."
            );
        }
    }

    #[test]
    #[ignore]
    fn state_editable_on_text_field() {
        let app = h::app_root();
        // Prior action tests (TypeText, SetValue) may have changed or cleared the value.
        // Find text field by name.
        let text_fields = app.locator(r#"[name="Name"]"#).elements().unwrap();
        if text_fields.is_empty() {
            // Fall back to finding any text field
            let fields = app.locator("text_field").elements().unwrap();
            let areas = app.locator("text_area").elements().unwrap();
            let all_text: Vec<&Element> = fields.iter().chain(areas.iter()).collect();
            assert!(!all_text.is_empty(), "Text entry not found. App: {}", app);
            assert!(all_text[0].states.editable, "Text entry should be editable");
        } else {
            assert!(
                text_fields[0].states.editable,
                "Text entry should be editable"
            );
        }
    }

    #[test]
    #[ignore]
    fn state_selected_on_list_item() {
        let app = h::app_root();
        // Click Apple to select it
        let apple = h::named(&app, "Apple");
        let app2 = h::act(&apple, "press");
        // Verify selection (may come through as Click -> Select depending on AT-SPI mapping)
        let apple2 = h::named(&app2, "Apple");
        // Selection might be reported differently; at least verify the action didn't crash
        println!(
            "Apple selected state after Click: {:?}",
            apple2.states.selected
        );
    }

    // ════════════════════════════════════════════════════════════════
    // Selector Queries (12 tests)
    // ════════════════════════════════════════════════════════════════

    #[test]
    #[ignore]
    fn sel_by_role() {
        let app = h::app_root();
        let buttons = app.locator("button").elements().unwrap();
        assert!(buttons.len() >= 2);
        for b in &buttons {
            assert_eq!(b.role, Role::Button);
        }
    }

    #[test]
    #[ignore]
    fn sel_by_exact_name() {
        let app = h::app_root();
        let submit = h::one(&app, r#"button[name="Submit"]"#);
        assert_eq!(submit.role, Role::Button);
    }

    #[test]
    #[ignore]
    fn sel_by_role_and_name() {
        let app = h::app_root();
        let results = app.locator(r#"button[name="Cancel"]"#).elements().unwrap();
        assert_eq!(results.len(), 1);
    }

    #[test]
    #[ignore]
    fn sel_name_contains() {
        let app = h::app_root();
        let results = app.locator(r#"[name*="agree"]"#).elements().unwrap();
        assert!(
            !results.is_empty(),
            "Should find element with 'agree' in name"
        );
    }

    #[test]
    #[ignore]
    fn sel_name_starts_with() {
        let app = h::app_root();
        // Try "Welc" first (Welcome label), fall back to "Sub" (Submit button)
        let results = app.locator(r#"[name^="Welc"]"#).elements().unwrap();
        if results.is_empty() {
            // Welcome label may not be named on some AT-SPI adapters; use Submit instead
            let results = app.locator(r#"[name^="Sub"]"#).elements().unwrap();
            assert!(!results.is_empty());
            assert!(results[0]
                .name
                .as_deref()
                .unwrap()
                .to_lowercase()
                .starts_with("sub"));
        } else {
            assert!(results[0]
                .name
                .as_deref()
                .unwrap()
                .to_lowercase()
                .starts_with("welc"));
        }
    }

    #[test]
    #[ignore]
    fn sel_name_ends_with() {
        let app = h::app_root();
        // "xa11y" suffix may be in the window title or app name
        let results = app.locator(r#"[name$="xa11y"]"#).elements().unwrap();
        if results.is_empty() {
            // Fall back to known name suffixes
            let results = app.locator(r#"[name$="App"]"#).elements().unwrap();
            if results.is_empty() {
                // On Windows, names may differ. Try "Submit" suffix.
                let results = app.locator(r#"[name$="Submit"]"#).elements().unwrap();
                assert!(
                    !results.is_empty(),
                    "Should find at least one element with name ending in 'Submit'"
                );
            }
        }
    }

    #[test]
    #[ignore]
    fn sel_value_attribute() {
        let app = h::app_root();
        // Try "Red" (ComboBox value), then fall back to any value attribute match.
        let results = app.locator(r#"[value*="Red"]"#).elements().unwrap();
        if results.is_empty() {
            // ComboBox value may not be exposed on some AT-SPI adapters.
            // Try matching against progress bar value "0.75"
            let results = app.locator(r#"[value*="0.75"]"#).elements().unwrap();
            assert!(
                !results.is_empty(),
                "Should find element with value containing '0.75' (ProgressBar)"
            );
        }
    }

    #[test]
    #[ignore]
    fn sel_descendant_combinator() {
        let app = h::app_root();
        // On Windows (UIA), the app root IS the window, so "window button"
        // won't find anything within the app's tree. Use "group button" which
        // works on all platforms (buttons are inside group containers).
        let results = app.locator("group button").elements().unwrap();
        if results.is_empty() {
            // Fall back to "window button" for Linux/macOS
            let results = app.locator("window button").elements().unwrap();
            assert!(!results.is_empty());
            for r in &results {
                assert_eq!(r.role, Role::Button);
            }
        } else {
            for r in &results {
                assert_eq!(r.role, Role::Button);
            }
        }
    }

    #[test]
    #[ignore]
    fn sel_child_combinator() {
        let app = h::app_root();
        let results = app.locator("application > window").elements().unwrap();
        // May or may not match depending on tree structure, but should not error
        for r in &results {
            assert_eq!(r.role, Role::Window);
        }
    }

    #[test]
    #[ignore]
    fn sel_nth_pseudo() {
        let app = h::app_root();
        let first = app.locator("button:nth(1)").elements().unwrap();
        assert_eq!(first.len(), 1);
    }

    #[test]
    #[ignore]
    fn sel_role_attribute() {
        let app = h::app_root();
        let results = app.locator(r#"[role="button"]"#).elements().unwrap();
        assert!(!results.is_empty());
        for r in &results {
            assert_eq!(r.role, Role::Button);
        }
    }

    #[test]
    #[ignore]
    fn sel_complex_chain() {
        let app = h::app_root();
        // Multi-segment selector: role + name attribute chain.
        // On Windows (UIA), the app root is the window and AccessKit containers
        // may flatten, so "window button" or "group button" may not work.
        // Use "menu_bar menu_item" which is nested on all platforms.
        let results = app
            .locator(r#"menu_bar menu_item[name="File"]"#)
            .elements()
            .unwrap();
        assert!(!results.is_empty(), "Should find File menu item via chain");
        assert_eq!(results[0].role, Role::MenuItem);
        assert_eq!(results[0].name.as_deref(), Some("File"));
    }

    #[test]
    #[ignore]
    fn raw_data_always_present() {
        let _app = h::app_root();
        #[cfg(target_os = "linux")]
        {
            let atspi_role = _app
                .data
                .raw
                .get("atspi_role")
                .and_then(|v| v.as_str())
                .expect("Expected atspi_role in raw data");
            assert!(!atspi_role.is_empty());
        }
        #[cfg(target_os = "macos")]
        {
            let ax_role = _app
                .data
                .raw
                .get("ax_role")
                .and_then(|v| v.as_str())
                .expect("Expected ax_role in raw data");
            assert!(!ax_role.is_empty());
        }
        #[cfg(target_os = "windows")]
        {
            let control_type_id = _app
                .data
                .raw
                .get("control_type_id")
                .and_then(|v| v.as_i64())
                .expect("Expected control_type_id in raw data");
            assert!(control_type_id > 0);
        }
    }

    // ════════════════════════════════════════════════════════════════
    // Serialization (1 test)
    // ════════════════════════════════════════════════════════════════

    #[test]
    #[ignore]
    fn json_roundtrip_real_element() {
        let app = h::app_root();
        // Serialize the root ElementData
        let json = serde_json::to_string(&app.data).unwrap();
        let deser: ElementData = serde_json::from_str(&json).unwrap();
        assert_eq!(deser.role, app.data.role);
        assert_eq!(deser.name, app.data.name);
    }
}