WIP

crates/collab2/src/tests.rs

@@ -4,6 +4,7 @@ use gpui::{Model, TestAppContext};
 mod channel_buffer_tests;
 mod channel_message_tests;
 mod channel_tests;
+mod editor_tests;
 mod following_tests;
 mod integration_tests;
 mod notification_tests;

crates/editor2/src/test.rs

@@ -1,81 +1,72 @@
 pub mod editor_lsp_test_context;
 pub mod editor_test_context;
 
-// todo!()
-// use crate::{
-//     display_map::{DisplayMap, DisplaySnapshot, ToDisplayPoint},
-//     DisplayPoint, Editor, EditorMode, MultiBuffer,
-// };
+use crate::{
+    display_map::{DisplayMap, DisplaySnapshot, ToDisplayPoint},
+    DisplayPoint, Editor, EditorMode, MultiBuffer,
+};
 
-// use gpui::{Model, ViewContext};
+use gpui::{Context, Model, Pixels, ViewContext};
 
-// use project::Project;
-// use util::test::{marked_text_offsets, marked_text_ranges};
+use project::Project;
+use util::test::{marked_text_offsets, marked_text_ranges};
 
-// #[cfg(test)]
-// #[ctor::ctor]
-// fn init_logger() {
-//     if std::env::var("RUST_LOG").is_ok() {
-//         env_logger::init();
-//     }
-// }
+#[cfg(test)]
+#[ctor::ctor]
+fn init_logger() {
+    if std::env::var("RUST_LOG").is_ok() {
+        env_logger::init();
+    }
+}
 
-// // Returns a snapshot from text containing '|' character markers with the markers removed, and DisplayPoints for each one.
-// pub fn marked_display_snapshot(
-//     text: &str,
-//     cx: &mut gpui::AppContext,
-// ) -> (DisplaySnapshot, Vec<DisplayPoint>) {
-//     let (unmarked_text, markers) = marked_text_offsets(text);
+// Returns a snapshot from text containing '|' character markers with the markers removed, and DisplayPoints for each one.
+pub fn marked_display_snapshot(
+    text: &str,
+    cx: &mut gpui::AppContext,
+) -> (DisplaySnapshot, Vec<DisplayPoint>) {
+    let (unmarked_text, markers) = marked_text_offsets(text);
 
-//     let family_id = cx
-//         .font_cache()
-//         .load_family(&["Helvetica"], &Default::default())
-//         .unwrap();
-//     let font_id = cx
-//         .font_cache()
-//         .select_font(family_id, &Default::default())
-//         .unwrap();
-//     let font_size = 14.0;
+    let font = cx.text_style().font();
+    let font_size: Pixels = 14.into();
 
-//     let buffer = MultiBuffer::build_simple(&unmarked_text, cx);
-//     let display_map =
-//         cx.add_model(|cx| DisplayMap::new(buffer, font_id, font_size, None, 1, 1, cx));
-//     let snapshot = display_map.update(cx, |map, cx| map.snapshot(cx));
-//     let markers = markers
-//         .into_iter()
-//         .map(|offset| offset.to_display_point(&snapshot))
-//         .collect();
+    let buffer = MultiBuffer::build_simple(&unmarked_text, cx);
+    let display_map = cx.build_model(|cx| DisplayMap::new(buffer, font, font_size, None, 1, 1, cx));
+    let snapshot = display_map.update(cx, |map, cx| map.snapshot(cx));
+    let markers = markers
+        .into_iter()
+        .map(|offset| offset.to_display_point(&snapshot))
+        .collect();
 
-//     (snapshot, markers)
-// }
+    (snapshot, markers)
+}
 
-// pub fn select_ranges(editor: &mut Editor, marked_text: &str, cx: &mut ViewContext<Editor>) {
-//     let (unmarked_text, text_ranges) = marked_text_ranges(marked_text, true);
-//     assert_eq!(editor.text(cx), unmarked_text);
-//     editor.change_selections(None, cx, |s| s.select_ranges(text_ranges));
-// }
+pub fn select_ranges(editor: &mut Editor, marked_text: &str, cx: &mut ViewContext<Editor>) {
+    let (unmarked_text, text_ranges) = marked_text_ranges(marked_text, true);
+    assert_eq!(editor.text(cx), unmarked_text);
+    editor.change_selections(None, cx, |s| s.select_ranges(text_ranges));
+}
 
-// pub fn assert_text_with_selections(
-//     editor: &mut Editor,
-//     marked_text: &str,
-//     cx: &mut ViewContext<Editor>,
-// ) {
-//     let (unmarked_text, text_ranges) = marked_text_ranges(marked_text, true);
-//     assert_eq!(editor.text(cx), unmarked_text);
-//     assert_eq!(editor.selections.ranges(cx), text_ranges);
-// }
+pub fn assert_text_with_selections(
+    editor: &mut Editor,
+    marked_text: &str,
+    cx: &mut ViewContext<Editor>,
+) {
+    let (unmarked_text, text_ranges) = marked_text_ranges(marked_text, true);
+    assert_eq!(editor.text(cx), unmarked_text);
+    assert_eq!(editor.selections.ranges(cx), text_ranges);
+}
 
-// // RA thinks this is dead code even though it is used in a whole lot of tests
-// #[allow(dead_code)]
-// #[cfg(any(test, feature = "test-support"))]
-// pub(crate) fn build_editor(buffer: Model<MultiBuffer>, cx: &mut ViewContext<Editor>) -> Editor {
-//     Editor::new(EditorMode::Full, buffer, None, None, cx)
-// }
+// RA thinks this is dead code even though it is used in a whole lot of tests
+#[allow(dead_code)]
+#[cfg(any(test, feature = "test-support"))]
+pub(crate) fn build_editor(buffer: Model<MultiBuffer>, cx: &mut ViewContext<Editor>) -> Editor {
+    Editor::new(EditorMode::Full, buffer, None, None, cx)
+}
 
-// pub(crate) fn build_editor_with_project(
-//     project: Model<Project>,
-//     buffer: Model<MultiBuffer>,
-//     cx: &mut ViewContext<Editor>,
-// ) -> Editor {
-//     Editor::new(EditorMode::Full, buffer, Some(project), None, cx)
-// }
+pub(crate) fn build_editor_with_project(
+    project: Model<Project>,
+    buffer: Model<MultiBuffer>,
+    cx: &mut ViewContext<Editor>,
+) -> Editor {
+    Editor::new(EditorMode::Full, buffer, Some(project), None, cx)
+}

crates/editor2/src/test/editor_test_context.rs

@@ -19,313 +19,313 @@ use util::{
 
 // use super::build_editor_with_project;
 
-// pub struct EditorTestContext<'a> {
-//     pub cx: &'a mut gpui::TestAppContext,
-//     pub window: AnyWindowHandle,
-//     pub editor: View<Editor>,
-// }
+pub struct EditorTestContext<'a> {
+    pub cx: &'a mut gpui::TestAppContext,
+    pub window: AnyWindowHandle,
+    pub editor: View<Editor>,
+}
 
-// impl<'a> EditorTestContext<'a> {
-//     pub async fn new(cx: &'a mut gpui::TestAppContext) -> EditorTestContext<'a> {
-//         let fs = FakeFs::new(cx.background());
-//         // fs.insert_file("/file", "".to_owned()).await;
-//         fs.insert_tree(
-//             "/root",
-//             gpui::serde_json::json!({
-//                 "file": "",
-//             }),
-//         )
-//         .await;
-//         let project = Project::test(fs, ["/root".as_ref()], cx).await;
-//         let buffer = project
-//             .update(cx, |project, cx| {
-//                 project.open_local_buffer("/root/file", cx)
-//             })
-//             .await
-//             .unwrap();
-//         let window = cx.add_window(|cx| {
-//             cx.focus_self();
-//             build_editor_with_project(project, MultiBuffer::build_from_buffer(buffer, cx), cx)
-//         });
-//         let editor = window.root(cx);
-//         Self {
-//             cx,
-//             window: window.into(),
-//             editor,
-//         }
-//     }
+impl<'a> EditorTestContext<'a> {
+    pub async fn new(cx: &'a mut gpui::TestAppContext) -> EditorTestContext<'a> {
+        let fs = FakeFs::new(cx.executor().clone());
+        // fs.insert_file("/file", "".to_owned()).await;
+        fs.insert_tree(
+            "/root",
+            gpui::serde_json::json!({
+                "file": "",
+            }),
+        )
+        .await;
+        let project = Project::test(fs, ["/root".as_ref()], cx).await;
+        let buffer = project
+            .update(cx, |project, cx| {
+                project.open_local_buffer("/root/file", cx)
+            })
+            .await
+            .unwrap();
+        let window = cx.add_window(|cx| {
+            cx.focus_self();
+            build_editor_with_project(project, MultiBuffer::build_from_buffer(buffer, cx), cx)
+        });
+        let editor = window.root(cx);
+        Self {
+            cx,
+            window: window.into(),
+            editor,
+        }
+    }
 
-//     pub fn condition(
-//         &self,
-//         predicate: impl FnMut(&Editor, &AppContext) -> bool,
-//     ) -> impl Future<Output = ()> {
-//         self.editor.condition(self.cx, predicate)
-//     }
+    pub fn condition(
+        &self,
+        predicate: impl FnMut(&Editor, &AppContext) -> bool,
+    ) -> impl Future<Output = ()> {
+        self.editor.condition(self.cx, predicate)
+    }
 
-//     pub fn editor<F, T>(&self, read: F) -> T
-//     where
-//         F: FnOnce(&Editor, &ViewContext<Editor>) -> T,
-//     {
-//         self.editor.update(self.cx, read)
-//     }
+    pub fn editor<F, T>(&self, read: F) -> T
+    where
+        F: FnOnce(&Editor, &ViewContext<Editor>) -> T,
+    {
+        self.editor.update(self.cx, read)
+    }
 
-//     pub fn update_editor<F, T>(&mut self, update: F) -> T
-//     where
-//         F: FnOnce(&mut Editor, &mut ViewContext<Editor>) -> T,
-//     {
-//         self.editor.update(self.cx, update)
-//     }
+    pub fn update_editor<F, T>(&mut self, update: F) -> T
+    where
+        F: FnOnce(&mut Editor, &mut ViewContext<Editor>) -> T,
+    {
+        self.editor.update(self.cx, update)
+    }
 
-//     pub fn multibuffer<F, T>(&self, read: F) -> T
-//     where
-//         F: FnOnce(&MultiBuffer, &AppContext) -> T,
-//     {
-//         self.editor(|editor, cx| read(editor.buffer().read(cx), cx))
-//     }
+    pub fn multibuffer<F, T>(&self, read: F) -> T
+    where
+        F: FnOnce(&MultiBuffer, &AppContext) -> 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 ModelContext<MultiBuffer>) -> T,
-//     {
-//         self.update_editor(|editor, cx| editor.buffer().update(cx, update))
-//     }
+    pub fn update_multibuffer<F, T>(&mut self, update: F) -> T
+    where
+        F: FnOnce(&mut MultiBuffer, &mut ModelContext<MultiBuffer>) -> T,
+    {
+        self.update_editor(|editor, cx| editor.buffer().update(cx, update))
+    }
 
-//     pub fn buffer_text(&self) -> String {
-//         self.multibuffer(|buffer, cx| buffer.snapshot(cx).text())
-//     }
+    pub fn buffer_text(&self) -> String {
+        self.multibuffer(|buffer, cx| buffer.snapshot(cx).text())
+    }
 
-//     pub fn buffer<F, T>(&self, read: F) -> T
-//     where
-//         F: FnOnce(&Buffer, &AppContext) -> T,
-//     {
-//         self.multibuffer(|multibuffer, cx| {
-//             let buffer = multibuffer.as_singleton().unwrap().read(cx);
-//             read(buffer, cx)
-//         })
-//     }
+    pub fn buffer<F, T>(&self, read: F) -> T
+    where
+        F: FnOnce(&Buffer, &AppContext) -> T,
+    {
+        self.multibuffer(|multibuffer, cx| {
+            let buffer = multibuffer.as_singleton().unwrap().read(cx);
+            read(buffer, cx)
+        })
+    }
 
-//     pub fn update_buffer<F, T>(&mut self, update: F) -> T
-//     where
-//         F: FnOnce(&mut Buffer, &mut ModelContext<Buffer>) -> T,
-//     {
-//         self.update_multibuffer(|multibuffer, cx| {
-//             let buffer = multibuffer.as_singleton().unwrap();
-//             buffer.update(cx, update)
-//         })
-//     }
+    pub fn update_buffer<F, T>(&mut self, update: F) -> T
+    where
+        F: FnOnce(&mut Buffer, &mut ModelContext<Buffer>) -> T,
+    {
+        self.update_multibuffer(|multibuffer, cx| {
+            let buffer = multibuffer.as_singleton().unwrap();
+            buffer.update(cx, update)
+        })
+    }
 
-//     pub fn buffer_snapshot(&self) -> BufferSnapshot {
-//         self.buffer(|buffer, _| buffer.snapshot())
-//     }
+    pub fn buffer_snapshot(&self) -> BufferSnapshot {
+        self.buffer(|buffer, _| buffer.snapshot())
+    }
 
-// pub fn simulate_keystroke(&mut self, keystroke_text: &str) -> ContextHandle {
-//     let keystroke_under_test_handle =
-//         self.add_assertion_context(format!("Simulated Keystroke: {:?}", keystroke_text));
-//     let keystroke = Keystroke::parse(keystroke_text).unwrap();
+    pub fn simulate_keystroke(&mut self, keystroke_text: &str) -> ContextHandle {
+        let keystroke_under_test_handle =
+            self.add_assertion_context(format!("Simulated Keystroke: {:?}", keystroke_text));
+        let keystroke = Keystroke::parse(keystroke_text).unwrap();
 
-//     self.cx.dispatch_keystroke(self.window, keystroke, false);
+        self.cx.dispatch_keystroke(self.window, keystroke, false);
 
-//     keystroke_under_test_handle
-// }
+        keystroke_under_test_handle
+    }
 
-// pub fn simulate_keystrokes<const COUNT: usize>(
-//     &mut self,
-//     keystroke_texts: [&str; COUNT],
-// ) -> ContextHandle {
-//     let keystrokes_under_test_handle =
-//         self.add_assertion_context(format!("Simulated Keystrokes: {:?}", keystroke_texts));
-//     for keystroke_text in keystroke_texts.into_iter() {
-//         self.simulate_keystroke(keystroke_text);
-//     }
-//     // it is common for keyboard shortcuts to kick off async actions, so this ensures that they are complete
-//     // before returning.
-//     // NOTE: we don't do this in simulate_keystroke() because a possible cause of bugs is that typing too
-//     // quickly races with async actions.
-//     if let Foreground::Deterministic { cx_id: _, executor } = self.cx.foreground().as_ref() {
-//         executor.run_until_parked();
-//     } else {
-//         unreachable!();
-//     }
+    pub fn simulate_keystrokes<const COUNT: usize>(
+        &mut self,
+        keystroke_texts: [&str; COUNT],
+    ) -> ContextHandle {
+        let keystrokes_under_test_handle =
+            self.add_assertion_context(format!("Simulated Keystrokes: {:?}", keystroke_texts));
+        for keystroke_text in keystroke_texts.into_iter() {
+            self.simulate_keystroke(keystroke_text);
+        }
+        // it is common for keyboard shortcuts to kick off async actions, so this ensures that they are complete
+        // before returning.
+        // NOTE: we don't do this in simulate_keystroke() because a possible cause of bugs is that typing too
+        // quickly races with async actions.
+        if let Foreground::Deterministic { cx_id: _, executor } = self.cx.foreground().as_ref() {
+            executor.run_until_parked();
+        } else {
+            unreachable!();
+        }
 
-//     keystrokes_under_test_handle
-// }
+        keystrokes_under_test_handle
+    }
 
-// pub fn ranges(&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 ranges(&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(self.cx, |editor, cx| editor.snapshot(cx));
-//     ranges[0].start.to_display_point(&snapshot)
-// }
+    pub fn display_point(&mut self, marked_text: &str) -> DisplayPoint {
+        let ranges = self.ranges(marked_text);
+        let snapshot = self
+            .editor
+            .update(self.cx, |editor, cx| editor.snapshot(cx));
+        ranges[0].start.to_display_point(&snapshot)
+    }
 
-// // Returns anchors for the current buffer using `«` and `»`
-// pub fn text_anchor_range(&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)
-// }
+    // Returns anchors for the current buffer using `«` and `»`
+    pub fn text_anchor_range(&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_diff_base(&mut self, diff_base: Option<&str>) {
-//     let diff_base = diff_base.map(String::from);
-//     self.update_buffer(|buffer, cx| buffer.set_diff_base(diff_base, cx));
-// }
+    pub fn set_diff_base(&mut self, diff_base: Option<&str>) {
+        let diff_base = diff_base.map(String::from);
+        self.update_buffer(|buffer, cx| buffer.set_diff_base(diff_base, cx));
+    }
 
-// /// 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().to_string()
-//     ));
-//     let (unmarked_text, selection_ranges) = marked_text_ranges(marked_text, true);
-//     self.editor.update(self.cx, |editor, cx| {
-//         editor.set_text(unmarked_text, cx);
-//         editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
-//             s.select_ranges(selection_ranges)
-//         })
-//     });
-//     state_context
-// }
+    /// 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().to_string()
+        ));
+        let (unmarked_text, selection_ranges) = marked_text_ranges(marked_text, true);
+        self.editor.update(self.cx, |editor, cx| {
+            editor.set_text(unmarked_text, cx);
+            editor.change_selections(Some(Autoscroll::fit()), 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().to_string()
-//     ));
-//     let (unmarked_text, selection_ranges) = marked_text_ranges(marked_text, true);
-//     self.editor.update(self.cx, |editor, cx| {
-//         assert_eq!(editor.text(cx), unmarked_text);
-//         editor.change_selections(Some(Autoscroll::fit()), 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().to_string()
+        ));
+        let (unmarked_text, selection_ranges) = marked_text_ranges(marked_text, true);
+        self.editor.update(self.cx, |editor, cx| {
+            assert_eq!(editor.text(cx), unmarked_text);
+            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
+                s.select_ranges(selection_ranges)
+            })
+        });
+        state_context
+    }
 
-// /// 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 (unmarked_text, expected_selections) = marked_text_ranges(marked_text, true);
-//     let buffer_text = self.buffer_text();
+    /// 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 (unmarked_text, expected_selections) = marked_text_ranges(marked_text, true);
+        let buffer_text = self.buffer_text();
 
-//     if buffer_text != unmarked_text {
-//         panic!("Unmarked text doesn't match buffer text\nBuffer text: {buffer_text:?}\nUnmarked text: {unmarked_text:?}\nRaw buffer text\n{buffer_text}Raw unmarked text\n{unmarked_text}");
-//     }
+        if buffer_text != unmarked_text {
+            panic!("Unmarked text doesn't match buffer text\nBuffer text: {buffer_text:?}\nUnmarked text: {unmarked_text:?}\nRaw buffer text\n{buffer_text}Raw unmarked text\n{unmarked_text}");
+        }
 
-//     self.assert_selections(expected_selections, marked_text.to_string())
-// }
+        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)
-// }
+    pub fn editor_state(&mut self) -> String {
+        generate_marked_text(self.buffer_text().as_str(), &self.editor_selections(), true)
+    }
 
-// #[track_caller]
-// pub fn assert_editor_background_highlights<Tag: 'static>(&mut self, marked_text: &str) {
-//     let expected_ranges = self.ranges(marked_text);
-//     let actual_ranges: Vec<Range<usize>> = self.update_editor(|editor, cx| {
-//         let snapshot = editor.snapshot(cx);
-//         editor
-//             .background_highlights
-//             .get(&TypeId::of::<Tag>())
-//             .map(|h| h.1.clone())
-//             .unwrap_or_default()
-//             .into_iter()
-//             .map(|range| range.to_offset(&snapshot.buffer_snapshot))
-//             .collect()
-//     });
-//     assert_set_eq!(actual_ranges, expected_ranges);
-// }
+    #[track_caller]
+    pub fn assert_editor_background_highlights<Tag: 'static>(&mut self, marked_text: &str) {
+        let expected_ranges = self.ranges(marked_text);
+        let actual_ranges: Vec<Range<usize>> = self.update_editor(|editor, cx| {
+            let snapshot = editor.snapshot(cx);
+            editor
+                .background_highlights
+                .get(&TypeId::of::<Tag>())
+                .map(|h| h.1.clone())
+                .unwrap_or_default()
+                .into_iter()
+                .map(|range| range.to_offset(&snapshot.buffer_snapshot))
+                .collect()
+        });
+        assert_set_eq!(actual_ranges, expected_ranges);
+    }
 
-// #[track_caller]
-// pub fn assert_editor_text_highlights<Tag: ?Sized + 'static>(&mut self, marked_text: &str) {
-//     let expected_ranges = self.ranges(marked_text);
-//     let snapshot = self.update_editor(|editor, cx| editor.snapshot(cx));
-//     let actual_ranges: Vec<Range<usize>> = snapshot
-//         .text_highlight_ranges::<Tag>()
-//         .map(|ranges| ranges.as_ref().clone().1)
-//         .unwrap_or_default()
-//         .into_iter()
-//         .map(|range| range.to_offset(&snapshot.buffer_snapshot))
-//         .collect();
-//     assert_set_eq!(actual_ranges, expected_ranges);
-// }
+    #[track_caller]
+    pub fn assert_editor_text_highlights<Tag: ?Sized + 'static>(&mut self, marked_text: &str) {
+        let expected_ranges = self.ranges(marked_text);
+        let snapshot = self.update_editor(|editor, cx| editor.snapshot(cx));
+        let actual_ranges: Vec<Range<usize>> = snapshot
+            .text_highlight_ranges::<Tag>()
+            .map(|ranges| ranges.as_ref().clone().1)
+            .unwrap_or_default()
+            .into_iter()
+            .map(|range| range.to_offset(&snapshot.buffer_snapshot))
+            .collect();
+        assert_set_eq!(actual_ranges, expected_ranges);
+    }
 
-// #[track_caller]
-// pub fn assert_editor_selections(&mut self, expected_selections: Vec<Range<usize>>) {
-//     let expected_marked_text =
-//         generate_marked_text(&self.buffer_text(), &expected_selections, true);
-//     self.assert_selections(expected_selections, expected_marked_text)
-// }
+    #[track_caller]
+    pub fn assert_editor_selections(&mut self, expected_selections: Vec<Range<usize>>) {
+        let expected_marked_text =
+            generate_marked_text(&self.buffer_text(), &expected_selections, true);
+        self.assert_selections(expected_selections, expected_marked_text)
+    }
 
-// fn editor_selections(&self) -> Vec<Range<usize>> {
-//     self.editor
-//         .read_with(self.cx, |editor, cx| editor.selections.all::<usize>(cx))
-//         .into_iter()
-//         .map(|s| {
-//             if s.reversed {
-//                 s.end..s.start
-//             } else {
-//                 s.start..s.end
-//             }
-//         })
-//         .collect::<Vec<_>>()
-// }
+    fn editor_selections(&self) -> Vec<Range<usize>> {
+        self.editor
+            .read_with(self.cx, |editor, cx| editor.selections.all::<usize>(cx))
+            .into_iter()
+            .map(|s| {
+                if s.reversed {
+                    s.end..s.start
+                } else {
+                    s.start..s.end
+                }
+            })
+            .collect::<Vec<_>>()
+    }
 
-// #[track_caller]
-// fn assert_selections(
-//     &mut self,
-//     expected_selections: Vec<Range<usize>>,
-//     expected_marked_text: String,
-// ) {
-//     let actual_selections = self.editor_selections();
-//     let actual_marked_text =
-//         generate_marked_text(&self.buffer_text(), &actual_selections, true);
-//     if expected_selections != actual_selections {
-//         panic!(
-//             indoc! {"
+    #[track_caller]
+    fn assert_selections(
+        &mut self,
+        expected_selections: Vec<Range<usize>>,
+        expected_marked_text: String,
+    ) {
+        let actual_selections = self.editor_selections();
+        let actual_marked_text =
+            generate_marked_text(&self.buffer_text(), &actual_selections, true);
+        if expected_selections != actual_selections {
+            panic!(
+                indoc! {"
 
-//                 {}Editor has unexpected selections.
+                {}Editor has unexpected selections.
 
-//                 Expected selections:
-//                 {}
+                Expected selections:
+                {}
 
-//                 Actual selections:
-//                 {}
-//             "},
-//             self.assertion_context(),
-//             expected_marked_text,
-//             actual_marked_text,
-//         );
-//     }
-// }
-// }
-//
-// impl<'a> Deref for EditorTestContext<'a> {
-//     type Target = gpui::TestAppContext;
+                Actual selections:
+                {}
+            "},
+                self.assertion_context(),
+                expected_marked_text,
+                actual_marked_text,
+            );
+        }
+    }
+}
 
-//     fn deref(&self) -> &Self::Target {
-//         self.cx
-//     }
-// }
+impl<'a> Deref for EditorTestContext<'a> {
+    type Target = gpui::TestAppContext;
 
-// impl<'a> DerefMut for EditorTestContext<'a> {
-//     fn deref_mut(&mut self) -> &mut Self::Target {
-//         &mut self.cx
-//     }
-// }
+    fn deref(&self) -> &Self::Target {
+        self.cx
+    }
+}
+
+impl<'a> DerefMut for EditorTestContext<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.cx
+    }
+}