1pub mod editor_lsp_test_context;
2pub mod editor_test_context;
3
4use crate::{
5 display_map::{DisplayMap, DisplaySnapshot, ToDisplayPoint},
6 DisplayPoint, Editor, EditorMode, FoldPlaceholder, MultiBuffer,
7};
8use gpui::{Context, Font, FontFeatures, FontStyle, FontWeight, Model, Pixels, ViewContext};
9use project::Project;
10use util::test::{marked_text_offsets, marked_text_ranges};
11
12#[cfg(test)]
13#[ctor::ctor]
14fn init_logger() {
15 if std::env::var("RUST_LOG").is_ok() {
16 env_logger::init();
17 }
18}
19
20// Returns a snapshot from text containing '|' character markers with the markers removed, and DisplayPoints for each one.
21pub fn marked_display_snapshot(
22 text: &str,
23 cx: &mut gpui::AppContext,
24) -> (DisplaySnapshot, Vec<DisplayPoint>) {
25 let (unmarked_text, markers) = marked_text_offsets(text);
26
27 let font = Font {
28 family: "Zed Plex Mono".into(),
29 features: FontFeatures::default(),
30 weight: FontWeight::default(),
31 style: FontStyle::default(),
32 };
33 let font_size: Pixels = 14usize.into();
34
35 let buffer = MultiBuffer::build_simple(&unmarked_text, cx);
36 let display_map = cx.new_model(|cx| {
37 DisplayMap::new(
38 buffer,
39 font,
40 font_size,
41 None,
42 true,
43 1,
44 1,
45 1,
46 FoldPlaceholder::test(),
47 cx,
48 )
49 });
50 let snapshot = display_map.update(cx, |map, cx| map.snapshot(cx));
51 let markers = markers
52 .into_iter()
53 .map(|offset| offset.to_display_point(&snapshot))
54 .collect();
55
56 (snapshot, markers)
57}
58
59pub fn select_ranges(editor: &mut Editor, marked_text: &str, cx: &mut ViewContext<Editor>) {
60 let (unmarked_text, text_ranges) = marked_text_ranges(marked_text, true);
61 assert_eq!(editor.text(cx), unmarked_text);
62 editor.change_selections(None, cx, |s| s.select_ranges(text_ranges));
63}
64
65#[track_caller]
66pub fn assert_text_with_selections(
67 editor: &mut Editor,
68 marked_text: &str,
69 cx: &mut ViewContext<Editor>,
70) {
71 let (unmarked_text, text_ranges) = marked_text_ranges(marked_text, true);
72 assert_eq!(editor.text(cx), unmarked_text);
73 assert_eq!(editor.selections.ranges(cx), text_ranges);
74}
75
76// RA thinks this is dead code even though it is used in a whole lot of tests
77#[allow(dead_code)]
78#[cfg(any(test, feature = "test-support"))]
79pub(crate) fn build_editor(buffer: Model<MultiBuffer>, cx: &mut ViewContext<Editor>) -> Editor {
80 Editor::new(EditorMode::Full, buffer, None, true, cx)
81}
82
83pub(crate) fn build_editor_with_project(
84 project: Model<Project>,
85 buffer: Model<MultiBuffer>,
86 cx: &mut ViewContext<Editor>,
87) -> Editor {
88 Editor::new(EditorMode::Full, buffer, Some(project), true, cx)
89}
90
91#[cfg(any(test, feature = "test-support"))]
92pub fn editor_hunks(
93 editor: &Editor,
94 snapshot: &DisplaySnapshot,
95 cx: &mut ViewContext<'_, Editor>,
96) -> Vec<(
97 String,
98 git::diff::DiffHunkStatus,
99 std::ops::Range<crate::DisplayRow>,
100)> {
101 use multi_buffer::MultiBufferRow;
102 use text::Point;
103
104 use crate::hunk_status;
105
106 snapshot
107 .buffer_snapshot
108 .git_diff_hunks_in_range(MultiBufferRow::MIN..MultiBufferRow::MAX)
109 .map(|hunk| {
110 let display_range = Point::new(hunk.associated_range.start.0, 0)
111 .to_display_point(snapshot)
112 .row()
113 ..Point::new(hunk.associated_range.end.0, 0)
114 .to_display_point(snapshot)
115 .row();
116 let (_, buffer, _) = editor
117 .buffer()
118 .read(cx)
119 .excerpt_containing(Point::new(hunk.associated_range.start.0, 0), cx)
120 .expect("no excerpt for expanded buffer's hunk start");
121 let diff_base = buffer
122 .read(cx)
123 .diff_base()
124 .expect("should have a diff base for expanded hunk")
125 .slice(hunk.diff_base_byte_range.clone())
126 .to_string();
127 (diff_base, hunk_status(&hunk), display_range)
128 })
129 .collect()
130}
131
132#[cfg(any(test, feature = "test-support"))]
133pub fn expanded_hunks(
134 editor: &Editor,
135 snapshot: &DisplaySnapshot,
136 cx: &mut ViewContext<'_, Editor>,
137) -> Vec<(
138 String,
139 git::diff::DiffHunkStatus,
140 std::ops::Range<crate::DisplayRow>,
141)> {
142 editor
143 .expanded_hunks
144 .hunks(false)
145 .map(|expanded_hunk| {
146 let hunk_display_range = expanded_hunk
147 .hunk_range
148 .start
149 .to_display_point(snapshot)
150 .row()
151 ..expanded_hunk
152 .hunk_range
153 .end
154 .to_display_point(snapshot)
155 .row();
156 let (_, buffer, _) = editor
157 .buffer()
158 .read(cx)
159 .excerpt_containing(expanded_hunk.hunk_range.start, cx)
160 .expect("no excerpt for expanded buffer's hunk start");
161 let diff_base = buffer
162 .read(cx)
163 .diff_base()
164 .expect("should have a diff base for expanded hunk")
165 .slice(expanded_hunk.diff_base_byte_range.clone())
166 .to_string();
167 (diff_base, expanded_hunk.status, hunk_display_range)
168 })
169 .collect()
170}
171
172#[cfg(any(test, feature = "test-support"))]
173pub fn expanded_hunks_background_highlights(
174 editor: &mut Editor,
175 cx: &mut gpui::WindowContext,
176) -> Vec<std::ops::RangeInclusive<crate::DisplayRow>> {
177 use crate::DisplayRow;
178
179 let mut highlights = Vec::new();
180
181 let mut range_start = 0;
182 let mut previous_highlighted_row = None;
183 for (highlighted_row, _) in editor.highlighted_display_rows(cx) {
184 match previous_highlighted_row {
185 Some(previous_row) => {
186 if previous_row + 1 != highlighted_row.0 {
187 highlights.push(DisplayRow(range_start)..=DisplayRow(previous_row));
188 range_start = highlighted_row.0;
189 }
190 }
191 None => {
192 range_start = highlighted_row.0;
193 }
194 }
195 previous_highlighted_row = Some(highlighted_row.0);
196 }
197 if let Some(previous_row) = previous_highlighted_row {
198 highlights.push(DisplayRow(range_start)..=DisplayRow(previous_row));
199 }
200
201 highlights
202}