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