use super::*;use crate::{    display_map::{DisplayMap, FoldMap, InlayMap},    test::editor_test_context::EditorTestContext,};use gpui::{Context, TestAppContext};use language::{Language, LanguageConfig, LanguageMatcher, LanguageRegistry};use multi_buffer::MultiBuffer;use project::Project;use std::sync::Arc; #[gpui::test]async fn test_markdown_link_folding(cx: &mut TestAppContext) {    init_test(cx);     let mut cx = EditorTestContext::new(cx).await;     // Set up markdown language with folding query    cx.update_buffer(|buffer, cx| {        let registry = LanguageRegistry::test(cx.background_executor().clone());        let markdown = Arc::new(Language::new(            LanguageConfig {                name: "Markdown".into(),                matcher: LanguageMatcher {                    path_suffixes: vec!["md".to_string()],                    ..Default::default()                },                ..Default::default()            },            None,        ));         registry.add(markdown.clone());        buffer.set_language_registry(registry);        buffer.set_language(Some(markdown), cx);    });     // Add markdown content with links    cx.set_state(indoc! {"        # Channel Notes         Check out [our website](https://example.com) for more info.         Here's a [link to docs](https://docs.example.com/guide) that you should read.         And another [reference](https://reference.example.com).    "});     cx.update_editor(|editor, cx| {        // Enable syntax folding        let display_map = editor.display_map.update(cx, |map, cx| {            map.syntax_fold_config = SyntaxFoldConfig {                enabled: true,                auto_fold_on_open: true,                proximity_expand_distance: 2,            };            map.detect_syntax_folds(cx);        });         // Verify folds were created for each link        let snapshot = editor.snapshot(cx);        let fold_count = snapshot.fold_count();        assert_eq!(fold_count, 3, "Should have 3 folds for 3 links");    });} #[gpui::test]async fn test_link_proximity_expansion(cx: &mut TestAppContext) {    init_test(cx);     let mut cx = EditorTestContext::new(cx).await;     // Set up markdown with a single link    cx.set_state(indoc! {"        Check out [this link](https://example.com) for details.    "});     cx.update_editor(|editor, cx| {        // Enable syntax folding with proximity expansion        editor.display_map.update(cx, |map, cx| {            map.syntax_fold_config = SyntaxFoldConfig {                enabled: true,                auto_fold_on_open: true,                proximity_expand_distance: 3,            };            map.detect_syntax_folds(cx);        });    });     // Move cursor near the link    cx.set_selections_state(indoc! {"        Check out |[this link](https://example.com) for details.    "});     cx.update_editor(|editor, cx| {        let display_map = editor.display_map.update(cx, |map, cx| {            // Simulate cursor movement handling            let cursor_offset = editor.selections.newest::<usize>(cx).head();            map.handle_cursor_movement(cursor_offset, cx);        });         // Verify link is expanded due to proximity        let snapshot = editor.snapshot(cx);        let expanded_count = snapshot.expanded_fold_count();        assert_eq!(            expanded_count, 1,            "Link should be expanded when cursor is near"        );    });     // Move cursor away from the link    cx.set_selections_state(indoc! {"        Check out [this link](https://example.com) for details.|    "});     cx.update_editor(|editor, cx| {        let display_map = editor.display_map.update(cx, |map, cx| {            let cursor_offset = editor.selections.newest::<usize>(cx).head();            map.handle_cursor_movement(cursor_offset, cx);        });         // Verify link is folded again        let snapshot = editor.snapshot(cx);        let expanded_count = snapshot.expanded_fold_count();        assert_eq!(            expanded_count, 0,            "Link should be folded when cursor moves away"        );    });} #[gpui::test]async fn test_link_click_action(cx: &mut TestAppContext) {    init_test(cx);     let mut cx = EditorTestContext::new(cx).await;     cx.set_state(indoc! {"        Visit [GitHub](https://github.com) for code.    "});     cx.update_editor(|editor, cx| {        editor.display_map.update(cx, |map, cx| {            map.syntax_fold_config = SyntaxFoldConfig {                enabled: true,                auto_fold_on_open: true,                proximity_expand_distance: 2,            };            map.detect_syntax_folds(cx);        });    });     // Simulate clicking on the folded link    cx.update_editor(|editor, cx| {        let point = editor.pixel_position_of_cursor(cx);         // Find fold at click position        let display_map = editor.display_map.read(cx);        let snapshot = display_map.snapshot(cx);        let click_offset = snapshot.display_point_to_offset(point, cx);         if let Some(fold) = display_map.syntax_fold_at_offset(click_offset) {            // Verify the fold has the correct URL action            assert!(matches!(                fold.action_data,                Some(FoldAction::OpenUrl(ref url)) if url == "https://github.com"            ));             // Execute the action (in tests, this would be mocked)            display_map.execute_fold_action(&fold, cx);        } else {            panic!("No fold found at click position");        }    });} #[gpui::test]async fn test_nested_markdown_structures(cx: &mut TestAppContext) {    init_test(cx);     let mut cx = EditorTestContext::new(cx).await;     // Test with nested brackets and complex markdown    cx.set_state(indoc! {"        # Documentation         See [the [nested] guide](https://example.com/guide) for details.         ![Image description](https://example.com/image.png)         Code: `[not a link](just code)`         > Quote with [link in quote](https://quoted.com)    "});     cx.update_editor(|editor, cx| {        editor.display_map.update(cx, |map, cx| {            map.syntax_fold_config = SyntaxFoldConfig {                enabled: true,                auto_fold_on_open: true,                proximity_expand_distance: 2,            };            map.detect_syntax_folds(cx);        });         // Verify correct number of folds (should not fold code block content)        let snapshot = editor.snapshot(cx);        let fold_count = snapshot.fold_count();        assert_eq!(            fold_count, 3,            "Should have 3 folds: nested link, image, and quote link"        );    });} #[gpui::test]async fn test_fold_persistence_across_edits(cx: &mut TestAppContext) {    init_test(cx);     let mut cx = EditorTestContext::new(cx).await;     cx.set_state(indoc! {"        First [link one](https://one.com) here.        Second [link two](https://two.com) here.    "});     cx.update_editor(|editor, cx| {        editor.display_map.update(cx, |map, cx| {            map.syntax_fold_config = SyntaxFoldConfig {                enabled: true,                auto_fold_on_open: true,                proximity_expand_distance: 2,            };            map.detect_syntax_folds(cx);        });    });     // Edit text between links    cx.set_selections_state(indoc! {"        First [link one](https://one.com) here|.        Second [link two](https://two.com) here.    "});     cx.simulate_keystroke(" and more text");     cx.update_editor(|editor, cx| {        // Verify folds are maintained after edit        let snapshot = editor.snapshot(cx);        let fold_count = snapshot.fold_count();        assert_eq!(fold_count, 2, "Both folds should persist after edit");    });     // Add a new link    cx.simulate_keystroke("\nThird [link three](https://three.com) added.");     cx.update_editor(|editor, cx| {        // Verify new fold is detected        let snapshot = editor.snapshot(cx);        let fold_count = snapshot.fold_count();        assert_eq!(fold_count, 3, "New fold should be detected for added link");    });} #[gpui::test]async fn test_channel_notes_integration(cx: &mut TestAppContext) {    init_test(cx);     let mut cx = EditorTestContext::new(cx).await;     // Simulate channel notes content with many links    cx.set_state(indoc! {"        # Project Resources         ## Documentation        - [API Reference](https://api.example.com/docs)        - [User Guide](https://guide.example.com)        - [Developer Handbook](https://dev.example.com/handbook)         ## Tools        - [Build Status](https://ci.example.com/status)        - [Issue Tracker](https://issues.example.com)        - [Code Review](https://review.example.com)         ## External Links        - [Blog Post](https://blog.example.com/announcement)        - [Video Tutorial](https://youtube.com/watch?v=demo)        - [Community Forum](https://forum.example.com)    "});     cx.update_editor(|editor, cx| {        editor.display_map.update(cx, |map, cx| {            map.syntax_fold_config = SyntaxFoldConfig {                enabled: true,                auto_fold_on_open: true,                proximity_expand_distance: 2,            };            map.detect_syntax_folds(cx);        });         // Verify all links are folded        let snapshot = editor.snapshot(cx);        let fold_count = snapshot.fold_count();        assert_eq!(fold_count, 9, "All 9 links should be folded");         // Verify visual appearance (folded links show only text)        let display_text = snapshot.display_text();        assert!(display_text.contains("API Reference"));        assert!(!display_text.contains("https://api.example.com/docs"));    });} fn init_test(cx: &mut TestAppContext) {    cx.update(|cx| {        let settings = crate::test::test_settings(cx);        cx.set_global(settings);        theme::init(theme::LoadThemes::JustBase, cx);        language::init(cx);        crate::init(cx);    });}