Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

111 KB
Raw Blame
use language::{Bias, LanguageAwareStyling, Point};
use multi_buffer::{MBTextSummary, MultiBufferRow};
use std::ops::Range;
use unicode_segmentation::{GraphemeCursor, GraphemeIncomplete};

use crate::{
    DisplayPoint,
    display_map::{DisplaySnapshot, FoldPoint, Highlights, TabPoint, ToDisplayPoint as _},
};

pub(crate) struct ColumnarSelectionRows<'a> {
    snapshot: &'a DisplaySnapshot,
}

impl<'a> ColumnarSelectionRows<'a> {
    pub(crate) fn new(snapshot: &'a DisplaySnapshot) -> Self {
        Self { snapshot }
    }

    pub(crate) fn columns_for_ranges(&mut self, ranges: &[Range<Point>]) -> Vec<Range<u32>> {
        let tabs = self.snapshot.tab_snapshot();
        let mut endpoints = ranges
            .iter()
            .enumerate()
            .flat_map(|(index, range)| {
                [(range.start, false), (range.end, true)]
                    .map(|(point, end)| (tabs.point_to_tab_point(point, Bias::Left), index, end))
            })
            .collect::<Vec<_>>();
        endpoints.sort_unstable();
        let mut answers = vec![0..0; ranges.len()];
        for endpoints in endpoints.chunk_by(|left, right| left.0.row() == right.0.row()) {
            let mut text = self.row(endpoints[0].0.row());
            let mut cursor = text.forward_cursor();
            for &(point, index, end) in endpoints {
                text.floor_forward(&mut cursor, point.column());
                if end {
                    answers[index].end = cursor.column;
                } else {
                    answers[index].start = cursor.column;
                }
            }
        }
        for answer in &mut answers {
            *answer = answer.start.min(answer.end)..answer.start.max(answer.end);
        }
        answers
    }

    pub(crate) fn points_for_rows(
        &mut self,
        queries: &[(u32, Range<u32>)],
    ) -> Vec<Option<(Point, Point)>> {
        let tabs = self.snapshot.tab_snapshot();
        let max_row = tabs.max_point().row();
        let mut endpoints = Vec::new();
        for (index, (row, columns)) in queries.iter().enumerate() {
            if *row <= max_row && columns.start <= columns.end {
                endpoints.push((*row, columns.start, false, index));
                if columns.start != columns.end {
                    endpoints.push((*row, columns.end, true, index));
                }
            }
        }
        endpoints.sort_unstable();
        let mut answers = vec![None::<(Point, Point)>; queries.len()];
        for endpoints in endpoints.chunk_by(|left, right| left.0 == right.0) {
            let row = endpoints[0].0;
            let length = tabs.line_len(row);
            let mut text = self.row(row);
            let mut cursor = text.cursor(0);
            let mut column = 0;
            let mut preceding = None;
            let mut buffer_cursor = None;
            for &(_, goal, end, index) in endpoints {
                let columns = &queries[index].1;
                if (end && answers[index].is_none())
                    || (!end && columns.start != columns.end && goal >= length)
                {
                    continue;
                }
                text.advance_columns(&mut cursor, goal - column);
                column = goal;
                if !end && columns.start != columns.end && cursor.byte() == length {
                    continue;
                }
                let point = self.point_for_cursor(
                    row,
                    &mut text,
                    cursor.clone(),
                    preceding,
                    &mut buffer_cursor,
                );
                preceding = Some((cursor.byte(), point));
                answers[index] = if end {
                    answers[index]
                        .zip(point)
                        .map(|((start, _), end)| (start.min(end), start.max(end)))
                } else {
                    point.map(|point| (point, point))
                };
            }
        }
        answers
    }

    #[cfg(test)]
    pub(crate) fn columns_for_range(&mut self, range: Range<Point>) -> Range<u32> {
        self.columns_for_ranges(&[range]).pop().expect("one range")
    }

    #[cfg(test)]
    pub(crate) fn points_for_row(
        &mut self,
        row: u32,
        columns: &Range<u32>,
    ) -> Option<(Point, Point)> {
        self.points_for_rows(&[(row, columns.clone())])
            .pop()
            .flatten()
    }

    fn point_for_cursor(
        &self,
        row: u32,
        text: &mut RowText<'a>,
        mut cursor: BoundaryCursor,
        preceding: Option<(u32, Option<Point>)>,
        buffer_cursor: &mut Option<BufferRowCursor<'a>>,
    ) -> Option<Point> {
        let frontier = preceding.map_or(0, |(byte, _)| byte);
        let mut backward_buffer_cursor = None;
        if let Some(buffer_cursor) = buffer_cursor {
            buffer_cursor.reverse = None;
        }
        loop {
            if let Some((byte, point)) = preceding
                && cursor.byte() <= byte
            {
                return point;
            }
            let tab_point = TabPoint::new(row, cursor.byte());
            let tabs = self.snapshot.tab_snapshot();
            let fold_point = tabs.tab_point_to_fold_point(tab_point, Bias::Left).0;
            if let Some(range) = self
                .snapshot
                .fold_snapshot()
                .placeholder_range_at(fold_point)
                && range.start < fold_point
            {
                let start = tabs.fold_point_to_tab_point(range.start);
                text.retreat_to(&mut cursor, start.column().max(frontier));
                continue;
            }
            let point = tabs.tab_point_to_point(tab_point, Bias::Left);
            let display_point = point.to_display_point(self.snapshot);
            let hidden = self.snapshot.is_block_line(display_point.row());
            let canonical = tabs.point_to_tab_point(point, Bias::Left);
            if !hidden
                && canonical == tab_point
                && self.floor_buffer_point(buffer_cursor, &mut backward_buffer_cursor, point)
                    == point
            {
                return Some(point);
            }
            let preceding = if hidden && canonical == tab_point {
                let hidden_start = self.snapshot.display_point_to_fold_point(
                    DisplayPoint::new(display_point.row(), 0),
                    Bias::Left,
                );
                let hidden_start = tabs.fold_point_to_tab_point(hidden_start);
                if hidden_start.row() != row {
                    return None;
                }
                if hidden_start < tab_point {
                    hidden_start
                } else {
                    TabPoint::new(row, hidden_start.column().checked_sub(1)?)
                }
            } else if canonical < tab_point {
                canonical
            } else {
                let previous = if let Some(byte) = point.column.checked_sub(1) {
                    self.floor_buffer_point(
                        buffer_cursor,
                        &mut backward_buffer_cursor,
                        Point::new(point.row, byte),
                    )
                } else {
                    let row = point.row.checked_sub(1)?;
                    Point::new(
                        row,
                        self.snapshot
                            .buffer_snapshot()
                            .line_len(MultiBufferRow(row)),
                    )
                };
                tabs.point_to_tab_point(previous, Bias::Left)
            };
            if preceding.row() != row {
                return None;
            }
            if preceding < tab_point {
                text.retreat_to(&mut cursor, preceding.column().max(frontier));
            } else {
                text.previous_boundary(&mut cursor)?;
            }
        }
    }

    fn floor_buffer_point(
        &self,
        forward: &mut Option<BufferRowCursor<'a>>,
        backward: &mut Option<BufferRowCursor<'a>>,
        point: Point,
    ) -> Point {
        if forward.as_ref().is_none_or(|cursor| cursor.row < point.row) {
            *backward = forward.replace(self.buffer_row_cursor(point.row));
        }
        let cursor = if let Some(cursor) = forward.as_mut().filter(|cursor| cursor.row == point.row)
        {
            cursor
        } else {
            if backward
                .as_ref()
                .is_none_or(|cursor| cursor.row != point.row)
            {
                let cursor = backward.insert(self.buffer_row_cursor(point.row));
                cursor.reverse = Some(cursor.text.floor_at(point.column));
            }
            backward.as_mut().expect("backward buffer row initialized")
        };
        if cursor.reverse.is_none() {
            cursor.text.floor_forward(&mut cursor.forward, point.column);
            cursor.reverse = Some(cursor.forward.boundary.clone());
        }
        let boundary = cursor
            .reverse
            .as_mut()
            .expect("buffer boundary initialized");
        cursor.text.retreat_to(boundary, point.column);
        Point::new(point.row, boundary.byte())
    }

    fn buffer_row_cursor(&self, row: u32) -> BufferRowCursor<'a> {
        let text = self.buffer_row(row);
        let forward = text.forward_cursor();
        BufferRowCursor {
            row,
            text,
            forward,
            reverse: None,
        }
    }

    fn buffer_row(&self, row: u32) -> RowText<'a> {
        let buffer = self.snapshot.buffer_snapshot();
        let length = buffer.line_len(MultiBufferRow(row));
        let range = Point::new(row, 0)..Point::new(row, length);
        let summary = buffer.text_summary_for_range::<MBTextSummary, _>(range.clone());
        if summary.len.0 == summary.chars {
            RowText::Ascii(length)
        } else {
            RowText::new(length, buffer.text_for_range(range))
        }
    }

    fn row(&self, row: u32) -> RowText<'a> {
        let tabs = self.snapshot.tab_snapshot();
        let folds = self.snapshot.fold_snapshot();
        let summary = folds.text_summary_for_range(
            FoldPoint::new(row, 0)..FoldPoint::new(row, folds.line_len(row)),
        );
        let length = tabs.line_len(row);
        if summary.len.0 == summary.chars {
            RowText::Ascii(length)
        } else {
            let chunks = tabs
                .chunks(
                    TabPoint::new(row, 0)..TabPoint::new(row, length),
                    LanguageAwareStyling {
                        tree_sitter: false,
                        diagnostics: false,
                    },
                    Highlights::default(),
                )
                .map(|chunk| (chunk.text, chunk.is_tab));
            RowText::with_tabs(length, chunks)
        }
    }
}

enum RowText<'a> {
    Ascii(u32),
    Unicode(RowChunks<'a>),
}

struct RowChunks<'a> {
    length: u32,
    chunks: Vec<TextChunk<'a>>,
    remaining: Box<dyn Iterator<Item = (&'a str, bool)> + 'a>,
    #[cfg(test)]
    context_bytes: usize,
}

#[derive(Clone, Copy)]
struct TextChunk<'a> {
    start: usize,
    text: &'a str,
}

#[derive(Clone)]
struct BoundaryCursor {
    graphemes: GraphemeCursor,
    chunk_index: usize,
}

struct ForwardCursor {
    boundary: BoundaryCursor,
    next: BoundaryCursor,
    column: u32,
}

struct BufferRowCursor<'a> {
    row: u32,
    text: RowText<'a>,
    forward: ForwardCursor,
    reverse: Option<BoundaryCursor>,
}

#[derive(Clone, Copy, PartialEq, Eq)]
enum BoundaryQuery {
    Next,
    Previous,
    Check,
}

impl<'a> RowText<'a> {
    fn new(length: u32, chunks: impl Iterator<Item = &'a str> + 'a) -> Self {
        Self::with_tabs(length, chunks.map(|text| (text, false)))
    }

    fn with_tabs(length: u32, chunks: impl Iterator<Item = (&'a str, bool)> + 'a) -> Self {
        Self::Unicode(RowChunks {
            length,
            chunks: Vec::new(),
            remaining: Box::new(chunks),
            #[cfg(test)]
            context_bytes: 0,
        })
    }

    fn cursor(&self, byte: u32) -> BoundaryCursor {
        let length = match self {
            Self::Ascii(length) => *length,
            Self::Unicode(chunks) => chunks.length,
        };
        BoundaryCursor {
            graphemes: GraphemeCursor::new(byte.min(length) as usize, length as usize, true),
            chunk_index: 0,
        }
    }

    fn forward_cursor(&self) -> ForwardCursor {
        let boundary = self.cursor(0);
        ForwardCursor {
            next: boundary.clone(),
            boundary,
            column: 0,
        }
    }

    fn floor_forward(&mut self, cursor: &mut ForwardCursor, byte: u32) {
        debug_assert!(byte >= cursor.boundary.byte());
        if let Self::Ascii(length) = self {
            cursor.column = byte.min(*length);
            cursor.boundary.graphemes.set_cursor(cursor.column as usize);
            return;
        }
        while cursor.boundary.byte() < byte {
            if cursor.next.byte() == cursor.boundary.byte()
                && self.next_boundary(&mut cursor.next).is_none()
            {
                break;
            }
            if cursor.next.byte() > byte {
                break;
            }
            cursor.boundary = cursor.next.clone();
            cursor.column += 1;
        }
    }

    #[cfg(test)]
    fn columns_for_bytes(&mut self, bytes: Range<u32>) -> Range<u32> {
        let mut cursor = self.forward_cursor();
        self.floor_forward(&mut cursor, bytes.start);
        let start = cursor.column;
        self.floor_forward(&mut cursor, bytes.end);
        start..cursor.column
    }

    fn advance_columns(&mut self, cursor: &mut BoundaryCursor, count: u32) {
        if let Self::Ascii(length) = self {
            cursor
                .graphemes
                .set_cursor(cursor.byte().saturating_add(count).min(*length) as usize);
        } else {
            for _ in 0..count {
                if self.next_boundary(cursor).is_none() {
                    break;
                }
            }
        }
    }

    fn floor_at(&mut self, byte: u32) -> BoundaryCursor {
        let mut cursor = self.cursor(byte);
        if let Self::Unicode(chunks) = self
            && cursor.byte() > 0
            && cursor.byte() < chunks.length
        {
            cursor.chunk_index = chunks.locate(cursor.byte() as usize);
            let chunk = chunks.chunk(cursor.chunk_index);
            let mut offset = cursor.byte() as usize - chunk.start;
            while !chunk.text.is_char_boundary(offset) {
                offset -= 1;
            }
            cursor.graphemes.set_cursor(chunk.start + offset);
            if chunks.resolve(&mut cursor, BoundaryQuery::Check).is_none() {
                chunks
                    .resolve(&mut cursor, BoundaryQuery::Previous)
                    .expect("non-boundary has a preceding boundary");
            }
        }
        cursor
    }

    fn retreat_to(&mut self, cursor: &mut BoundaryCursor, byte: u32) {
        if let Self::Ascii(_) = self {
            cursor
                .graphemes
                .set_cursor(cursor.byte().min(byte) as usize);
        } else {
            while cursor.byte() > byte {
                if self.previous_boundary(cursor).is_none() {
                    break;
                }
            }
        }
    }

    fn next_boundary(&mut self, cursor: &mut BoundaryCursor) -> Option<u32> {
        match self {
            Self::Ascii(length) => {
                if cursor.byte() >= *length {
                    return None;
                }
                cursor.graphemes.set_cursor(cursor.byte() as usize + 1);
                Some(cursor.byte())
            }
            Self::Unicode(chunks) => chunks.resolve(cursor, BoundaryQuery::Next),
        }
    }

    fn previous_boundary(&mut self, cursor: &mut BoundaryCursor) -> Option<u32> {
        match self {
            Self::Ascii(_) => {
                let byte = cursor.byte().checked_sub(1)?;
                cursor.graphemes.set_cursor(byte as usize);
                Some(byte)
            }
            Self::Unicode(chunks) => chunks.resolve(cursor, BoundaryQuery::Previous),
        }
    }
}

impl<'a> RowChunks<'a> {
    fn chunk(&mut self, index: usize) -> TextChunk<'a> {
        const TAB_CHARACTERS: [u8; 128] = [b'\t'; 128];
        while self.chunks.len() <= index {
            let (text, is_tab) = self
                .remaining
                .find(|(text, _)| !text.is_empty())
                .expect("row chunks must cover the row");
            let text = if is_tab {
                std::str::from_utf8(&TAB_CHARACTERS[..text.len()]).expect("tab controls are UTF-8")
            } else {
                text
            };
            let start = self
                .chunks
                .last()
                .map_or(0, |chunk| chunk.start + chunk.text.len());
            self.chunks.push(TextChunk { start, text });
            #[cfg(test)]
            tests::ROW_WORK.with(|work| {
                let (boundaries, chunks) = work.get();
                work.set((boundaries, chunks + 1));
            });
        }
        self.chunks[index]
    }

    fn locate(&mut self, byte: usize) -> usize {
        while self
            .chunks
            .last()
            .is_none_or(|chunk| chunk.start + chunk.text.len() <= byte)
        {
            self.chunk(self.chunks.len());
        }
        self.chunks.partition_point(|chunk| chunk.start <= byte) - 1
    }

    fn resolve(&mut self, cursor: &mut BoundaryCursor, query: BoundaryQuery) -> Option<u32> {
        #[cfg(test)]
        tests::ROW_WORK.with(|work| {
            let (boundaries, chunks) = work.get();
            work.set((boundaries + 1, chunks));
        });
        loop {
            let offset = cursor.graphemes.cur_cursor();
            if query == BoundaryQuery::Check && (offset == 0 || offset == self.length as usize) {
                return Some(offset as u32);
            }
            if (query == BoundaryQuery::Next && offset == self.length as usize)
                || (query == BoundaryQuery::Previous && offset == 0)
            {
                return None;
            }
            let chunk = loop {
                let chunk = self.chunk(cursor.chunk_index);
                if offset < chunk.start
                    || (query == BoundaryQuery::Previous && offset == chunk.start)
                {
                    cursor.chunk_index -= 1;
                } else if offset > chunk.start + chunk.text.len()
                    || (query != BoundaryQuery::Previous
                        && offset == chunk.start + chunk.text.len())
                {
                    cursor.chunk_index += 1;
                } else {
                    break chunk;
                }
            };
            let mut bridge = [0; 8];
            let (text, start) =
                if query != BoundaryQuery::Previous && offset == chunk.start && offset > 0 {
                    let previous = self.chunk(cursor.chunk_index - 1);
                    let previous = previous.text.chars().next_back().expect("nonempty chunk");
                    let following = chunk.text.chars().next().expect("nonempty chunk");
                    let previous_length = previous.encode_utf8(&mut bridge).len();
                    let following_length =
                        following.encode_utf8(&mut bridge[previous_length..]).len();
                    (
                        std::str::from_utf8(&bridge[..previous_length + following_length])
                            .expect("encoded scalars are UTF-8"),
                        offset - previous_length,
                    )
                } else {
                    (chunk.text, chunk.start)
                };
            loop {
                let result = match query {
                    BoundaryQuery::Next => cursor.graphemes.next_boundary(text, start),
                    BoundaryQuery::Previous => cursor.graphemes.prev_boundary(text, start),
                    BoundaryQuery::Check => cursor
                        .graphemes
                        .is_boundary(text, start)
                        .map(|boundary| boundary.then_some(cursor.graphemes.cur_cursor())),
                };
                match result {
                    Ok(boundary) => return boundary.map(|byte| byte as u32),
                    Err(GraphemeIncomplete::PreContext(end)) => {
                        let index = self.locate(end - 1);
                        let context = self.chunk(index);
                        let context_text = &context.text[..end - context.start];
                        #[cfg(test)]
                        {
                            self.context_bytes += context_text.len();
                        }
                        cursor
                            .graphemes
                            .provide_context(context_text, context.start);
                    }
                    Err(GraphemeIncomplete::NextChunk | GraphemeIncomplete::PrevChunk) => break,
                    Err(error) => unreachable!("row grapheme cursor: {error:?}"),
                }
            }
        }
    }
}

impl BoundaryCursor {
    fn byte(&self) -> u32 {
        self.graphemes.cur_cursor() as u32
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{
        AddSelectionAbove, AddSelectionBelow, SelectionEffects,
        display_map::{
            BlockPlacement, BlockProperties, BlockStyle, Crease, DisplayMap, FoldPlaceholder,
        },
        inlays::Inlay,
        test::{editor_test_context::EditorTestContext, test_font},
    };
    use collections::HashSet;
    use gpui::{
        AppContext as _, BorrowAppContext as _, Element as _, Entity, Pixels, SharedString,
        TestAppContext, div, px,
    };
    use language::{Buffer, Capability};
    use multi_buffer::{Anchor, ExcerptRange, MultiBuffer, MultiBufferOffset, PathKey};
    use project::project_settings::DiagnosticSeverity;
    use rand::prelude::*;
    use settings::SettingsStore;
    use std::{cell::Cell, env, iter, num::NonZeroU32, sync::Arc};
    use theme::LoadThemes;
    use unicode_segmentation::UnicodeSegmentation as _;

    thread_local! {
        pub(super) static ROW_WORK: Cell<(usize, usize)> = const { Cell::new((0, 0)) };
    }

    #[gpui::test]
    async fn test_columnar_selection_actions_batch_work(cx: &mut TestAppContext) {
        crate::editor_tests::init_test(cx, |_| {});
        let mut cx = EditorTestContext::new(cx).await;
        let rows = [("é.", 3, 2), ("e\u{301}.", 4, 3), ("🦀.", 5, 4)];
        for count in [32, 128] {
            let text = rows
                .iter()
                .map(|(unit, _, _)| unit.repeat(count))
                .collect::<Vec<_>>()
                .join("\n");
            for above in [false, true] {
                for (nonempty, reversed) in [(false, false), (true, false), (true, true)] {
                    let indices = if nonempty { 0..count } else { 1..count + 1 };
                    let expected = |added| {
                        rows.iter()
                            .enumerate()
                            .filter(|(row, _)| {
                                if above {
                                    *row >= 2 - added
                                } else {
                                    *row <= added
                                }
                            })
                            .flat_map(|(row, &(_, stride, width))| {
                                separated_columnar_ranges(
                                    row as u32,
                                    indices.clone(),
                                    stride,
                                    if nonempty { width } else { 0 },
                                    reversed,
                                )
                            })
                            .collect::<Vec<_>>()
                    };
                    set_columnar_action_state(&mut cx, &text, &expected(0));
                    for (direction, added) in [
                        (above, 1),
                        (above, 2),
                        (above, 2),
                        (!above, 1),
                        (!above, 0),
                        (above, 1),
                    ] {
                        let expected = expected(added);
                        assert_eq!(expected.len(), (added + 1) * count);
                        assert_columnar_action_work(&mut cx, direction, &expected, 4 * (2 * count));
                    }
                }
            }
        }
    }

    #[gpui::test]
    async fn test_columnar_selection_actions_join_skipped_rows_work(cx: &mut TestAppContext) {
        crate::editor_tests::init_test(cx, |_| {});
        let mut cx = EditorTestContext::new(cx).await;
        for count in [32, 128] {
            for above in [false, true] {
                let row = |row| if above { 6 - row } else { row };
                let mut lines = [
                    "é.".repeat(count + 1),
                    "é".to_owned(),
                    "e\u{301}.".repeat(count / 2 + 1),
                    String::new(),
                    "🦀.".to_owned(),
                    "🦀.".repeat(count + 1),
                    "e\u{301}.".repeat(count + 1),
                ];
                if above {
                    lines.reverse();
                }
                let text = lines.join("\n");
                for reversed in [false, true] {
                    let sources =
                        separated_columnar_ranges(row(0), count / 2 + 1..count + 1, 3, 2, reversed)
                            .into_iter()
                            .chain(separated_columnar_ranges(
                                row(2),
                                1..count / 2 + 1,
                                4,
                                3,
                                reversed,
                            ))
                            .collect::<Vec<_>>();
                    let expected = |added| {
                        let mut expected = sources.clone();
                        for (target, stride, width) in
                            [(5, 5, 4), (6, 4, 3)].into_iter().take(added)
                        {
                            expected.extend(separated_columnar_ranges(
                                row(target),
                                1..count + 1,
                                stride,
                                width,
                                reversed,
                            ));
                        }
                        expected.sort_unstable_by_key(|range| range.start.min(range.end));
                        expected
                    };
                    set_columnar_action_state(&mut cx, &text, &expected(0));
                    for (direction, added) in [
                        (above, 1),
                        (above, 2),
                        (above, 2),
                        (!above, 1),
                        (!above, 0),
                        (above, 1),
                    ] {
                        let expected = expected(added);
                        assert_eq!(expected.len(), (added + 1) * count);
                        assert_columnar_action_work(
                            &mut cx,
                            direction,
                            &expected,
                            5 * (2 * (count + 1)),
                        );
                    }
                }
            }
        }
    }

    #[gpui::test]
    async fn test_columnar_selection_actions_skip_replaced_source_rows(cx: &mut TestAppContext) {
        crate::editor_tests::init_test(cx, |_| {});
        let mut cx = EditorTestContext::new(cx).await;
        for hidden_count in [1, 128] {
            let text = iter::repeat_n("éab", hidden_count as usize + 3)
                .collect::<Vec<_>>()
                .join("\n");
            for above in [false, true] {
                let row = |row| if above { hidden_count + 2 - row } else { row };
                for ends_inside_replacement in [false, true] {
                    let end_row = hidden_count + u32::from(!ends_inside_replacement);
                    let source = Point::new(row(0).min(row(end_row)), 2)
                        ..Point::new(row(0).max(row(end_row)), 3);
                    set_columnar_action_state(&mut cx, &text, &[source]);
                    let blocks = cx.update_editor(|editor, _, cx| {
                        let buffer = editor.buffer.read(cx).snapshot(cx);
                        editor.insert_blocks(
                            [BlockProperties {
                                placement: BlockPlacement::Replace(
                                    buffer
                                        .anchor_after(Point::new(row(1).min(row(hidden_count)), 0))
                                        ..=buffer.anchor_before(Point::new(
                                            row(1).max(row(hidden_count)),
                                            4,
                                        )),
                                ),
                                height: Some(1),
                                style: BlockStyle::Fixed,
                                render: Arc::new(|_| div().into_any()),
                                priority: 0,
                            }],
                            None,
                            cx,
                        )
                    });
                    let mut expected = [0, hidden_count + 1, hidden_count + 2]
                        .into_iter()
                        .take(if ends_inside_replacement { 2 } else { 3 })
                        .map(|source_row| {
                            Point::new(row(source_row), 2)..Point::new(row(source_row), 3)
                        })
                        .collect::<Vec<_>>();
                    expected.sort_unstable_by_key(|range| range.start);
                    assert_columnar_action_work(&mut cx, above, &expected, 32);
                    cx.update_editor(|editor, _, cx| {
                        editor.remove_blocks(blocks.into_iter().collect(), None, cx);
                    });
                }
            }
        }
    }

    #[gpui::test]
    fn test_columnar_selection_batch_work(cx: &mut TestAppContext) {
        init_test(cx);
        let length = 4096;
        let line = "é".repeat(length);
        let snapshot = plain_state(&format!("{line}\n{line}"), cx)
            .build_map(cx)
            .update(cx, |map, cx| map.snapshot(cx));
        let mut query = ColumnarSelectionRows::new(&snapshot);
        let mut ranges = (0..length as u32)
            .flat_map(|column| {
                (0..2)
                    .map(move |row| Point::new(row, column * 2)..Point::new(row, length as u32 * 2))
            })
            .collect::<Vec<_>>();
        let mut expected_columns = (0..length as u32)
            .flat_map(|column| [column..length as u32, column..length as u32])
            .collect::<Vec<_>>();
        for _ in 0..2 {
            ROW_WORK.set((0, 0));
            let answers = query.columns_for_ranges(&ranges);
            assert_eq!(answers.len(), expected_columns.len());
            for (index, (answer, expected)) in answers.iter().zip(&expected_columns).enumerate() {
                assert_eq!(answer, expected, "range {index}");
            }
            let (boundaries, chunks) = ROW_WORK.get();
            assert_eq!(boundaries, 2 * length);
            assert!(chunks <= 2 * length);
            ranges.reverse();
            expected_columns.reverse();
        }
        let requests = (0..length as u32)
            .flat_map(|column| (0..2).map(move |row| (row, column..length as u32)))
            .collect::<Vec<_>>();
        let expected_points = (0..length as u32)
            .flat_map(|column| {
                (0..2).map(move |row| {
                    Some((
                        Point::new(row, column * 2),
                        Point::new(row, length as u32 * 2),
                    ))
                })
            })
            .collect::<Vec<_>>();
        assert_batch_points(&mut query, requests, expected_points, 4 * length);
        assert_eq!(query.columns_for_ranges(&[]), Vec::new());
        assert_eq!(query.points_for_rows(&[]), Vec::new());
    }

    #[gpui::test]
    fn test_columnar_selection_batch_fold_projection(cx: &mut TestAppContext) {
        init_test(cx);
        let length = 128;
        let prefix = "é".repeat(length);
        let indicators = "🇦".repeat(length);
        let mut state = plain_state(&format!("{prefix}\n{indicators}\n{indicators}"), cx);
        let buffer = state.buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
        state.folds = vec![
            buffer.anchor_after(Point::new(0, length as u32 * 2))
                ..buffer.anchor_before(Point::new(1, 4)),
            buffer.anchor_after(Point::new(1, length as u32 * 4))
                ..buffer.anchor_before(Point::new(2, 4)),
        ];
        let snapshot = state.build_map(cx).update(cx, |map, cx| map.snapshot(cx));
        let visible_indicators = "🇦".repeat(length - 1);
        assert_eq!(
            snapshot.tab_snapshot().text(),
            format!("{prefix}⋯{visible_indicators}⋯{visible_indicators}")
        );
        let end_column = length as u32 * 2 + 2;
        let end = Point::new(2, length as u32 * 4);
        let requests = (0..=end_column)
            .flat_map(|column| [(0, column..column), (0, column..end_column)])
            .collect::<Vec<_>>();
        let expected = (0..=end_column)
            .flat_map(|column| {
                let point = if column <= length as u32 {
                    Point::new(0, column * 2)
                } else if column <= length as u32 * 3 / 2 {
                    Point::new(0, length as u32 * 2)
                } else if column < end_column {
                    Point::new(1, length as u32 * 4)
                } else {
                    end
                };
                [Some((point, point)), Some((point, end))]
            })
            .collect::<Vec<_>>();
        let mut query = ColumnarSelectionRows::new(&snapshot);
        assert_batch_points(&mut query, requests, expected, 16 * length);
    }

    #[gpui::test]
    fn test_columnar_selection_batch_rejects_before_end(cx: &mut TestAppContext) {
        init_test(cx);
        let mut state = plain_state("x\né\n", cx);
        let buffer = state.buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
        state.inlays.push(Inlay::mock_hint(
            0,
            buffer.anchor_before(Point::new(1, 0)),
            &format!("é{}\n", "a".repeat(1_048_576)),
        ));
        let snapshot = state.build_map(cx).update(cx, |map, cx| map.snapshot(cx));
        let mut query = ColumnarSelectionRows::new(&snapshot);
        let mut requests = vec![(1, 0..u32::MAX); 4096];
        requests.extend([(2, 1..u32::MAX), (0, 2..u32::MAX), (u32::MAX, 0..0)]);
        for _ in 0..2 {
            ROW_WORK.set((0, 0));
            assert_eq!(query.points_for_rows(&requests), vec![None; requests.len()]);
            assert_eq!(ROW_WORK.get(), (1, 1));
            requests.reverse();
        }
    }

    #[gpui::test]
    fn test_columnar_selection_batch_virtual_frontier_work(cx: &mut TestAppContext) {
        init_test(cx);
        for (folded, length, prefix_length) in [(false, 4096, 1), (true, 64, 1), (true, 4096, 256)]
        {
            let prefix = "a".repeat(prefix_length);
            let placeholder = "é".repeat(length);
            let point = Point::new(0, prefix_length as u32);
            let mut state = plain_state(&format!("{prefix}xb"), cx);
            if !folded {
                let buffer = state.buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
                state.inlays.push(Inlay::mock_hint(
                    0,
                    buffer.anchor_after(point),
                    &placeholder,
                ));
            }
            let map = state.build_map(cx);
            if folded {
                map.update(cx, |map, cx| {
                    map.fold(
                        vec![Crease::simple(
                            point..Point::new(0, point.column + 1),
                            FoldPlaceholder {
                                collapsed_text: Some(SharedString::from(placeholder.clone())),
                                ..FoldPlaceholder::test()
                            },
                        )],
                        cx,
                    )
                });
            }
            let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
            assert_eq!(
                snapshot.tab_snapshot().text(),
                if folded {
                    format!("{prefix}{placeholder}b")
                } else {
                    format!("{prefix}{placeholder}xb")
                }
            );
            let end = point.column + length as u32 - 1;
            let requests = (point.column..=end)
                .flat_map(|column| [(0, column..column), (0, column..end)])
                .collect::<Vec<_>>();
            let expected = vec![Some((point, point)); requests.len()];
            assert_batch_points(
                &mut ColumnarSelectionRows::new(&snapshot),
                requests,
                expected,
                8 * length,
            );
        }
    }

    #[gpui::test]
    fn test_columnar_selection_batch_frontier_across_original_rows(
        cx: &mut TestAppContext,
        mut rng: StdRng,
    ) {
        init_test(cx);
        let lines = [
            "ééé",
            "🇦🇶🇦🇶🇦🇶🇦",
            "🇦🇶🇦🇶🇦🇶🇦🇶",
            "\t\u{301}界",
            "\u{600}e\u{301}",
            "👩🏽\u{200d}💻",
            "क्\u{200d}ष",
            "\u{1100}\u{1161}\u{11a8}",
            "\u{301}\u{301}",
            "a\0\u{200b}b",
            "é界🏀",
            "✈\u{fe0f}1\u{fe0f}\u{20e3}",
            "का",
            "",
        ];
        for tab_size in [1, 128] {
            set_tab_size(tab_size, cx);
            for bias in [None, Some(Bias::Left), Some(Bias::Right)] {
                let mut state = plain_state(&lines.join("\n"), cx);
                let buffer = state.buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
                for (row, line) in lines.iter().enumerate().skip(1) {
                    let Some(first) = line.chars().next() else {
                        continue;
                    };
                    let point = Point::new(row as u32, first.len_utf8() as u32);
                    if row % 4 != 0 {
                        state.folds.push(
                            buffer.anchor_after(Point::new(
                                row as u32 - 1,
                                lines[row - 1].len() as u32,
                            ))..buffer.anchor_before(point),
                        );
                    }
                    if let Some(bias) = bias {
                        state.inlays.push(Inlay::mock_hint(
                            row,
                            buffer.anchor_at(point, bias),
                            ["🇶", "\u{301}", "\t\n\u{600}"][row % 3],
                        ));
                    }
                }
                let snapshot = state.build_map(cx).update(cx, |map, cx| map.snapshot(cx));
                let expanded = snapshot
                    .fold_snapshot()
                    .text()
                    .split('\n')
                    .map(|line| plain_row(line, tab_size))
                    .collect::<Vec<_>>();
                assert_eq!(
                    snapshot.tab_snapshot().text(),
                    expanded
                        .iter()
                        .map(|row| row.text.as_str())
                        .collect::<Vec<_>>()
                        .join("\n")
                );
                let raw = snapshot.buffer_snapshot().text();
                let candidates = expanded
                    .iter()
                    .enumerate()
                    .map(|(row, expanded)| {
                        enumerated_points(&snapshot, &raw, row as u32, &expanded.boundaries)
                    })
                    .collect::<Vec<_>>();
                let mut requests = expanded
                    .iter()
                    .enumerate()
                    .flat_map(|(row, expanded)| {
                        (0..=expanded.len + 1)
                            .chain(iter::once(u32::MAX))
                            .flat_map(move |start| {
                                [0, start, start.saturating_add(1), expanded.len, u32::MAX]
                                    .map(|end| (row as u32, start..end))
                            })
                    })
                    .collect::<Vec<_>>();
                requests.extend([(u32::MAX, 0..0), (expanded.len() as u32, 0..1)]);
                requests.extend_from_within(..);
                requests.shuffle(&mut rng);
                let mut query = ColumnarSelectionRows::new(&snapshot);
                for _ in 0..4 {
                    let answers = query.points_for_rows(&requests);
                    assert_eq!(answers.len(), requests.len());
                    for ((row, columns), answer) in requests.iter().zip(answers) {
                        let expected = expanded.get(*row as usize).and_then(|expanded| {
                            nearest_points(columns, expanded.len, &candidates[*row as usize])
                        });
                        assert_eq!(
                            answer, expected,
                            "tab size {tab_size}, bias {bias:?}, row {row}, columns {columns:?}"
                        );
                    }
                    requests.reverse();
                    requests = requests.into_iter().step_by(7).collect();
                }
                let points = lines
                    .iter()
                    .enumerate()
                    .flat_map(|(row, line)| {
                        scalar_boundaries(line)
                            .into_iter()
                            .map(move |byte| Point::new(row as u32, byte as u32))
                    })
                    .collect::<Vec<_>>();
                let mut ranges = points
                    .iter()
                    .flat_map(|start| points.iter().map(move |end| *start..*end))
                    .collect::<Vec<_>>();
                ranges.extend_from_within(..);
                ranges.shuffle(&mut rng);
                let answers = query.columns_for_ranges(&ranges);
                assert_eq!(answers.len(), ranges.len());
                for (range, answer) in ranges.iter().zip(answers) {
                    let column = |point| {
                        let tab = snapshot
                            .tab_snapshot()
                            .point_to_tab_point(point, Bias::Left);
                        expanded[tab.row() as usize]
                            .boundaries
                            .partition_point(|byte| *byte <= tab.column() as usize)
                            as u32
                            - 1
                    };
                    let start = column(range.start);
                    let end = column(range.end);
                    assert_eq!(
                        answer,
                        start.min(end)..start.max(end),
                        "tab size {tab_size}, bias {bias:?}, source {range:?}"
                    );
                }
            }
        }
    }

    #[test]
    fn test_column_boundaries_across_chunks() {
        for (text, expected) in [
            ("", vec![0]),
            ("abc", vec![0, 1, 2, 3]),
            ("e\u{301}x", vec![0, 3, 4]),
            ("\u{301}\u{301}x", vec![0, 4, 5]),
            ("👩\u{200d}💻x", vec![0, 11, 12]),
            ("🇦🇶🇦🇶🇦x", vec![0, 8, 16, 20, 21]),
            ("क्\u{200d}षx", vec![0, 12, 13]),
            ("\r\nx", vec![0, 2, 3]),
            ("\u{600}🇦🇶🇦x", vec![0, 10, 14, 15]),
            ("🇦\u{301}🇶🇦x", vec![0, 6, 14, 15]),
        ] {
            for split in scalar_boundaries(text) {
                let mut query = RowText::new(
                    text.len() as u32,
                    ["", &text[..split], "", &text[split..], ""].into_iter(),
                );
                assert_row_boundaries(&mut query, &expected);
            }
            let boundaries = scalar_boundaries(text);
            let mut query = RowText::new(
                text.len() as u32,
                boundaries.windows(2).map(|range| &text[range[0]..range[1]]),
            );
            assert_row_boundaries(&mut query, &expected);
            for start in 0..=text.len() {
                for end in start..=text.len() {
                    assert_eq!(
                        query.columns_for_bytes(start as u32..end as u32),
                        (expected.partition_point(|boundary| *boundary <= start) - 1) as u32
                            ..(expected.partition_point(|boundary| *boundary <= end) - 1) as u32,
                        "{text:?}, range {start}..{end}"
                    );
                }
            }
        }
    }

    #[test]
    fn test_column_boundaries_tab_chunks() {
        let prefix = "\u{600}";
        let suffix = "\u{301}e\u{301}👩\u{200d}💻🇦🇶\0\u{200b}x";
        for width in [1, 4, 128] {
            let spaces = " ".repeat(width);
            let suffix_start = prefix.len() + width;
            let len = suffix_start + suffix.len();
            let expected = iter::once(0)
                .chain(prefix.len()..=suffix_start)
                .chain([2, 5, 16, 24, 25, 28, 29].map(|offset| suffix_start + offset))
                .collect::<Vec<_>>();
            for tab_split in 0..=width {
                for split in scalar_boundaries(suffix) {
                    let mut query = RowText::with_tabs(
                        len as u32,
                        [
                            (prefix, false),
                            (&spaces[..tab_split], true),
                            ("", false),
                            (&spaces[tab_split..], true),
                            (&suffix[..split], false),
                            ("", true),
                            (&suffix[split..], false),
                        ]
                        .into_iter(),
                    );
                    assert_row_boundaries(&mut query, &expected);
                }
            }
        }
    }

    #[test]
    fn test_column_boundaries_tab_before_large_grapheme() {
        let suffix = format!("{}z", "\u{301}".repeat(1_048_576));
        let mut query = RowText::with_tabs(
            4 + suffix.len() as u32,
            [("    ", true), (suffix.as_str(), false)].into_iter(),
        );
        let mut cursor = query.cursor(0);
        query.advance_columns(&mut cursor, 4);
        assert_eq!(cursor.byte(), 4);
        let RowText::Unicode(chunks) = &query else {
            panic!("Unicode row")
        };
        assert_eq!(chunks.chunks.len(), 2);
        assert_eq!(chunks.chunks[1].text.as_ptr(), suffix.as_ptr());
        assert_eq!(chunks.context_bytes, 0);
        assert_eq!(query.next_boundary(&mut cursor), Some(2_097_156));
        assert_eq!(query.next_boundary(&mut cursor), Some(2_097_157));
        assert_eq!(query.columns_for_bytes(2_097_155..2_097_155), 4..4);
        query.retreat_to(&mut cursor, 2_097_155);
        assert_eq!(cursor.byte(), 4);
    }

    #[test]
    fn test_row_cursor_forks_and_reverse_floors() {
        let text = "🇦🇶🇦🇶🇦e\u{301}👩\u{200d}💻क्\u{200d}षz";
        let expected = [0, 8, 16, 20, 23, 34, 46, 47];
        let boundaries = scalar_boundaries(text);
        let mut query = RowText::new(
            text.len() as u32,
            boundaries.windows(2).map(|range| &text[range[0]..range[1]]),
        );
        assert_row_boundaries(&mut query, &expected);
        let mut forward = query.cursor(0);
        for pair in expected.windows(2) {
            assert_eq!(forward.byte(), pair[0] as u32);
            let mut backward = forward.clone();
            for byte in (0..pair[0]).rev() {
                query.retreat_to(&mut backward, byte as u32);
                let index = expected.partition_point(|boundary| *boundary <= byte) - 1;
                assert_eq!(backward.byte(), expected[index] as u32);
            }
            assert_eq!(query.next_boundary(&mut forward), Some(pair[1] as u32));
            assert_eq!(backward.byte(), 0);
        }
    }

    #[test]
    fn test_row_cursor_giant_split_clusters() {
        for text in [
            format!("e{}z", "\u{301}".repeat(4096)),
            format!("👩{}\u{200d}💻z", "\u{301}".repeat(4096)),
            format!("क{}षz", "्\u{200d}".repeat(4096)),
        ] {
            let boundaries = scalar_boundaries(&text);
            let mut query = RowText::new(
                text.len() as u32,
                boundaries.windows(2).map(|range| &text[range[0]..range[1]]),
            );
            let end = text.len() as u32;
            let mut cursor = query.cursor(0);
            assert_eq!(query.next_boundary(&mut cursor), Some(end - 1));
            let mut fork = cursor.clone();
            assert_eq!(query.next_boundary(&mut cursor), Some(end));
            assert_eq!(query.previous_boundary(&mut fork), Some(0));
            for byte in [1, end / 2, end - 2] {
                assert_eq!(query.floor_at(byte).byte(), 0);
            }
            assert_eq!(query.floor_at(end - 1).byte(), end - 1);
            assert_eq!(query.previous_boundary(&mut cursor), Some(end - 1));
            assert_eq!(query.previous_boundary(&mut cursor), Some(0));
            let RowText::Unicode(chunks) = &query else {
                panic!("Unicode row")
            };
            assert_eq!(chunks.chunks.len(), boundaries.len() - 1);
            assert_eq!(chunks.chunks[0].text.as_ptr(), text.as_ptr());
        }
    }

    #[test]
    fn test_row_cursor_lazy_polling() {
        let suffix = format!("{}é", "a".repeat(1_048_576));
        let polls = Cell::new(0);
        let chunks = ["éabc", suffix.as_str()].into_iter().inspect(|_| {
            polls.set(polls.get() + 1);
        });
        let mut query = RowText::new(5 + suffix.len() as u32, chunks);
        assert_eq!(query.columns_for_bytes(0..0), 0..0);
        assert_eq!(query.floor_at(0).byte(), 0);
        let mut cursor = query.cursor(0);
        query.advance_columns(&mut cursor, 0);
        assert_eq!(polls.get(), 0);
        query.advance_columns(&mut cursor, 2);
        assert_eq!(cursor.byte(), 3);
        assert_eq!(polls.get(), 1);
        let mut fork = cursor.clone();
        query.retreat_to(&mut fork, 1);
        assert_eq!(fork.byte(), 0);
        assert_eq!(query.next_boundary(&mut cursor), Some(4));
        assert_eq!(polls.get(), 1);
        assert_eq!(query.columns_for_bytes(0..2), 0..1);
        assert_eq!(polls.get(), 1);
        let RowText::Unicode(chunks) = &query else {
            panic!("Unicode row")
        };
        assert_eq!(chunks.chunks.len(), 1);
        assert_eq!(chunks.context_bytes, 0);
    }

    #[test]
    fn test_row_cursor_reverse_regional_context_is_linear() {
        for symbols in [127, 128, 1023, 1024, 8191, 8192] {
            let text = "🇦".repeat(symbols);
            for chunk_symbols in [1, 2, 7, symbols] {
                for end in [text.len(), text.len() - 1, text.len() - 4] {
                    let chunks = text.as_bytes().chunks(4 * chunk_symbols).map(|chunk| {
                        std::str::from_utf8(chunk).expect("regional indicator chunks")
                    });
                    let mut query = RowText::new(text.len() as u32, chunks);
                    let mut cursor = query.floor_at(end as u32);
                    assert_eq!(
                        cursor.byte(),
                        if end == text.len() { end } else { end / 8 * 8 } as u32
                    );
                    let mut expected = cursor.byte();
                    while expected > 0 {
                        expected = (expected - 1) / 8 * 8;
                        assert_eq!(query.previous_boundary(&mut cursor), Some(expected));
                    }
                    assert_eq!(query.previous_boundary(&mut cursor), None);
                    let RowText::Unicode(chunks) = &query else {
                        panic!("Unicode row")
                    };
                    if chunk_symbols == 1 {
                        assert!(chunks.context_bytes > 0);
                    }
                    assert!(
                        chunks.context_bytes <= text.len() * 2,
                        "symbols {symbols}, chunk symbols {chunk_symbols}, end {end}, context bytes {}",
                        chunks.context_bytes
                    );
                }
            }
        }
    }

    #[gpui::test]
    fn test_columnar_selection_right_inlay_shifts_regional_parity(cx: &mut TestAppContext) {
        init_test(cx);
        for symbols in [4, 64, 8192] {
            let text = format!("{}z", "🇦".repeat(symbols));
            let mut state = plain_state(&text, cx);
            let buffer = state.buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
            state
                .inlays
                .push(Inlay::mock_hint(0, buffer.anchor_after(Point::zero()), "🇶"));
            let snapshot = state.build_map(cx).update(cx, |map, cx| map.snapshot(cx));
            assert_eq!(snapshot.tab_snapshot().text(), format!("🇶{text}"));
            let mut query = ColumnarSelectionRows::new(&snapshot);
            let last_flag = symbols as u32 / 2;
            let requests = (1..=last_flag)
                .flat_map(|column| [(0, column..column), (0, column..last_flag + 1)])
                .collect::<Vec<_>>();
            let end = Point::new(0, symbols as u32 * 4);
            let expected = (1..=last_flag)
                .flat_map(|_| {
                    [
                        Some((Point::zero(), Point::zero())),
                        Some((Point::zero(), end)),
                    ]
                })
                .collect::<Vec<_>>();
            assert_batch_points(&mut query, requests, expected, 8 * symbols);
            assert_eq!(
                query.points_for_row(0, &(last_flag..last_flag + 1)),
                Some((Point::zero(), end))
            );
            assert_eq!(
                query.points_for_row(0, &(last_flag + 1..last_flag + 1)),
                Some((end, end))
            );
        }
    }

    #[gpui::test]
    fn test_columnar_selection_tab_control_boundaries(cx: &mut TestAppContext) {
        init_test(cx);
        let expected = plain_row("\t\u{301}x", 4);
        assert_eq!(expected.text, "    \u{301}x");
        assert_eq!(expected.len, 6);
        assert_eq!(expected.columns, [(0, 0), (1, 4), (3, 5), (4, 6)]);
        assert_eq!(expected.points, [(0, 0), (4, 1), (5, 3), (6, 4)]);
        assert_eq!(expected.boundaries, [0, 1, 2, 3, 4, 6, 7]);
        for tab_size in [1, 2, 4, 8, 127, 128] {
            set_tab_size(tab_size, cx);
            let after_prepend_tab = 1 + tab_size - 1 % tab_size;
            for (line, endpoints) in [
                (
                    "\t\u{301}x",
                    vec![(0, 0), (1, tab_size), (3, tab_size + 1), (4, tab_size + 2)],
                ),
                (
                    "\u{600}\t\u{301}x",
                    vec![
                        (0, 0),
                        (2, 1),
                        (3, after_prepend_tab),
                        (5, after_prepend_tab + 1),
                        (6, after_prepend_tab + 2),
                    ],
                ),
            ] {
                let snapshot = plain_state(&format!("{line}\n{line}"), cx)
                    .build_map(cx)
                    .update(cx, |map, cx| map.snapshot(cx));
                let mut query = ColumnarSelectionRows::new(&snapshot);
                for source_row in [0, 1] {
                    for (index, &(start, start_column)) in endpoints.iter().enumerate() {
                        for &(end, end_column) in &endpoints[index..] {
                            for reversed in [false, true] {
                                let start_point = Point::new(source_row, start);
                                let end_point = Point::new(source_row, end);
                                let columns = query.columns_for_range(if reversed {
                                    end_point..start_point
                                } else {
                                    start_point..end_point
                                });
                                assert_eq!(columns, start_column..end_column);
                                let target_row = 1 - source_row;
                                assert_eq!(
                                    query.points_for_row(target_row, &columns),
                                    Some((
                                        Point::new(target_row, start),
                                        Point::new(target_row, end)
                                    )),
                                    "line {line:?}, tab size {tab_size}, source row {source_row}, range {start}..{end}, reversed {reversed}"
                                );
                            }
                        }
                    }
                }
                assert_plain_rows(&snapshot, tab_size);
            }
        }
    }

    #[gpui::test]
    fn test_columnar_selection_tab_control_boundaries_with_virtual_text(cx: &mut TestAppContext) {
        init_test(cx);
        let mut state = plain_state("\tQx\n\tx", cx);
        let buffer = state.buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
        state.inlays.push(Inlay::mock_hint(
            0,
            buffer.anchor_after(Point::new(1, 1)),
            "\u{301}",
        ));
        let map = state.build_map(cx);
        map.update(cx, |map, cx| {
            map.fold(
                vec![Crease::simple(
                    Point::new(0, 1)..Point::new(0, 2),
                    FoldPlaceholder {
                        collapsed_text: Some(SharedString::from("\u{301}")),
                        ..FoldPlaceholder::test()
                    },
                )],
                cx,
            )
        });
        let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
        assert_eq!(snapshot.tab_snapshot().text(), "    \u{301}x\n    \u{301}x");
        let mut query = ColumnarSelectionRows::new(&snapshot);
        for row in [0, 1] {
            assert_eq!(
                query.columns_for_range(Point::new(row, 1)..Point::new(row, 1)),
                4..4
            );
            assert_eq!(
                query.points_for_row(row, &(4..4)),
                Some((Point::new(row, 1), Point::new(row, 1)))
            );
            assert_eq!(
                query.points_for_row(row, &(4..5)),
                Some((Point::new(row, 1), Point::new(row, 2 - row)))
            );
        }
    }

    #[gpui::test]
    fn test_columnar_selection_lazy_unicode_prefix(cx: &mut TestAppContext) {
        init_test(cx);
        let line = format!("{}é", "a".repeat(1_048_576));
        let snapshot = plain_state(&format!("{line}\n{line}"), cx)
            .build_map(cx)
            .update(cx, |map, cx| map.snapshot(cx));
        let mut query = ColumnarSelectionRows::new(&snapshot);
        assert_eq!(query.columns_for_range(Point::zero()..Point::zero()), 0..0);
        assert_eq!(
            query.points_for_row(1, &(0..0)),
            Some((Point::new(1, 0), Point::new(1, 0)))
        );
        for row in [query.row(1), query.buffer_row(1)] {
            let RowText::Unicode(chunks) = row else {
                panic!("Unicode row")
            };
            assert_eq!(chunks.chunks.len(), 0);
        }
        assert_eq!(
            query.points_for_row(1, &(1..1)),
            Some((Point::new(1, 1), Point::new(1, 1)))
        );
        for mut row in [query.row(1), query.buffer_row(1)] {
            let mut cursor = row.cursor(0);
            row.advance_columns(&mut cursor, 1);
            assert_eq!(cursor.byte(), 1);
            let RowText::Unicode(chunks) = row else {
                panic!("Unicode row")
            };
            assert_eq!(chunks.chunks.len(), 1);
        }
        assert_eq!(
            query.points_for_row(1, &(1_048_576..1_048_576)),
            Some((Point::new(1, 1_048_576), Point::new(1, 1_048_576)))
        );
    }

    #[gpui::test]
    fn test_columnar_selection_skips_long_virtual_row(cx: &mut TestAppContext) {
        init_test(cx);
        let mut state = plain_state(&format!("x\n{}", "a".repeat(1_048_576)), cx);
        let buffer = state.buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
        state.inlays.push(Inlay::mock_hint(
            0,
            buffer.anchor_before(Point::new(1, 0)),
            &format!("{}\n", "a".repeat(1_048_576)),
        ));
        let snapshot = state.build_map(cx).update(cx, |map, cx| map.snapshot(cx));
        let mut query = ColumnarSelectionRows::new(&snapshot);
        assert_eq!(query.points_for_row(1, &(1_048_576..1_048_576)), None);
        assert_eq!(
            query.points_for_row(2, &(1_048_576..1_048_576)),
            Some((Point::new(1, 1_048_576), Point::new(1, 1_048_576)))
        );
    }

    #[gpui::test]
    fn test_columnar_selection_graphemes_and_edges(cx: &mut TestAppContext) {
        init_test(cx);
        let state = plain_state("e\u{301}\néé\n\n\t\u{301}x\n👩\u{200d}💻z\n", cx);
        let map = state.build_map(cx);
        let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
        let mut query = ColumnarSelectionRows::new(&snapshot);
        assert_eq!(
            query.columns_for_range(Point::new(0, 0)..Point::new(0, 3)),
            0..1
        );
        assert_eq!(
            query.columns_for_range(Point::new(1, 0)..Point::new(1, 4)),
            0..2
        );
        assert_eq!(
            query.columns_for_range(Point::new(1, 4)..Point::new(0, 0)),
            0..2
        );
        assert_eq!(
            query.points_for_row(0, &(0..1)),
            Some((Point::new(0, 0), Point::new(0, 3)))
        );
        assert_eq!(
            query.points_for_row(1, &(0..1)),
            Some((Point::new(1, 0), Point::new(1, 2)))
        );
        assert_eq!(query.points_for_row(0, &(1..2)), None);
        assert_eq!(
            query.points_for_row(0, &(u32::MAX..u32::MAX)),
            Some((Point::new(0, 3), Point::new(0, 3)))
        );
        assert_eq!(
            query.points_for_row(2, &(0..0)),
            Some((Point::new(2, 0), Point::new(2, 0)))
        );
        assert_eq!(query.points_for_row(2, &(0..1)), None);
        assert_eq!(
            query.points_for_row(3, &(3..4)),
            Some((Point::new(3, 0), Point::new(3, 1)))
        );
        assert_eq!(
            query.points_for_row(4, &(0..1)),
            Some((Point::new(4, 0), Point::new(4, 11)))
        );
        assert_eq!(
            query.points_for_row(5, &(u32::MAX..u32::MAX)),
            Some((Point::new(5, 0), Point::new(5, 0)))
        );
        assert_eq!(query.points_for_row(6, &(0..0)), None);
        assert_eq!(query.points_for_row(u32::MAX, &(0..0)), None);
        assert_plain_rows(&snapshot, 4);
        let empty = plain_state("", cx)
            .build_map(cx)
            .update(cx, |map, cx| map.snapshot(cx));
        assert_plain_rows(&empty, 4);
    }

    #[gpui::test]
    fn test_columnar_selection_ascii_fast_path(cx: &mut TestAppContext) {
        init_test(cx);
        let state = plain_state(&format!("{}\nx", "a".repeat(1_048_576)), cx);
        let map = state.build_map(cx);
        let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
        let mut query = ColumnarSelectionRows::new(&snapshot);
        assert_eq!(query.points_for_row(1, &(2..3)), None);
        assert_eq!(size_of_val(&query), size_of::<&DisplaySnapshot>());
        assert_eq!(
            query.columns_for_range(Point::zero()..Point::new(0, 1_048_576)),
            0..1_048_576
        );
        let RowText::Ascii(len) = query.row(0) else {
            panic!("ASCII row allocated Unicode boundaries")
        };
        assert_eq!(len, 1_048_576);
        assert_eq!(
            query.points_for_row(0, &(1_048_575..u32::MAX)),
            Some((Point::new(0, 1_048_575), Point::new(0, 1_048_576)))
        );
        let RowText::Ascii(len) = query.buffer_row(0) else {
            panic!("ASCII buffer row allocated Unicode boundaries")
        };
        assert_eq!(len, 1_048_576);
    }

    #[gpui::test]
    fn test_columnar_selection_tab_expansion_boundary(cx: &mut TestAppContext) {
        init_test(cx);
        let prefixes = (255..=257)
            .map(|column| format!("{}{}", "α".repeat(127), "a".repeat(column - 254)))
            .chain([
                format!("{}α", "a".repeat(255)),
                format!("{}e\u{301}", "a".repeat(254)),
            ])
            .collect::<Vec<_>>();
        let text = prefixes
            .iter()
            .map(|prefix| format!("{prefix}\t\u{301}β"))
            .collect::<Vec<_>>()
            .join("\n");
        let buffer = cx.new(|cx| Buffer::local(text, cx));
        let state = MapState::new(cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx)));
        let map = state.build_map(cx);
        for tab_size in [1, 3, 128] {
            set_tab_size(tab_size, cx);
            let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
            assert_plain_rows(&snapshot, tab_size);
            if tab_size == 128 {
                assert_eq!(
                    snapshot.tab_snapshot().text(),
                    format!(
                        "{}{}\u{301}β\n{} \u{301}β\n{} \u{301}β\n{} \u{301}β\n{} \u{301}β",
                        prefixes[0],
                        " ".repeat(128),
                        prefixes[1],
                        prefixes[2],
                        prefixes[3],
                        prefixes[4]
                    )
                );
            }
            buffer.update(cx, |buffer, cx| buffer.edit([(0..0, "a")], None, cx));
            assert_plain_rows(&map.update(cx, |map, cx| map.snapshot(cx)), tab_size);
            buffer.update(cx, |buffer, cx| buffer.edit([(0..1, "")], None, cx));
            let restored = map.update(cx, |map, cx| map.snapshot(cx));
            assert_eq!(
                restored.tab_snapshot().text(),
                snapshot.tab_snapshot().text()
            );
            assert_plain_rows(&restored, tab_size);
        }
    }

    #[gpui::test]
    fn test_columnar_selection_folds_and_inlays_without_frames(
        cx: &mut TestAppContext,
        mut rng: StdRng,
    ) {
        init_test(cx);
        let mut state = plain_state("e\u{301}x\nab\ncd", cx);
        let map = state.build_map(cx);
        map.update(cx, |map, cx| {
            map.fold(
                vec![Crease::simple(
                    Point::new(0, 1)..Point::new(0, 3),
                    FoldPlaceholder::test(),
                )],
                cx,
            )
        });
        let folded = map.update(cx, |map, cx| map.snapshot(cx));
        assert_eq!(folded.tab_snapshot().text(), "e⋯x\nab\ncd");
        assert_eq!(
            ColumnarSelectionRows::new(&folded).points_for_row(0, &(1..2)),
            Some((Point::new(0, 0), Point::new(0, 3)))
        );
        state.folds = folded
            .folds_in_range(Anchor::Min..Anchor::Max)
            .map(|fold| fold.range.0.clone())
            .collect();
        for (index, bias) in [Bias::Left, Bias::Right].into_iter().enumerate() {
            state.inlays.push(Inlay::mock_hint(
                index,
                folded.buffer_snapshot().anchor_at(Point::new(1, 1), bias),
                "\u{301}\n\tR",
            ));
        }
        map.update(cx, |map, cx| {
            map.splice_inlays(&[], state.inlays.clone(), cx)
        });
        let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
        assert_eq!(
            snapshot.tab_snapshot().text(),
            "e⋯x\na\u{301}\n    R\u{301}\n    Rb\ncd"
        );
        let mut query = ColumnarSelectionRows::new(&snapshot);
        assert_eq!(query.points_for_row(2, &(0..0)), None);
        assert_eq!(query.points_for_row(2, &(0..u32::MAX)), None);
        let rebuilt = state.build_map(cx).update(cx, |map, cx| map.snapshot(cx));
        check_snapshot(&snapshot, &rebuilt, true, None, 4, &mut rng, 0);
    }

    #[gpui::test]
    fn test_columnar_selection_long_fold_placeholders(cx: &mut TestAppContext) {
        init_test(cx);
        for placeholder in ["...", "long placeholder", "ééé", "👩\u{200d}💻xyz"] {
            for edited in [false, true] {
                let buffer = cx.new(|cx| Buffer::local(if edited { "a\nxb" } else { "axb" }, cx));
                let state = MapState::new(cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx)));
                let map = state.build_map(cx);
                map.update(cx, |map, cx| {
                    map.fold(
                        vec![Crease::simple(
                            Point::new(0, 1)..if edited {
                                Point::new(1, 1)
                            } else {
                                Point::new(0, 2)
                            },
                            FoldPlaceholder {
                                collapsed_text: Some(SharedString::from(placeholder)),
                                ..FoldPlaceholder::test()
                            },
                        )],
                        cx,
                    );
                });
                if edited {
                    buffer.update(cx, |buffer, cx| {
                        buffer.edit([(Point::new(0, 1)..Point::new(1, 0), "")], None, cx)
                    });
                }
                let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
                assert_eq!(snapshot.tab_snapshot().text(), format!("a{placeholder}b"));
                let mut query = ColumnarSelectionRows::new(&snapshot);
                let end = 1 + placeholder.graphemes(true).count() as u32;
                for column in 1..end {
                    assert_eq!(
                        query.points_for_row(0, &(column..column)),
                        Some((Point::new(0, 1), Point::new(0, 1))),
                        "{placeholder:?}, column {column}, edited {edited}"
                    );
                }
                assert_eq!(
                    query.points_for_row(0, &(end..end)),
                    Some((Point::new(0, 2), Point::new(0, 2)))
                );
            }
        }
    }

    #[gpui::test]
    fn test_columnar_selection_fold_grapheme_edges(cx: &mut TestAppContext) {
        init_test(cx);
        for (text, placeholder, column, expected) in
            [("axb", "\u{301}..", 1, 0), ("ax\u{301}b", "..", 3, 4)]
        {
            let state = plain_state(text, cx);
            let map = state.build_map(cx);
            map.update(cx, |map, cx| {
                map.fold(
                    vec![Crease::simple(
                        Point::new(0, 1)..Point::new(0, 2),
                        FoldPlaceholder {
                            collapsed_text: Some(SharedString::from(placeholder)),
                            ..FoldPlaceholder::test()
                        },
                    )],
                    cx,
                )
            });
            let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
            assert_eq!(
                ColumnarSelectionRows::new(&snapshot).points_for_row(0, &(column..column)),
                Some((Point::new(0, expected), Point::new(0, expected))),
                "{text:?}, {placeholder:?}"
            );
        }
        for merge in [false, true] {
            let map = plain_state("axyb", cx).build_map(cx);
            map.update(cx, |map, cx| {
                map.fold(
                    [(1, ".."), (2, "ZZ")]
                        .into_iter()
                        .map(|(start, placeholder)| {
                            Crease::simple(
                                Point::new(0, start)..Point::new(0, start + 1),
                                FoldPlaceholder {
                                    merge_adjacent: merge,
                                    collapsed_text: Some(SharedString::from(placeholder)),
                                    ..FoldPlaceholder::test()
                                },
                            )
                        })
                        .collect(),
                    cx,
                )
            });
            let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
            assert_eq!(
                snapshot.tab_snapshot().text(),
                if merge { "a..b" } else { "a..ZZb" }
            );
            let expected = if merge {
                vec![0, 1, 1, 3, 4]
            } else {
                vec![0, 1, 1, 2, 2, 3, 4]
            };
            let mut query = ColumnarSelectionRows::new(&snapshot);
            for (column, byte) in expected.into_iter().enumerate() {
                let column = column as u32;
                assert_eq!(
                    query.points_for_row(0, &(column..column)),
                    Some((Point::new(0, byte), Point::new(0, byte))),
                    "merge={merge}, column={column}"
                );
            }
        }
    }

    #[gpui::test]
    fn test_columnar_selection_fold_ending_inside_grapheme(cx: &mut TestAppContext) {
        init_test(cx);
        let map = plain_state("aX\u{1100}\u{1161}z", cx).build_map(cx);
        map.update(cx, |map, cx| {
            map.fold(
                vec![Crease::simple(
                    Point::new(0, 1)..Point::new(0, 5),
                    FoldPlaceholder::test(),
                )],
                cx,
            )
        });
        let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
        assert_eq!(snapshot.tab_snapshot().text(), "a⋯\u{1161}z");
        let mut query = ColumnarSelectionRows::new(&snapshot);
        for (columns, expected) in [
            (0..0, (Point::new(0, 0), Point::new(0, 0))),
            (1..1, (Point::new(0, 1), Point::new(0, 1))),
            (2..2, (Point::new(0, 1), Point::new(0, 1))),
            (3..3, (Point::new(0, 8), Point::new(0, 8))),
            (4..4, (Point::new(0, 9), Point::new(0, 9))),
            (1..3, (Point::new(0, 1), Point::new(0, 8))),
            (2..4, (Point::new(0, 1), Point::new(0, 9))),
        ] {
            assert_eq!(
                query.points_for_row(0, &columns),
                Some(expected),
                "columns {columns:?}"
            );
        }
    }

    #[test]
    fn test_column_boundaries_large_grapheme() {
        let text = format!("e{}z", "\u{301}".repeat(1024));
        let mut query = RowText::new(text.len() as u32, iter::once(text.as_str()));
        let mut cursor = query.cursor(0);
        assert_eq!(cursor.byte(), 0);
        assert_eq!(query.next_boundary(&mut cursor), Some(2049));
        assert_eq!(query.next_boundary(&mut cursor), Some(2050));
        assert_eq!(query.columns_for_bytes(2048..2049), 0..1);
        assert_eq!(query.floor_at(2048).byte(), 0);
        assert_eq!(query.floor_at(2049).byte(), 2049);
    }

    #[gpui::test(iterations = 20)]
    fn test_columnar_selection_during_pending_rewrap(cx: &mut TestAppContext, mut rng: StdRng) {
        init_test(cx);
        cx.background_executor.set_block_on_ticks(0..=0);
        let text = (0..120)
            .map(|row| format!("row{row} {}", random_text(&mut rng, 6)))
            .collect::<Vec<_>>()
            .join("\n");
        let mut state = plain_state(&text, cx);
        let map = state.build_map(cx);
        let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
        let buffer = snapshot.buffer_snapshot();
        let hidden_start = rng.random_range(0..buffer.max_point().row);
        let hidden_end = rng.random_range(hidden_start..=buffer.max_point().row);
        state.block = Some((
            BlockPlacement::Replace(
                buffer.anchor_before(Point::new(hidden_start, 0))
                    ..=buffer.anchor_after(Point::new(
                        hidden_end,
                        buffer.line_len(MultiBufferRow(hidden_end)),
                    )),
            ),
            1,
        ));
        map.update(cx, |map, cx| {
            map.insert_blocks([state.block_properties().expect("block")], cx)
        });
        state.wrap_width = Some(px(30.0));
        map.update(cx, |map, cx| map.set_wrap_width(state.wrap_width, cx));
        assert!(map.update(cx, |map, cx| map.is_rewrapping(cx)));
        let interpolated = map.update(cx, |map, cx| map.snapshot(cx));
        assert!(map.update(cx, |map, cx| map.is_rewrapping(cx)));
        check_snapshot(&interpolated, &interpolated, true, None, 4, &mut rng, 0);
        let rebuilt = state.build_map(cx);
        cx.run_until_parked();
        assert!(!map.update(cx, |map, cx| map.is_rewrapping(cx)));
        let rebuilt = rebuilt.update(cx, |map, cx| map.snapshot(cx));
        let settled = map.update(cx, |map, cx| map.snapshot(cx));
        assert_eq!(hidden_rows(&settled), hidden_rows(&rebuilt));
        check_snapshot(&settled, &rebuilt, true, None, 4, &mut rng, 1);
        check_snapshot(
            &interpolated,
            &settled,
            hidden_rows(&interpolated) == hidden_rows(&settled),
            None,
            4,
            &mut rng,
            2,
        );
    }

    #[gpui::test(iterations = 100)]
    fn test_random_columnar_selections(cx: &mut TestAppContext, mut rng: StdRng) {
        init_test(cx);
        cx.background_executor.set_block_on_ticks(0..=50);
        let operations = env::var("OPERATIONS")
            .map(|value| value.parse::<usize>().expect("invalid OPERATIONS"))
            .unwrap_or(15);
        let mut texts = (0..rng.random_range(1..=2))
            .map(|_| format!("a{}z", random_text(&mut rng, 12)))
            .collect::<Vec<_>>();
        let buffers = texts
            .iter()
            .map(|text| cx.new(|cx| Buffer::local(text.clone(), cx)))
            .collect::<Vec<_>>();
        let multibuffer = cx.new(|cx| {
            if buffers.len() == 1 {
                return MultiBuffer::singleton(buffers[0].clone(), cx);
            }
            let mut buffer = MultiBuffer::new(Capability::ReadWrite);
            for (index, source) in buffers.iter().enumerate() {
                let snapshot = source.read(cx).snapshot();
                buffer.set_excerpt_ranges_for_path(
                    PathKey::sorted(index as u64),
                    source.clone(),
                    &snapshot,
                    vec![ExcerptRange::new(Point::zero()..snapshot.max_point())],
                    cx,
                );
            }
            buffer
        });
        let mut state = MapState::new(multibuffer);
        let map = state.build_map(cx);
        let mut block_ids = HashSet::default();
        let mut kinds = [0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6];
        kinds.shuffle(&mut rng);
        let mut snapshot = map.update(cx, |map, cx| map.snapshot(cx));
        check_snapshot(
            &snapshot,
            &snapshot,
            true,
            Some(&texts.join("\n")),
            4,
            &mut rng,
            0,
        );
        for operation in 0..operations {
            let kind = kinds[operation % kinds.len()];
            log::info!(
                "operation {operation}: kind {kind}, texts {texts:?}, tabs {}, folds {:?}, inlays {:?}, block {:?}, wrap {:?}",
                state.tab_size,
                state.folds,
                state.inlays,
                state.block,
                state.wrap_width
            );
            let replaced_before = state.replaces_rows();
            match kind {
                0 => {
                    let index = rng.random_range(0..buffers.len());
                    let text = &mut texts[index];
                    let boundaries = text
                        .char_indices()
                        .map(|(offset, _)| offset)
                        .skip(1)
                        .collect::<Vec<_>>();
                    let start = rng.random_range(0..boundaries.len());
                    let mut range =
                        boundaries[start]..boundaries[rng.random_range(start..boundaries.len())];
                    let mut replacement = random_text(&mut rng, 4);
                    if text.get(range.clone()) == Some(replacement.as_str()) {
                        replacement.push('a');
                    }
                    let mut expected = text.clone();
                    expected.replace_range(range.clone(), &replacement);
                    if expected.len() > 256
                        || expected.matches('\t').count() > 4
                        || expected.matches('\n').count() > 12
                    {
                        range = 1..text.len() - 1;
                        replacement.clear();
                        expected = String::from("az");
                    }
                    assert_ne!(expected.as_str(), text.as_str());
                    log::info!("edit buffer {index}: {range:?} -> {replacement:?}");
                    buffers[index].update(cx, |buffer, cx| {
                        buffer.edit([(range, replacement)], None, cx)
                    });
                    *text = expected;
                    if state.replaces_rows() {
                        map.update(cx, |map, cx| {
                            map.remove_blocks(std::mem::take(&mut block_ids), cx);
                            block_ids.extend(
                                map.insert_blocks([state.block_properties().expect("block")], cx),
                            );
                        });
                    }
                }
                1 => {
                    let size = rng.random_range(1..128);
                    state.tab_size = size + u32::from(size >= state.tab_size);
                    set_tab_size(state.tab_size, cx);
                }
                2 => {
                    if state.folds.is_empty() {
                        let index = rng.random_range(0..texts.len());
                        let base = texts
                            .iter()
                            .take(index)
                            .map(|text| text.len() + 1)
                            .sum::<usize>();
                        let boundaries = scalar_boundaries(&texts[index]);
                        let start = rng.random_range(0..boundaries.len() - 1);
                        let end = rng.random_range(start + 1..boundaries.len());
                        let buffer = snapshot.buffer_snapshot();
                        let range = buffer.anchor_after(MultiBufferOffset(base + boundaries[start]))
                            ..buffer.anchor_before(MultiBufferOffset(base + boundaries[end]));
                        map.update(cx, |map, cx| {
                            map.fold(vec![Crease::simple(range, FoldPlaceholder::test())], cx)
                        });
                    } else {
                        map.update(cx, |map, cx| {
                            map.unfold_intersecting([Anchor::Min..Anchor::Max], true, cx)
                        });
                        if state.replaces_rows() {
                            block_ids.clear();
                            state.block = None;
                        }
                    }
                }
                3 | 6 => {
                    if state.inlays.is_empty() {
                        let text = snapshot.buffer_snapshot().text();
                        let boundaries = scalar_boundaries(&text);
                        let offset =
                            MultiBufferOffset(boundaries[rng.random_range(0..boundaries.len())]);
                        for (index, bias) in [Bias::Left, Bias::Right].into_iter().enumerate() {
                            let text = format!("\n{}\t", random_text(&mut rng, 3));
                            state.inlays.push(Inlay::mock_hint(
                                index,
                                snapshot.buffer_snapshot().anchor_at(offset, bias),
                                text.as_str(),
                            ));
                        }
                        map.update(cx, |map, cx| {
                            map.splice_inlays(&[], state.inlays.clone(), cx)
                        });
                    } else {
                        let ids = state
                            .inlays
                            .iter()
                            .map(|inlay| inlay.id)
                            .collect::<Vec<_>>();
                        map.update(cx, |map, cx| map.splice_inlays(&ids, Vec::new(), cx));
                        state.inlays.clear();
                    }
                }
                4 => {
                    state.wrap_width = if state.wrap_width.is_some() {
                        None
                    } else {
                        Some(px([0.0, 12.0, 48.0, 300.0][rng.random_range(0..4)]))
                    };
                    map.update(cx, |map, cx| map.set_wrap_width(state.wrap_width, cx));
                }
                5 => {
                    if state.block.is_some() {
                        map.update(cx, |map, cx| {
                            map.remove_blocks(std::mem::take(&mut block_ids), cx)
                        });
                        state.block = None;
                    } else {
                        let text = snapshot.buffer_snapshot().text();
                        let boundaries = scalar_boundaries(&text);
                        let start = rng.random_range(0..boundaries.len());
                        let buffer = snapshot.buffer_snapshot();
                        let position = buffer.anchor_after(MultiBufferOffset(boundaries[start]));
                        let placement = match rng.random_range(0..3) {
                            0 => BlockPlacement::Above(position),
                            1 => BlockPlacement::Below(position),
                            _ => {
                                let start = rng.random_range(0..boundaries.len() - 1);
                                let end = rng.random_range(start + 1..boundaries.len());
                                BlockPlacement::Replace(
                                    buffer.anchor_before(MultiBufferOffset(boundaries[start]))
                                        ..=buffer.anchor_after(MultiBufferOffset(boundaries[end])),
                                )
                            }
                        };
                        state.block = Some((placement, rng.random_range(1..=3)));
                        block_ids.extend(map.update(cx, |map, cx| {
                            map.insert_blocks([state.block_properties().expect("block")], cx)
                        }));
                    }
                }
                _ => unreachable!(),
            }
            let previous = snapshot;
            snapshot = map.update(cx, |map, cx| map.snapshot(cx));
            state.folds = snapshot
                .folds_in_range(Anchor::Min..Anchor::Max)
                .map(|fold| fold.range.0.clone())
                .collect();
            let text = texts.join("\n");
            assert_eq!(
                snapshot.buffer_snapshot().text(),
                text,
                "operation {operation}"
            );
            let plain = (state.folds.is_empty()
                && state
                    .inlays
                    .iter()
                    .all(|inlay| !inlay.position.is_valid(snapshot.buffer_snapshot()))
                && !state.replaces_rows())
            .then_some(text.as_str());
            let rewrapping = map.update(cx, |map, cx| map.is_rewrapping(cx));
            let rebuilt = state.build_map(cx);
            cx.run_until_parked();
            let rebuilt = rebuilt.update(cx, |map, cx| map.snapshot(cx));
            let settled = map.update(cx, |map, cx| map.snapshot(cx));
            assert_eq!(
                hidden_rows(&settled),
                hidden_rows(&rebuilt),
                "operation {operation}: hidden rows"
            );
            check_snapshot(
                &snapshot,
                &rebuilt,
                !state.replaces_rows() || !rewrapping,
                plain,
                state.tab_size,
                &mut rng,
                operation,
            );
            if (kind == 4 || kind == 5) && !replaced_before && !state.replaces_rows() {
                check_snapshot(
                    &snapshot,
                    &previous,
                    true,
                    plain,
                    state.tab_size,
                    &mut rng,
                    operation,
                );
            }
            check_snapshot(
                &settled,
                &rebuilt,
                true,
                plain,
                state.tab_size,
                &mut rng,
                operation,
            );
            snapshot = settled;
        }
    }

    struct MapState {
        buffer: Entity<MultiBuffer>,
        tab_size: u32,
        folds: Vec<Range<Anchor>>,
        inlays: Vec<Inlay>,
        block: Option<(BlockPlacement<Anchor>, u32)>,
        wrap_width: Option<Pixels>,
    }

    impl MapState {
        fn new(buffer: Entity<MultiBuffer>) -> Self {
            Self {
                buffer,
                tab_size: 4,
                folds: Vec::new(),
                inlays: Vec::new(),
                block: None,
                wrap_width: None,
            }
        }

        fn build_map(&self, cx: &mut TestAppContext) -> Entity<DisplayMap> {
            cx.new(|cx| {
                let mut map = DisplayMap::new(
                    self.buffer.clone(),
                    test_font(),
                    px(10.0),
                    self.wrap_width,
                    1,
                    1,
                    FoldPlaceholder::test(),
                    DiagnosticSeverity::Warning,
                    cx,
                );
                map.splice_inlays(&[], self.inlays.clone(), cx);
                if !self.folds.is_empty() {
                    map.fold(
                        self.folds
                            .iter()
                            .cloned()
                            .map(|range| Crease::simple(range, FoldPlaceholder::test()))
                            .collect(),
                        cx,
                    );
                }
                if let Some(block) = self.block_properties() {
                    map.insert_blocks([block], cx);
                }
                map
            })
        }

        fn replaces_rows(&self) -> bool {
            matches!(self.block, Some((BlockPlacement::Replace(_), _)))
        }

        fn block_properties(&self) -> Option<BlockProperties<Anchor>> {
            self.block
                .as_ref()
                .map(|(placement, height)| BlockProperties {
                    placement: placement.clone(),
                    style: BlockStyle::Fixed,
                    height: Some(*height),
                    render: Arc::new(|_| div().into_any()),
                    priority: 0,
                })
        }
    }

    struct PlainRow {
        text: String,
        len: u32,
        columns: Vec<(u32, u32)>,
        points: Vec<(u32, u32)>,
        boundaries: Vec<usize>,
    }

    fn assert_batch_points(
        query: &mut ColumnarSelectionRows<'_>,
        mut requests: Vec<(u32, Range<u32>)>,
        mut expected: Vec<Option<(Point, Point)>>,
        work_bound: usize,
    ) {
        for _ in 0..2 {
            ROW_WORK.set((0, 0));
            let answers = query.points_for_rows(&requests);
            assert_eq!(answers.len(), expected.len());
            for (index, (answer, expected)) in answers.iter().zip(&expected).enumerate() {
                assert_eq!(answer, expected, "request {index}: {:?}", requests[index]);
            }
            let (boundaries, chunks) = ROW_WORK.get();
            assert!(boundaries <= work_bound, "{boundaries} > {work_bound}");
            assert!(chunks <= work_bound, "{chunks} > {work_bound}");
            requests.reverse();
            expected.reverse();
        }
    }

    fn enumerated_points(
        snapshot: &DisplaySnapshot,
        raw: &str,
        row: u32,
        boundaries: &[usize],
    ) -> Vec<(u32, Point)> {
        raw.split('\n')
            .enumerate()
            .flat_map(|(row, line)| {
                grapheme_boundaries(line)
                    .into_iter()
                    .map(move |byte| Point::new(row as u32, byte as u32))
            })
            .filter_map(|point| {
                let tab = snapshot
                    .tab_snapshot()
                    .point_to_tab_point(point, Bias::Left);
                if tab.row() != row
                    || snapshot.tab_snapshot().tab_point_to_point(tab, Bias::Left) != point
                {
                    return None;
                }
                let display = point.to_display_point(snapshot);
                if display.to_point(snapshot) != point || snapshot.is_block_line(display.row()) {
                    return None;
                }
                boundaries
                    .binary_search(&(tab.column() as usize))
                    .ok()
                    .map(|column| (column as u32, point))
            })
            .collect()
    }

    fn nearest_points(
        columns: &Range<u32>,
        length: u32,
        candidates: &[(u32, Point)],
    ) -> Option<(Point, Point)> {
        if columns.start > columns.end || (columns.start != columns.end && columns.start >= length)
        {
            return None;
        }
        let point = |column| {
            candidates
                .iter()
                .filter(|(candidate, _)| *candidate <= column)
                .max_by_key(|(candidate, _)| *candidate)
                .map(|(_, point)| *point)
        };
        point(columns.start).zip(point(columns.end))
    }

    fn hidden_rows(snapshot: &DisplaySnapshot) -> Vec<bool> {
        (0..=snapshot.buffer_snapshot().max_point().row)
            .map(|row| snapshot.is_block_line(Point::new(row, 0).to_display_point(snapshot).row()))
            .collect()
    }

    fn init_test(cx: &mut TestAppContext) {
        cx.update(|cx| {
            let settings = SettingsStore::test(cx);
            cx.set_global(settings);
            crate::init(cx);
            theme_settings::init(LoadThemes::JustBase, cx);
        });
        set_tab_size(4, cx);
    }

    fn set_tab_size(size: u32, cx: &mut TestAppContext) {
        cx.update(|cx| {
            cx.update_global::<SettingsStore, _>(|store, cx| {
                store.update_user_settings(cx, |settings| {
                    settings.project.all_languages.defaults.tab_size = NonZeroU32::new(size);
                })
            })
        });
    }

    fn plain_state(text: &str, cx: &mut TestAppContext) -> MapState {
        MapState::new(cx.update(|cx| MultiBuffer::build_simple(text, cx)))
    }

    fn random_text(rng: &mut StdRng, tokens: usize) -> String {
        let mut text = String::new();
        let mut tabs = 0;
        for _ in 0..rng.random_range(0..=tokens) {
            let mut token = *[
                "a",
                " ",
                "\t",
                "\n",
                "α",
                "界",
                "🏀",
                "é",
                "e\u{301}",
                "o\u{308}\u{301}",
                "\u{301}",
                "👩\u{200d}💻",
                "👍🏽",
                "🇦🇶",
                "✈\u{fe0f}",
            ]
            .choose(rng)
            .expect("tokens");
            if token == "\t" {
                if tabs == 2 {
                    token = "a";
                } else {
                    tabs += 1;
                }
            }
            text.push_str(token);
        }
        text
    }

    fn assert_row_boundaries(query: &mut RowText<'_>, expected: &[usize]) {
        let length = *expected.last().expect("end boundary");
        for byte in 0..=length + 1 {
            let column = expected.partition_point(|boundary| *boundary <= byte) - 1;
            assert_eq!(
                query.columns_for_bytes(byte as u32..byte as u32),
                column as u32..column as u32,
                "byte {byte}, expected {expected:?}"
            );
            assert_eq!(
                query.floor_at(byte as u32).byte(),
                expected[column] as u32,
                "byte {byte}, expected {expected:?}"
            );
        }
        let mut cursor = query.cursor(0);
        for byte in expected.iter().skip(1) {
            assert_eq!(query.next_boundary(&mut cursor), Some(*byte as u32));
        }
        assert_eq!(query.next_boundary(&mut cursor), None);
        for byte in expected.iter().rev().skip(1) {
            assert_eq!(query.previous_boundary(&mut cursor), Some(*byte as u32));
        }
        assert_eq!(query.previous_boundary(&mut cursor), None);
        let mut cursor = query.floor_at(u32::MAX);
        assert_eq!(cursor.byte(), length as u32);
        for byte in expected.iter().rev().skip(1) {
            assert_eq!(query.previous_boundary(&mut cursor), Some(*byte as u32));
        }
        query.advance_columns(&mut cursor, u32::MAX);
        assert_eq!(cursor.byte(), length as u32);
    }

    fn scalar_boundaries(text: &str) -> Vec<usize> {
        text.char_indices()
            .map(|(offset, _)| offset)
            .chain(iter::once(text.len()))
            .collect()
    }

    fn grapheme_boundaries(text: &str) -> Vec<usize> {
        text.grapheme_indices(true)
            .map(|(offset, _)| offset)
            .chain(iter::once(text.len()))
            .collect()
    }

    fn plain_row(line: &str, tab_size: u32) -> PlainRow {
        let mut text = String::new();
        let mut columns = Vec::new();
        let mut points = Vec::new();
        let mut boundaries = Vec::new();
        let mut column = 0;
        let mut character_column = 0;
        for (byte, grapheme) in line.grapheme_indices(true) {
            points.push((column, byte as u32));
            columns.extend(
                grapheme
                    .char_indices()
                    .map(|(offset, _)| ((byte + offset) as u32, column)),
            );
            if grapheme == "\t" {
                let width = if byte < 256 {
                    tab_size - character_column % tab_size
                } else {
                    1
                };
                boundaries.extend(text.len()..text.len() + width as usize);
                text.extend(iter::repeat_n(' ', width as usize));
                character_column += width;
                column += width;
            } else {
                boundaries.push(text.len());
                text.push_str(grapheme);
                character_column += grapheme.chars().count() as u32;
                column += 1;
            }
        }
        columns.push((line.len() as u32, column));
        points.push((column, line.len() as u32));
        boundaries.push(text.len());
        PlainRow {
            text,
            len: column,
            columns,
            points,
            boundaries,
        }
    }

    fn expected_points(
        row: u32,
        columns: &Range<u32>,
        expected: &PlainRow,
    ) -> Option<(Point, Point)> {
        if columns.start != columns.end && columns.start >= expected.len {
            return None;
        }
        let point = |column| {
            Point::new(
                row,
                expected
                    .points
                    .iter()
                    .rev()
                    .find(|(candidate, _)| *candidate <= column)
                    .expect("row start")
                    .1,
            )
        };
        Some((point(columns.start), point(columns.end)))
    }

    fn assert_plain_rows(snapshot: &DisplaySnapshot, tab_size: u32) {
        let raw = snapshot.buffer_snapshot().text();
        let expected = raw
            .split('\n')
            .map(|line| plain_row(line, tab_size))
            .collect::<Vec<_>>();
        assert_eq!(
            snapshot.tab_snapshot().text(),
            expected
                .iter()
                .map(|row| row.text.as_str())
                .collect::<Vec<_>>()
                .join("\n")
        );
        let mut query = ColumnarSelectionRows::new(snapshot);
        for (row, expected) in expected.iter().enumerate() {
            let row = row as u32;
            assert_eq!(
                query.row(row).columns_for_bytes(0..u32::MAX).end,
                expected.len
            );
            for &(byte, column) in &expected.columns {
                assert_eq!(
                    query.columns_for_range(Point::new(row, byte)..Point::new(row, byte)),
                    column..column
                );
            }
            for column in 0..=expected.len + 1 {
                for columns in [column..column, column..column + 1, column..u32::MAX] {
                    assert_eq!(
                        query.points_for_row(row, &columns),
                        expected_points(row, &columns, expected),
                        "row {row}, columns {columns:?}, text {:?}",
                        expected.text
                    );
                }
            }
        }
    }

    fn check_snapshot(
        snapshot: &DisplaySnapshot,
        rebuilt: &DisplaySnapshot,
        blocks_agree: bool,
        plain: Option<&str>,
        tab_size: u32,
        rng: &mut StdRng,
        operation: usize,
    ) {
        let text = snapshot.tab_snapshot().text();
        assert_eq!(
            text,
            rebuilt.tab_snapshot().text(),
            "operation {operation}: tab text"
        );
        assert_eq!(
            snapshot.fold_snapshot().text(),
            rebuilt.fold_snapshot().text(),
            "operation {operation}: fold text"
        );
        assert_eq!(
            snapshot.inlay_snapshot().text(),
            rebuilt.inlay_snapshot().text(),
            "operation {operation}: inlay text"
        );
        let raw = snapshot.buffer_snapshot().text();
        assert_eq!(raw, rebuilt.buffer_snapshot().text());
        if let Some(plain) = plain {
            assert_eq!(raw, plain);
        }
        let expected = plain.map(|plain| {
            plain
                .split('\n')
                .map(|line| plain_row(line, tab_size))
                .collect::<Vec<_>>()
        });
        if let Some(expected) = &expected {
            assert_eq!(
                text,
                expected
                    .iter()
                    .map(|row| row.text.as_str())
                    .collect::<Vec<_>>()
                    .join("\n"),
                "operation {operation}: independent expansion"
            );
        }
        let lines = text.split('\n').collect::<Vec<_>>();
        let raw_lines = raw.split('\n').collect::<Vec<_>>();
        let raw_boundaries = grapheme_boundaries(&raw);
        let mut query = ColumnarSelectionRows::new(snapshot);
        let mut rebuilt_query = ColumnarSelectionRows::new(rebuilt);
        assert_eq!(
            snapshot.tab_snapshot().max_point().row() as usize + 1,
            lines.len()
        );
        let sources = scalar_boundaries(&raw);
        for (start, end) in [
            (0, raw.len()),
            (
                sources[rng.random_range(0..sources.len())],
                sources[rng.random_range(0..sources.len())],
            ),
        ] {
            let point = |offset| {
                Point::new(
                    raw[..offset].matches('\n').count() as u32,
                    raw[..offset].rsplit('\n').next().expect("line").len() as u32,
                )
            };
            let range = point(start)..point(end);
            let columns = query.columns_for_range(range.clone());
            assert_eq!(
                columns,
                rebuilt_query.columns_for_range(range.clone()),
                "operation {operation}: source {range:?}"
            );
            if let Some(expected) = &expected {
                let column = |point: Point| {
                    expected[point.row as usize]
                        .columns
                        .iter()
                        .find(|(byte, _)| *byte == point.column)
                        .expect("source byte")
                        .1
                };
                let (start, end) = (column(range.start), column(range.end));
                assert_eq!(
                    columns,
                    start.min(end)..start.max(end),
                    "operation {operation}: independent source {range:?}"
                );
            }
        }
        let folded = snapshot.fold_snapshot().text();
        let expanded = folded
            .split('\n')
            .map(|line| plain_row(line, tab_size))
            .collect::<Vec<_>>();
        let mut rows = vec![
            0,
            lines.len() - 1,
            rng.random_range(0..lines.len()),
            rng.random_range(0..lines.len()),
        ];
        rows.sort_unstable();
        rows.dedup();
        for row in rows {
            assert_eq!(lines[row], expanded[row].text);
            let boundaries = &expanded[row].boundaries;
            let len = boundaries.len() as u32 - 1;
            assert_eq!(
                snapshot.tab_snapshot().line_len(row as u32),
                lines[row].len() as u32
            );
            assert_eq!(
                query.row(row as u32).columns_for_bytes(0..u32::MAX).end,
                len,
                "operation {operation}: row {row}"
            );
            assert_eq!(
                rebuilt_query
                    .row(row as u32)
                    .columns_for_bytes(0..u32::MAX)
                    .end,
                len
            );
            let candidates = enumerated_points(snapshot, &raw, row as u32, boundaries);
            let middle = rng.random_range(0..=len + 1);
            let requests = [
                0..0,
                0..u32::MAX,
                middle..middle,
                middle..middle + 1,
                middle..rng.random_range(middle..=len + 1),
                len..len,
                len..len + 1,
                u32::MAX..u32::MAX,
            ]
            .map(|columns| (row as u32, columns));
            let answers = query.points_for_rows(&requests);
            let rebuilt_answers = rebuilt_query.points_for_rows(&requests);
            let mut checked_points = HashSet::default();
            for (((_, columns), points), rebuilt_points) in
                requests.into_iter().zip(answers).zip(rebuilt_answers)
            {
                if blocks_agree {
                    assert_eq!(
                        points, rebuilt_points,
                        "operation {operation}: row {row}, columns {columns:?}"
                    );
                }
                if let Some(expected) = &expected {
                    assert_eq!(
                        points,
                        expected_points(row as u32, &columns, &expected[row]),
                        "operation {operation}: independent row {row}, columns {columns:?}"
                    );
                }
                let expected = nearest_points(&columns, len, &candidates);
                assert_eq!(
                    points, expected,
                    "operation {operation}: enumerated raw boundaries, row {row}, columns {columns:?}, raw {raw:?}, tab {text:?}"
                );
                if let Some((start, end)) = points {
                    assert!(start <= end);
                    for point in [start, end] {
                        if !checked_points.insert(point) {
                            continue;
                        }
                        let line = raw_lines
                            .get(point.row as usize)
                            .expect("raw row in bounds");
                        assert!(point.column as usize <= line.len());
                        let offset = raw_lines
                            .iter()
                            .take(point.row as usize)
                            .map(|line| line.len() + 1)
                            .sum::<usize>()
                            + point.column as usize;
                        assert_eq!(
                            raw_boundaries
                                .get(raw_boundaries.partition_point(|boundary| *boundary < offset))
                                .copied(),
                            Some(offset),
                            "operation {operation}: full-buffer grapheme {point:?}, raw {raw:?}"
                        );
                        let forward = snapshot
                            .tab_snapshot()
                            .point_to_tab_point(point, Bias::Left);
                        assert_eq!(forward.row(), row as u32);
                        assert_eq!(
                            snapshot
                                .tab_snapshot()
                                .tab_point_to_point(forward, Bias::Left),
                            point
                        );
                        let column = boundaries
                            .binary_search(&(forward.column() as usize))
                            .expect("tab grapheme boundary")
                            as u32;
                        assert_eq!(
                            query.points_for_row(row as u32, &(column..column)),
                            Some((point, point))
                        );
                        let display = point.to_display_point(snapshot);
                        assert!(!snapshot.is_block_line(display.row()));
                        assert_eq!(display.to_point(snapshot), point);
                    }
                }
            }
        }
        assert_eq!(query.points_for_row(lines.len() as u32, &(0..0)), None);
    }

    fn separated_columnar_ranges(
        row: u32,
        indices: Range<usize>,
        stride: u32,
        width: u32,
        reversed: bool,
    ) -> Vec<Range<Point>> {
        indices
            .map(|index| {
                let start = Point::new(row, index as u32 * stride);
                let end = Point::new(row, start.column + width);
                if reversed { end..start } else { start..end }
            })
            .collect()
    }

    fn set_columnar_action_state(
        cx: &mut EditorTestContext,
        text: &str,
        expected: &[Range<Point>],
    ) {
        cx.update_editor(|editor, window, cx| {
            editor.set_text(text, window, cx);
            editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {
                selections.select_ranges(expected.iter().cloned());
            });
            assert_eq!(
                editor
                    .selections
                    .ranges::<Point>(&editor.display_snapshot(cx)),
                expected,
            );
        });
    }

    #[track_caller]
    fn assert_columnar_action_work(
        cx: &mut EditorTestContext,
        above: bool,
        expected: &[Range<Point>],
        work_bound: usize,
    ) {
        cx.update_editor(|editor, window, cx| {
            ROW_WORK.set((0, 0));
            if above {
                editor.add_selection_above(
                    &AddSelectionAbove {
                        skip_soft_wrap: true,
                    },
                    window,
                    cx,
                );
            } else {
                editor.add_selection_below(
                    &AddSelectionBelow {
                        skip_soft_wrap: true,
                    },
                    window,
                    cx,
                );
            }
            let (boundaries, chunks) = ROW_WORK.replace((0, 0));
            assert!(boundaries > 0);
            assert!(chunks > 0);
            assert!(
                boundaries + chunks <= work_bound,
                "above {above}: {boundaries} boundaries + {chunks} chunks > {work_bound}",
            );
            let actual = editor
                .selections
                .ranges::<Point>(&editor.display_snapshot(cx));
            assert_eq!(actual.len(), expected.len(), "above {above}");
            for (index, (actual, expected)) in actual.iter().zip(expected).enumerate() {
                assert_eq!(actual, expected, "above {above}, selection {index}");
            }
        });
    }
}