use crate::{    AnchorRangeExt, DisplayPoint, Editor, ExcerptId, MultiBuffer, MultiBufferSnapshot, RowExt,    display_map::{HighlightKey, ToDisplayPoint},};use buffer_diff::DiffHunkStatusKind;use collections::BTreeMap;use futures::Future; use git::repository::RepoPath;use gpui::{    AnyWindowHandle, App, Context, Entity, Focusable as _, Keystroke, Pixels, Point,    VisualTestContext, Window, WindowHandle, prelude::*,};use itertools::Itertools;use language::{Buffer, BufferSnapshot, LanguageRegistry};use multi_buffer::{Anchor, ExcerptRange, MultiBufferOffset, MultiBufferRow};use parking_lot::RwLock;use project::{FakeFs, Project};use std::{    ops::{Deref, DerefMut, Range},    path::Path,    sync::{        Arc,        atomic::{AtomicUsize, Ordering},    },};use text::Selection;use util::{    assert_set_eq,    test::{generate_marked_text, marked_text_ranges},}; use super::{build_editor, build_editor_with_project}; pub struct EditorTestContext {    pub cx: gpui::VisualTestContext,    pub window: AnyWindowHandle,    pub editor: Entity<Editor>,    pub assertion_cx: AssertionContextManager,} impl EditorTestContext {    pub async fn new(cx: &mut gpui::TestAppContext) -> EditorTestContext {        let fs = FakeFs::new(cx.executor());        let root = Self::root_path();        fs.insert_tree(            root,            serde_json::json!({                ".git": {},                "file": "",            }),        )        .await;        let project = Project::test(fs.clone(), [root], cx).await;        let buffer = project            .update(cx, |project, cx| {                project.open_local_buffer(root.join("file"), cx)            })            .await            .unwrap();         let language = project            .read_with(cx, |project, _cx| {                project.languages().language_for_name("Plain Text")            })            .await            .unwrap();        buffer.update(cx, |buffer, cx| {            buffer.set_language(Some(language), cx);        });         let editor = cx.add_window(|window, cx| {            let editor = build_editor_with_project(                project,                MultiBuffer::build_from_buffer(buffer, cx),                window,                cx,            );             window.focus(&editor.focus_handle(cx), cx);            editor        });        let editor_view = editor.root(cx).unwrap();         cx.run_until_parked();        Self {            cx: VisualTestContext::from_window(*editor.deref(), cx),            window: editor.into(),            editor: editor_view,            assertion_cx: AssertionContextManager::new(),        }    }     #[cfg(target_os = "windows")]    fn root_path() -> &'static Path {        Path::new("C:\\root")    }     #[cfg(not(target_os = "windows"))]    fn root_path() -> &'static Path {        Path::new("/root")    }     pub async fn for_editor_in(editor: Entity<Editor>, cx: &mut gpui::VisualTestContext) -> Self {        cx.focus(&editor);        Self {            window: cx.windows()[0],            cx: cx.clone(),            editor,            assertion_cx: AssertionContextManager::new(),        }    }     pub async fn for_editor(editor: WindowHandle<Editor>, cx: &mut gpui::TestAppContext) -> Self {        let editor_view = editor.root(cx).unwrap();        Self {            cx: VisualTestContext::from_window(*editor.deref(), cx),            window: editor.into(),            editor: editor_view,            assertion_cx: AssertionContextManager::new(),        }    }     #[track_caller]    pub fn new_multibuffer<const COUNT: usize>(        cx: &mut gpui::TestAppContext,        excerpts: [&str; COUNT],    ) -> EditorTestContext {        let mut multibuffer = MultiBuffer::new(language::Capability::ReadWrite);        let buffer = cx.new(|cx| {            for excerpt in excerpts.into_iter() {                let (text, ranges) = marked_text_ranges(excerpt, false);                let buffer = cx.new(|cx| Buffer::local(text, cx));                multibuffer.push_excerpts(buffer, ranges.into_iter().map(ExcerptRange::new), cx);            }            multibuffer        });         let editor = cx.add_window(|window, cx| {            let editor = build_editor(buffer, window, cx);            window.focus(&editor.focus_handle(cx), cx);             editor        });         let editor_view = editor.root(cx).unwrap();        Self {            cx: VisualTestContext::from_window(*editor.deref(), cx),            window: editor.into(),            editor: editor_view,            assertion_cx: AssertionContextManager::new(),        }    }     pub fn condition(        &self,        predicate: impl FnMut(&Editor, &App) -> bool,    ) -> impl Future<Output = ()> {        self.editor            .condition::<crate::EditorEvent>(&self.cx, predicate)    }     #[track_caller]    pub fn editor<F, T>(&mut self, read: F) -> T    where        F: FnOnce(&Editor, &Window, &mut Context<Editor>) -> T,    {        self.editor            .update_in(&mut self.cx, |this, window, cx| read(this, window, cx))    }     #[track_caller]    pub fn update_editor<F, T>(&mut self, update: F) -> T    where        F: FnOnce(&mut Editor, &mut Window, &mut Context<Editor>) -> T,    {        self.editor.update_in(&mut self.cx, update)    }     pub fn multibuffer<F, T>(&mut self, read: F) -> T    where        F: FnOnce(&MultiBuffer, &App) -> T,    {        self.editor(|editor, _, cx| read(editor.buffer().read(cx), cx))    }     pub fn update_multibuffer<F, T>(&mut self, update: F) -> T    where        F: FnOnce(&mut MultiBuffer, &mut Context<MultiBuffer>) -> T,    {        self.update_editor(|editor, _, cx| editor.buffer().update(cx, update))    }     pub fn buffer_text(&mut self) -> String {        self.multibuffer(|buffer, cx| buffer.snapshot(cx).text())    }     pub fn display_text(&mut self) -> String {        self.update_editor(|editor, _, cx| editor.display_text(cx))    }     pub fn buffer<F, T>(&mut self, read: F) -> T    where        F: FnOnce(&Buffer, &App) -> T,    {        self.multibuffer(|multibuffer, cx| {            let buffer = multibuffer.as_singleton().unwrap().read(cx);            read(buffer, cx)        })    }     pub fn language_registry(&mut self) -> Arc<LanguageRegistry> {        self.editor(|editor, _, cx| {            editor                .project                .as_ref()                .unwrap()                .read(cx)                .languages()                .clone()        })    }     pub fn update_buffer<F, T>(&mut self, update: F) -> T    where        F: FnOnce(&mut Buffer, &mut Context<Buffer>) -> T,    {        self.update_multibuffer(|multibuffer, cx| {            let buffer = multibuffer.as_singleton().unwrap();            buffer.update(cx, update)        })    }     pub fn buffer_snapshot(&mut self) -> BufferSnapshot {        self.buffer(|buffer, _| buffer.snapshot())    }     pub fn add_assertion_context(&self, context: String) -> ContextHandle {        self.assertion_cx.add_context(context)    }     pub fn assertion_context(&self) -> String {        self.assertion_cx.context()    }     // unlike cx.simulate_keystrokes(), this does not run_until_parked    // so you can use it to test detailed timing    pub fn simulate_keystroke(&mut self, keystroke_text: &str) {        let keystroke = Keystroke::parse(keystroke_text).unwrap();        self.cx.dispatch_keystroke(self.window, keystroke);    }     pub fn run_until_parked(&mut self) {        self.cx.background_executor.run_until_parked();    }     #[track_caller]    pub fn ranges(&mut self, marked_text: &str) -> Vec<Range<usize>> {        let (unmarked_text, ranges) = marked_text_ranges(marked_text, false);        assert_eq!(self.buffer_text(), unmarked_text);        ranges    }     pub fn display_point(&mut self, marked_text: &str) -> DisplayPoint {        let ranges = self.ranges(marked_text);        let snapshot = self.editor.update_in(&mut self.cx, |editor, window, cx| {            editor.snapshot(window, cx)        });        MultiBufferOffset(ranges[0].start).to_display_point(&snapshot)    }     pub fn pixel_position(&mut self, marked_text: &str) -> Point<Pixels> {        let display_point = self.display_point(marked_text);        self.pixel_position_for(display_point)    }     pub fn pixel_position_for(&mut self, display_point: DisplayPoint) -> Point<Pixels> {        self.update_editor(|editor, window, cx| {            let newest_point = editor                .selections                .newest_display(&editor.display_snapshot(cx))                .head();            let pixel_position = editor.pixel_position_of_newest_cursor.unwrap();            let line_height = editor                .style(cx)                .text                .line_height_in_pixels(window.rem_size());            let snapshot = editor.snapshot(window, cx);            let details = editor.text_layout_details(window, cx);             let y = pixel_position.y                + f32::from(line_height)                    * Pixels::from(display_point.row().as_f64() - newest_point.row().as_f64());            let x = pixel_position.x + snapshot.x_for_display_point(display_point, &details)                - snapshot.x_for_display_point(newest_point, &details);            Point::new(x, y)        })    }     // Returns anchors for the current buffer using `«` and `»`    pub fn text_anchor_range(&mut self, marked_text: &str) -> Range<language::Anchor> {        let ranges = self.ranges(marked_text);        let snapshot = self.buffer_snapshot();        snapshot.anchor_before(ranges[0].start)..snapshot.anchor_after(ranges[0].end)    }     pub async fn wait_for_autoindent_applied(&mut self) {        if let Some(fut) = self.update_buffer(|buffer, _| buffer.wait_for_autoindent_applied()) {            fut.await.ok();        }    }     pub fn set_head_text(&mut self, diff_base: &str) {        self.cx.run_until_parked();        let fs =            self.update_editor(|editor, _, cx| editor.project().unwrap().read(cx).fs().as_fake());        let path = self.update_buffer(|buffer, _| buffer.file().unwrap().path().clone());        fs.set_head_for_repo(            &Self::root_path().join(".git"),            &[(path.as_unix_str(), diff_base.to_string())],            "deadbeef",        );        self.cx.run_until_parked();    }     pub fn clear_index_text(&mut self) {        self.cx.run_until_parked();        let fs =            self.update_editor(|editor, _, cx| editor.project().unwrap().read(cx).fs().as_fake());        fs.set_index_for_repo(&Self::root_path().join(".git"), &[]);        self.cx.run_until_parked();    }     pub fn set_index_text(&mut self, diff_base: &str) {        self.cx.run_until_parked();        let fs =            self.update_editor(|editor, _, cx| editor.project().unwrap().read(cx).fs().as_fake());        let path = self.update_buffer(|buffer, _| buffer.file().unwrap().path().clone());        fs.set_index_for_repo(            &Self::root_path().join(".git"),            &[(path.as_unix_str(), diff_base.to_string())],        );        self.cx.run_until_parked();    }     #[track_caller]    pub fn assert_index_text(&mut self, expected: Option<&str>) {        let fs =            self.update_editor(|editor, _, cx| editor.project().unwrap().read(cx).fs().as_fake());        let path = self.update_buffer(|buffer, _| buffer.file().unwrap().path().clone());        let mut found = None;        fs.with_git_state(&Self::root_path().join(".git"), false, |git_state| {            found = git_state                .index_contents                .get(&RepoPath::from_rel_path(&path))                .cloned();        })        .unwrap();        assert_eq!(expected, found.as_deref());    }     /// Change the editor's text and selections using a string containing    /// embedded range markers that represent the ranges and directions of    /// each selection.    ///    /// Returns a context handle so that assertion failures can print what    /// editor state was needed to cause the failure.    ///    /// See the `util::test::marked_text_ranges` function for more information.    #[track_caller]    pub fn set_state(&mut self, marked_text: &str) -> ContextHandle {        let state_context = self.add_assertion_context(format!(            "Initial Editor State: \"{}\"",            marked_text.escape_debug()        ));        let (unmarked_text, selection_ranges) = marked_text_ranges(marked_text, true);        self.editor.update_in(&mut self.cx, |editor, window, cx| {            editor.set_text(unmarked_text, window, cx);            editor.change_selections(Default::default(), window, cx, |s| {                s.select_ranges(                    selection_ranges                        .into_iter()                        .map(|range| MultiBufferOffset(range.start)..MultiBufferOffset(range.end)),                )            })        });        state_context    }     /// Only change the editor's selections    #[track_caller]    pub fn set_selections_state(&mut self, marked_text: &str) -> ContextHandle {        let state_context = self.add_assertion_context(format!(            "Initial Editor State: \"{}\"",            marked_text.escape_debug()        ));        let (unmarked_text, selection_ranges) = marked_text_ranges(marked_text, true);        self.editor.update_in(&mut self.cx, |editor, window, cx| {            assert_eq!(editor.text(cx), unmarked_text);            editor.change_selections(Default::default(), window, cx, |s| {                s.select_ranges(                    selection_ranges                        .into_iter()                        .map(|range| MultiBufferOffset(range.start)..MultiBufferOffset(range.end)),                )            })        });        state_context    }     /// Assert about the text of the editor, the selections, and the expanded    /// diff hunks.    ///    /// Diff hunks are indicated by lines starting with `+` and `-`.    #[track_caller]    pub fn assert_state_with_diff(&mut self, expected_diff_text: String) {        assert_state_with_diff(&self.editor, &mut self.cx, &expected_diff_text);    }     #[track_caller]    pub fn assert_excerpts_with_selections(&mut self, marked_text: &str) {        let actual_text = self.to_format_multibuffer_as_marked_text();        let fmt_additional_notes = || {            struct Format<'a, T: std::fmt::Display>(&'a str, &'a T);             impl<T: std::fmt::Display> std::fmt::Display for Format<'_, T> {                fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {                    write!(                        f,                        "\n\n----- EXPECTED: -----\n\n{}\n\n----- ACTUAL: -----\n\n{}\n\n",                        self.0, self.1                    )                }            }             Format(marked_text, &actual_text)        };         let expected_excerpts = marked_text            .strip_prefix("[EXCERPT]\n")            .unwrap()            .split("[EXCERPT]\n")            .collect::<Vec<_>>();         let (multibuffer_snapshot, selections, excerpts) = self.update_editor(|editor, _, cx| {            let multibuffer_snapshot = editor.buffer.read(cx).snapshot(cx);             let selections = editor.selections.disjoint_anchors_arc();            let excerpts = multibuffer_snapshot                .excerpts()                .map(|(e_id, snapshot, range)| (e_id, snapshot.clone(), range))                .collect::<Vec<_>>();             (multibuffer_snapshot, selections, excerpts)        });         assert!(            excerpts.len() == expected_excerpts.len(),            "should have {} excerpts, got {}{}",            expected_excerpts.len(),            excerpts.len(),            fmt_additional_notes(),        );         for (ix, (excerpt_id, snapshot, range)) in excerpts.into_iter().enumerate() {            let is_folded = self                .update_editor(|editor, _, cx| editor.is_buffer_folded(snapshot.remote_id(), cx));            let (expected_text, expected_selections) =                marked_text_ranges(expected_excerpts[ix], true);            if expected_text == "[FOLDED]\n" {                assert!(is_folded, "excerpt {} should be folded", ix);                let is_selected = selections.iter().any(|s| s.head().excerpt_id == excerpt_id);                if !expected_selections.is_empty() {                    assert!(                        is_selected,                        "excerpt {ix} should contain selections. got {:?}{}",                        self.editor_state(),                        fmt_additional_notes(),                    );                } else {                    assert!(                        !is_selected,                        "excerpt {ix} should not contain selections, got: {selections:?}{}",                        fmt_additional_notes(),                    );                }                continue;            }            assert!(                !is_folded,                "excerpt {} should not be folded{}",                ix,                fmt_additional_notes()            );            assert_eq!(                multibuffer_snapshot                    .text_for_range(Anchor::range_in_buffer(excerpt_id, range.context.clone()))                    .collect::<String>(),                expected_text,                "{}",

Lines 1–500 of 826. Load more