use crate::{    display_map::ToDisplayPoint, AnchorRangeExt, Autoscroll, DisplayPoint, Editor, MultiBuffer,    RowExt,};use buffer_diff::DiffHunkStatusKind;use collections::BTreeMap;use futures::Future; use gpui::{    prelude::*, AnyWindowHandle, App, Context, Entity, Focusable as _, Keystroke, Pixels, Point,    VisualTestContext, Window, WindowHandle,};use itertools::Itertools;use language::{Buffer, BufferSnapshot, LanguageRegistry};use multi_buffer::{Anchor, ExcerptRange, MultiBufferRow};use parking_lot::RwLock;use project::{FakeFs, Project};use std::{    any::TypeId,    ops::{Deref, DerefMut, Range},    path::Path,    sync::{        atomic::{AtomicUsize, Ordering},        Arc,    },};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 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));            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(),        }    }     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(|range| ExcerptRange {                        context: range,                        primary: None,                    }),                    cx,                );            }            multibuffer        });         let editor = cx.add_window(|window, cx| {            let editor = build_editor(buffer, window, cx);            window.focus(&editor.focus_handle(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)        });        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(cx).head();            let pixel_position = editor.pixel_position_of_newest_cursor.unwrap();            let line_height = editor                .style()                .unwrap()                .text                .line_height_in_pixels(window.rem_size());            let snapshot = editor.snapshot(window, cx);            let details = editor.text_layout_details(window);             let y = pixel_position.y                + line_height * (display_point.row().as_f32() - newest_point.row().as_f32());            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 fn set_head_text(&mut self, diff_base: &str) {        self.cx.run_until_parked();        let fs = self.update_editor(|editor, _, cx| {            editor.project.as_ref().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.into(), diff_base.to_string())],        );        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.as_ref().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.as_ref().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.into(), 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.as_ref().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(path.as_ref()).cloned();        });        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.    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(Some(Autoscroll::fit()), window, cx, |s| {                s.select_ranges(selection_ranges)            })        });        state_context    }     /// Only change the editor's selections    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(Some(Autoscroll::fit()), window, cx, |s| {                s.select_ranges(selection_ranges)            })        });        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 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();            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()        );         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.len() > 0 {                    assert!(                        is_selected,                        "excerpt {ix} should be selected. got {:?}",                        self.editor_state(),                    );                } else {                    assert!(                        !is_selected,                        "excerpt {ix} should not be selected, got: {selections:?}",                    );                }                continue;            }            assert!(!is_folded, "excerpt {} should not be folded", ix);            assert_eq!(                multibuffer_snapshot                    .text_for_range(Anchor::range_in_buffer(                        excerpt_id,                        snapshot.remote_id(),                        range.context.clone()                    ))                    .collect::<String>(),                expected_text            );             let selections = selections                .iter()                .filter(|s| s.head().excerpt_id == excerpt_id)                .map(|s| {                    let head = text::ToOffset::to_offset(&s.head().text_anchor, &snapshot)                        - text::ToOffset::to_offset(&range.context.start, &snapshot);                    let tail = text::ToOffset::to_offset(&s.head().text_anchor, &snapshot)                        - text::ToOffset::to_offset(&range.context.start, &snapshot);                    tail..head                })                .collect::<Vec<_>>();            // todo: selections that cross excerpt boundaries..            assert_eq!(                selections, expected_selections,                "excerpt {} has incorrect selections",                ix,            );        }    }     /// Make an assertion about the editor's text and the ranges and directions    /// of its selections using a string containing embedded range markers.    ///    /// See the `util::test::marked_text_ranges` function for more information.    #[track_caller]    pub fn assert_editor_state(&mut self, marked_text: &str) {        let (expected_text, expected_selections) = marked_text_ranges(marked_text, true);        pretty_assertions::assert_eq!(self.buffer_text(), expected_text, "unexpected buffer text");        self.assert_selections(expected_selections, marked_text.to_string())    }     /// Make an assertion about the editor's text and the ranges and directions    /// of its selections using a string containing embedded range markers.    ///    /// See the `util::test::marked_text_ranges` function for more information.    #[track_caller]    pub fn assert_display_state(&mut self, marked_text: &str) {        let (expected_text, expected_selections) = marked_text_ranges(marked_text, true);        pretty_assertions::assert_eq!(self.display_text(), expected_text, "unexpected buffer text");        self.assert_selections(expected_selections, marked_text.to_string())    }     pub fn editor_state(&mut self) -> String {        generate_marked_text(self.buffer_text().as_str(), &self.editor_selections(), true)    } 

Lines 1–500 of 686. Load more