pub mod editor_lsp_test_context;pub mod editor_test_context; use std::{rc::Rc, sync::LazyLock}; pub use crate::rust_analyzer_ext::expand_macro_recursively;use crate::{    DisplayPoint, Editor, EditorMode, FoldPlaceholder, MultiBuffer, SelectionEffects, Size,    display_map::{        Block, BlockPlacement, CustomBlockId, DisplayMap, DisplayRow, DisplaySnapshot,        ToDisplayPoint,    },};use collections::HashMap;use gpui::{    AppContext as _, Context, Entity, EntityId, Font, FontFeatures, FontStyle, FontWeight, Pixels,    VisualTestContext, Window, font, size,};use multi_buffer::{MultiBufferOffset, ToPoint};use pretty_assertions::assert_eq;use project::{Project, project_settings::DiagnosticSeverity};use ui::{App, BorrowAppContext, IntoElement, px};use util::test::{generate_marked_text, marked_text_offsets, marked_text_ranges}; #[cfg(test)]#[ctor::ctor]fn init_logger() {    zlog::init_test();} pub fn test_font() -> Font {    static TEST_FONT: LazyLock<Font> = LazyLock::new(|| {        #[cfg(not(target_os = "windows"))]        {            font("Helvetica")        }         #[cfg(target_os = "windows")]        {            font("Courier New")        }    });     TEST_FONT.clone()} // Returns a snapshot from text containing '|' character markers with the markers removed, and DisplayPoints for each one.#[track_caller]pub fn marked_display_snapshot(    text: &str,    cx: &mut gpui::App,) -> (DisplaySnapshot, Vec<DisplayPoint>) {    let (unmarked_text, markers) = marked_text_offsets(text);     let font = Font {        family: ".ZedMono".into(),        features: FontFeatures::default(),        fallbacks: None,        weight: FontWeight::default(),        style: FontStyle::default(),    };    let font_size: Pixels = 14usize.into();     let buffer = MultiBuffer::build_simple(&unmarked_text, cx);    let display_map = cx.new(|cx| {        DisplayMap::new(            buffer,            font,            font_size,            None,            1,            1,            FoldPlaceholder::test(),            DiagnosticSeverity::Warning,            cx,        )    });    let snapshot = display_map.update(cx, |map, cx| map.snapshot(cx));    let markers = markers        .into_iter()        .map(|offset| MultiBufferOffset(offset).to_display_point(&snapshot))        .collect();     (snapshot, markers)} #[track_caller]pub fn select_ranges(    editor: &mut Editor,    marked_text: &str,    window: &mut Window,    cx: &mut Context<Editor>,) {    let (unmarked_text, text_ranges) = marked_text_ranges(marked_text, true);    assert_eq!(editor.text(cx), unmarked_text);    editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {        s.select_ranges(            text_ranges                .into_iter()                .map(|range| MultiBufferOffset(range.start)..MultiBufferOffset(range.end)),        )    });} #[track_caller]pub fn assert_text_with_selections(    editor: &mut Editor,    marked_text: &str,    cx: &mut Context<Editor>,) {    let (unmarked_text, _text_ranges) = marked_text_ranges(marked_text, true);    assert_eq!(editor.text(cx), unmarked_text, "text doesn't match");    let actual = generate_marked_text(        &editor.text(cx),        &editor            .selections            .ranges::<MultiBufferOffset>(&editor.display_snapshot(cx))            .into_iter()            .map(|range| range.start.0..range.end.0)            .collect::<Vec<_>>(),        marked_text.contains("«"),    );    assert_eq!(actual, marked_text, "Selections don't match");} #[cfg(any(test, feature = "test-support"))]pub(crate) fn build_editor(    buffer: Entity<MultiBuffer>,    window: &mut Window,    cx: &mut Context<Editor>,) -> Editor {    Editor::new(EditorMode::full(), buffer, None, window, cx)} pub(crate) fn build_editor_with_project(    project: Entity<Project>,    buffer: Entity<MultiBuffer>,    window: &mut Window,    cx: &mut Context<Editor>,) -> Editor {    Editor::new(EditorMode::full(), buffer, Some(project), window, cx)} #[derive(Default)]struct TestBlockContent(    HashMap<(EntityId, CustomBlockId), Rc<dyn Fn(&mut VisualTestContext) -> String>>,); impl gpui::Global for TestBlockContent {} pub fn set_block_content_for_tests(    editor: &Entity<Editor>,    id: CustomBlockId,    cx: &mut App,    f: impl Fn(&mut VisualTestContext) -> String + 'static,) {    cx.update_default_global::<TestBlockContent, _>(|bc, _| {        bc.0.insert((editor.entity_id(), id), Rc::new(f))    });} pub fn block_content_for_tests(    editor: &Entity<Editor>,    id: CustomBlockId,    cx: &mut VisualTestContext,) -> Option<String> {    let f = cx.update(|_, cx| {        cx.default_global::<TestBlockContent>()            .0            .get(&(editor.entity_id(), id))            .cloned()    })?;    Some(f(cx))} pub fn editor_content_with_blocks(editor: &Entity<Editor>, cx: &mut VisualTestContext) -> String {    editor_content_with_blocks_and_width(editor, px(3000.), cx)} pub fn editor_content_with_blocks_and_width(    editor: &Entity<Editor>,    width: Pixels,    cx: &mut VisualTestContext,) -> String {    editor_content_with_blocks_and_size(editor, size(width, px(3000.0)), cx)} pub fn editor_content_with_blocks_and_size(    editor: &Entity<Editor>,    draw_size: Size<Pixels>,    cx: &mut VisualTestContext,) -> String {    cx.simulate_resize(draw_size);    cx.draw(gpui::Point::default(), draw_size, |_, _| {        editor.clone().into_any_element()    });    let (snapshot, mut lines, blocks) = editor.update_in(cx, |editor, window, cx| {        let snapshot = editor.snapshot(window, cx);        let text = editor.display_text(cx);        let lines = text.lines().map(|s| s.to_string()).collect::<Vec<String>>();        let blocks = snapshot            .blocks_in_range(DisplayRow(0)..snapshot.max_point().row())            .map(|(row, block)| (row, block.clone()))            .collect::<Vec<_>>();        (snapshot, lines, blocks)    });    for (row, block) in blocks {        match block {            Block::Custom(custom_block) => {                if let BlockPlacement::Near(x) = &custom_block.placement                    && snapshot.intersects_fold(x.to_point(&snapshot.buffer_snapshot()))                {                    continue;                };                let content = block_content_for_tests(editor, custom_block.id, cx)                    .expect("block content not found");                // 2: "related info 1 for diagnostic 0"                if let Some(height) = custom_block.height {                    if height == 0 {                        lines[row.0 as usize - 1].push_str(" § ");                        lines[row.0 as usize - 1].push_str(&content);                    } else {                        let block_lines = content.lines().collect::<Vec<_>>();                        assert_eq!(block_lines.len(), height as usize);                        lines[row.0 as usize].push_str("§ ");                        lines[row.0 as usize].push_str(block_lines[0].trim_end());                        for i in 1..height as usize {                            if row.0 as usize + i >= lines.len() {                                lines.push("".to_string());                            };                            lines[row.0 as usize + i].push_str("§ ");                            lines[row.0 as usize + i].push_str(block_lines[i].trim_end());                        }                    }                }            }            Block::FoldedBuffer {                first_excerpt,                height,            } => {                while lines.len() <= row.0 as usize {                    lines.push(String::new());                }                lines[row.0 as usize].push_str(&cx.update(|_, cx| {                    format!(                        "§ {}",                        first_excerpt                            .buffer                            .file()                            .map(|file| file.file_name(cx))                            .unwrap_or("<no file>")                    )                }));                for row in row.0 + 1..row.0 + height {                    while lines.len() <= row as usize {                        lines.push(String::new());                    }                    lines[row as usize].push_str("§ -----");                }            }            Block::ExcerptBoundary { height, .. } => {                for row in row.0..row.0 + height {                    while lines.len() <= row as usize {                        lines.push(String::new());                    }                    lines[row as usize].push_str("§ -----");                }            }            Block::BufferHeader { excerpt, height } => {                while lines.len() <= row.0 as usize {                    lines.push(String::new());                }                lines[row.0 as usize].push_str(&cx.update(|_, cx| {                    format!(                        "§ {}",                        excerpt                            .buffer                            .file()                            .map(|file| file.file_name(cx))                            .unwrap_or("<no file>")                    )                }));                for row in row.0 + 1..row.0 + height {                    while lines.len() <= row as usize {                        lines.push(String::new());                    }                    lines[row as usize].push_str("§ -----");                }            }            Block::Spacer { height, .. } => {                for row in row.0..row.0 + height {                    while lines.len() <= row as usize {                        lines.push(String::new());                    }                    lines[row as usize].push_str("§ spacer");                }            }        }    }    lines.join("\n")}