first pass of merging in warp (doesn't build)

crates/galaxy_terminal/src/model/grid/cell_tests.rs

@@ -0,0 +1,102 @@
+// The code in this file is adapted from the alacritty_terminal crate under the
+// Apache license; see: crates/warp_terminal/src/model/LICENSE-ALACRITTY.
+
+use super::{Cell, LineLength};
+use crate::model::char_or_str::CharOrStr;
+use crate::model::grid::cell::{Flags, MAX_GRAPHEME_BYTES};
+use crate::model::grid::row::Row;
+
+#[test]
+fn verify_cell_size() {
+    // If this test fails, then something has changed about Cell that alters its memory layout and
+    // causes it to be a different size than expected. Verify carefully if that is expected before
+    // updating the constant value.
+    const EXPECTED_CELL_SIZE_IN_BYTES: usize = 24;
+
+    assert_eq!(std::mem::size_of::<Cell>(), EXPECTED_CELL_SIZE_IN_BYTES);
+}
+
+#[test]
+fn line_length_works() {
+    let mut row = Row::new(10);
+    row[5].c = 'a';
+
+    assert_eq!(row.line_length(), 6);
+}
+
+#[test]
+fn line_length_works_with_wrapline() {
+    let mut row = Row::new(10);
+    row[9].flags.insert(super::Flags::WRAPLINE);
+
+    assert_eq!(row.line_length(), 10);
+}
+
+#[test]
+fn line_length_works_with_empty_line() {
+    let mut row = Row::new(1);
+    row.shrink(0);
+    assert_eq!(row.line_length(), 0);
+}
+
+#[test]
+fn test_contains_cell_decorations() {
+    assert!(Flags::UNDERLINE.intersects(Flags::CELL_DECORATIONS));
+    assert!(Flags::STRIKEOUT.intersects(Flags::CELL_DECORATIONS));
+    assert!(Flags::DOUBLE_UNDERLINE.intersects(Flags::CELL_DECORATIONS));
+}
+
+#[test]
+fn push_zerowidth_caps_accumulated_grapheme() {
+    // A ZWJ (U+200D) is three bytes in UTF-8.  Push enough of them to go
+    // well past `MAX_GRAPHEME_BYTES`, and verify that the accumulated
+    // content stops growing at the cap.
+    let mut cell = Cell {
+        c: 'e',
+        ..Cell::default()
+    };
+    let zwj = '\u{200D}';
+    let zwj_bytes = zwj.len_utf8();
+    let pushes = (MAX_GRAPHEME_BYTES * 10) / zwj_bytes;
+    for _ in 0..pushes {
+        cell.push_zerowidth(zwj, /* log_long_grapheme_warnings */ true);
+    }
+
+    let CharOrStr::Str(content) = cell.raw_content() else {
+        panic!("cell should have accumulated zero-width content as a string");
+    };
+    // The stored content is "base char + N zero-width chars".  The total
+    // length in bytes must fit within the cap.
+    assert!(
+        content.len() <= MAX_GRAPHEME_BYTES,
+        "expected stored content length {} to be <= cap {}",
+        content.len(),
+        MAX_GRAPHEME_BYTES,
+    );
+    // We also want the cap to actually be approached: the stored content
+    // should contain many zero-width characters and not have been truncated
+    // early.
+    let zero_width_bytes = content.len() - 'e'.len_utf8();
+    let zero_width_count = zero_width_bytes / zwj_bytes;
+    assert!(
+        zero_width_count >= 80,
+        "expected at least 80 zero-width chars to fit, got {zero_width_count}",
+    );
+    assert!(content.starts_with('e'));
+    assert!(content[1..].chars().all(|c| c == zwj));
+}
+
+#[test]
+fn push_zerowidth_seeds_base_char_on_first_push() {
+    // Before any zero-width char is pushed, the cell's raw content is just
+    // the base char.  After the first push, the content becomes a string
+    // consisting of the base char plus the pushed zero-width char.
+    let mut cell = Cell {
+        c: 'x',
+        ..Cell::default()
+    };
+    assert_eq!(cell.raw_content(), CharOrStr::Char('x'));
+
+    cell.push_zerowidth('\u{0301}', /* log_long_grapheme_warnings */ true);
+    assert_eq!(cell.raw_content(), CharOrStr::Str("x\u{0301}"));
+}