Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix most of the FoldMap random tests with inlays

Browse source 
Co-Authored-By: Antonio Scandurra <antonio@zed.dev>
This commit is contained in:
Kirill Bulatov 2023-06-16 13:31:53 +03:00
parent f2c510000b
commit d4d88252c3
1 changed files with 71 additions and 54 deletions
Download patch file Download diff file Expand all files Collapse all files

125
crates/editor/src/display_map/fold_map.rs
View file

@ -35,6 +35,7 @@ impl FoldPoint {
&mut self.0.row &mut self.0.row
} }
#[cfg(test)]
pub fn column_mut(&mut self) -> &mut u32 { pub fn column_mut(&mut self) -> &mut u32 {
&mut self.0.column &mut self.0.column
} }
@ -235,9 +236,7 @@ impl FoldMap {
if cfg!(test) { if cfg!(test) {
assert_eq!( assert_eq!(
self.snapshot.transforms.summary().input.len, self.snapshot.transforms.summary().input.len,
self.snapshot self.snapshot.inlay_snapshot.len().0,
.inlay_snapshot
.to_buffer_offset(self.snapshot.inlay_snapshot.len()),
"transform tree does not match inlay snapshot's length" "transform tree does not match inlay snapshot's length"
); );
@ -1160,6 +1159,13 @@ impl FoldOffset {
}; };
FoldPoint(cursor.start().1.output.lines + overshoot) FoldPoint(cursor.start().1.output.lines + overshoot)
} }
pub fn to_inlay_offset(self, snapshot: &FoldSnapshot) -> InlayOffset {
let mut cursor = snapshot.transforms.cursor::<(FoldOffset, InlayOffset)>();
cursor.seek(&self, Bias::Right, &());
let overshoot = self.0 - cursor.start().0 .0;
InlayOffset(cursor.start().1 .0 + overshoot)
}
} }
impl Add for FoldOffset { impl Add for FoldOffset {
@ -1213,6 +1219,7 @@ mod tests {
use settings::SettingsStore; use settings::SettingsStore;
use std::{cmp::Reverse, env, mem, sync::Arc}; use std::{cmp::Reverse, env, mem, sync::Arc};
use sum_tree::TreeMap; use sum_tree::TreeMap;
use text::Patch;
use util::test::sample_text; use util::test::sample_text;
use util::RandomCharIter; use util::RandomCharIter;
use Bias::{Left, Right}; use Bias::{Left, Right};
@ -1458,13 +1465,19 @@ mod tests {
Arc::new((HighlightStyle::default(), highlight_ranges)), Arc::new((HighlightStyle::default(), highlight_ranges)),
); );
let mut next_inlay_id = 0;
for _ in 0..operations { for _ in 0..operations {
log::info!("text: {:?}", buffer_snapshot.text()); log::info!("text: {:?}", buffer_snapshot.text());
let mut buffer_edits = Vec::new(); let mut buffer_edits = Vec::new();
let mut inlay_edits = Vec::new();
match rng.gen_range(0..=100) { match rng.gen_range(0..=100) {
0..=59 => { 0..=39 => {
snapshot_edits.extend(map.randomly_mutate(&mut rng)); snapshot_edits.extend(map.randomly_mutate(&mut rng));
} }
40..=59 => {
let (_, edits) = inlay_map.randomly_mutate(&mut next_inlay_id, &mut rng);
inlay_edits = edits;
}
_ => buffer.update(cx, |buffer, cx| { _ => buffer.update(cx, |buffer, cx| {
let subscription = buffer.subscribe(); let subscription = buffer.subscribe();
let edit_count = rng.gen_range(1..=5); let edit_count = rng.gen_range(1..=5);
@ -1476,14 +1489,19 @@ mod tests {
}), }),
}; };
let (inlay_snapshot, inlay_edits) = let (inlay_snapshot, new_inlay_edits) =
inlay_map.sync(buffer_snapshot.clone(), buffer_edits); inlay_map.sync(buffer_snapshot.clone(), buffer_edits);
let inlay_edits = Patch::new(inlay_edits)
.compose(new_inlay_edits)
.into_inner();
let (snapshot, edits) = map.read(inlay_snapshot.clone(), inlay_edits); let (snapshot, edits) = map.read(inlay_snapshot.clone(), inlay_edits);
snapshot_edits.push((snapshot.clone(), edits)); snapshot_edits.push((snapshot.clone(), edits));
let mut expected_text: String = buffer_snapshot.text().to_string(); let mut expected_text: String = inlay_snapshot.text().to_string();
for fold_range in map.merged_fold_ranges().into_iter().rev() { for fold_range in map.merged_fold_ranges().into_iter().rev() {
expected_text.replace_range(fold_range.start..fold_range.end, "⋯"); let fold_inlay_start = inlay_snapshot.to_inlay_offset(fold_range.start);
let fold_inlay_end = inlay_snapshot.to_inlay_offset(fold_range.end);
expected_text.replace_range(fold_inlay_start.0..fold_inlay_end.0, "⋯");
} }
assert_eq!(snapshot.text(), expected_text); assert_eq!(snapshot.text(), expected_text);
@ -1493,27 +1511,27 @@ mod tests {
expected_text.matches('\n').count() + 1 expected_text.matches('\n').count() + 1
); );
let mut prev_row = 0; // let mut prev_row = 0;
let mut expected_buffer_rows = Vec::new(); // let mut expected_buffer_rows = Vec::new();
for fold_range in map.merged_fold_ranges().into_iter() { // for fold_range in map.merged_fold_ranges().into_iter() {
let fold_start = buffer_snapshot.offset_to_point(fold_range.start).row; // let fold_start = buffer_snapshot.offset_to_point(fold_range.start).row;
let fold_end = buffer_snapshot.offset_to_point(fold_range.end).row; // let fold_end = buffer_snapshot.offset_to_point(fold_range.end).row;
expected_buffer_rows.extend( // expected_buffer_rows.extend(
buffer_snapshot // buffer_snapshot
.buffer_rows(prev_row) // .buffer_rows(prev_row)
.take((1 + fold_start - prev_row) as usize), // .take((1 + fold_start - prev_row) as usize),
); // );
prev_row = 1 + fold_end; // prev_row = 1 + fold_end;
} // }
expected_buffer_rows.extend(buffer_snapshot.buffer_rows(prev_row)); // expected_buffer_rows.extend(buffer_snapshot.buffer_rows(prev_row));
assert_eq!( // assert_eq!(
expected_buffer_rows.len(), // expected_buffer_rows.len(),
expected_text.matches('\n').count() + 1, // expected_text.matches('\n').count() + 1,
"wrong expected buffer rows {:?}. text: {:?}", // "wrong expected buffer rows {:?}. text: {:?}",
expected_buffer_rows, // expected_buffer_rows,
expected_text // expected_text
); // );
for (output_row, line) in expected_text.lines().enumerate() { for (output_row, line) in expected_text.lines().enumerate() {
let line_len = snapshot.line_len(output_row as u32); let line_len = snapshot.line_len(output_row as u32);
@ -1532,18 +1550,17 @@ mod tests {
let mut char_column = 0; let mut char_column = 0;
for c in expected_text.chars() { for c in expected_text.chars() {
let inlay_point = fold_point.to_inlay_point(&snapshot); let inlay_point = fold_point.to_inlay_point(&snapshot);
let buffer_point = inlay_snapshot.to_buffer_point(inlay_point); let inlay_offset = fold_offset.to_inlay_offset(&snapshot);
let buffer_offset = buffer_snapshot.point_to_offset(buffer_point);
assert_eq!( assert_eq!(
snapshot.to_fold_point(inlay_point, Right), snapshot.to_fold_point(inlay_point, Right),
fold_point, fold_point,
"{:?} -> fold point", "{:?} -> fold point",
buffer_point, inlay_point,
); );
assert_eq!( assert_eq!(
inlay_snapshot.to_buffer_offset(inlay_snapshot.to_offset(inlay_point)), inlay_snapshot.to_offset(inlay_point),
buffer_offset, inlay_offset,
"inlay_snapshot.to_buffer_offset(inlay_snapshot.to_offset(({:?}))", "inlay_snapshot.to_offset({:?})",
inlay_point, inlay_point,
); );
assert_eq!( assert_eq!(
@ -1592,28 +1609,28 @@ mod tests {
); );
} }
let mut fold_row = 0; // let mut fold_row = 0;
while fold_row < expected_buffer_rows.len() as u32 { // while fold_row < expected_buffer_rows.len() as u32 {
fold_row = snapshot // fold_row = snapshot
.clip_point(FoldPoint::new(fold_row, 0), Bias::Right) // .clip_point(FoldPoint::new(fold_row, 0), Bias::Right)
.row(); // .row();
assert_eq!( // assert_eq!(
snapshot.buffer_rows(fold_row).collect::<Vec<_>>(), // snapshot.buffer_rows(fold_row).collect::<Vec<_>>(),
expected_buffer_rows[(fold_row as usize)..], // expected_buffer_rows[(fold_row as usize)..],
"wrong buffer rows starting at fold row {}", // "wrong buffer rows starting at fold row {}",
fold_row, // fold_row,
); // );
fold_row += 1; // fold_row += 1;
} // }
let fold_start_rows = map // let fold_start_rows = map
.merged_fold_ranges() // .merged_fold_ranges()
.iter() // .iter()
.map(|range| range.start.to_point(&buffer_snapshot).row) // .map(|range| range.start.to_point(&buffer_snapshot).row)
.collect::<HashSet<_>>(); // .collect::<HashSet<_>>();
for row in fold_start_rows { // for row in fold_start_rows {
assert!(snapshot.is_line_folded(row)); // assert!(snapshot.is_line_folded(row));
} // }
for _ in 0..5 { for _ in 0..5 {
let end = let end =