ztmux 0.1.0

// Copyright (c) 2010 Nicholas Marriott <nicholas.marriott@gmail.com>
//
// Permission to use, copy, modify, and distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
// IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
// OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
use crate::*;

#[repr(C)]
pub struct tty_acs_entry {
    pub key: u8,
    pub string: &'static [u8; 4],
}
impl tty_acs_entry {
    #[expect(clippy::trivially_copy_pass_by_ref, reason = "false positive")]
    pub const fn new(key: u8, string: &'static [u8; 4]) -> Self {
        Self { key, string }
    }
}

static TTY_ACS_TABLE: [tty_acs_entry; 36] = [
    tty_acs_entry::new(b'+', &[0o342, 0o206, 0o222, 0o000]), // arrow pointing right
    tty_acs_entry::new(b',', &[0o342, 0o206, 0o220, 0o000]), // arrow pointing left
    tty_acs_entry::new(b'-', &[0o342, 0o206, 0o221, 0o000]), // arrow pointing up
    tty_acs_entry::new(b'.', &[0o342, 0o206, 0o223, 0o000]), // arrow pointing down
    tty_acs_entry::new(b'0', &[0o342, 0o226, 0o256, 0o000]), // solid square block
    tty_acs_entry::new(b'`', &[0o342, 0o227, 0o206, 0o000]), // diamond
    tty_acs_entry::new(b'a', &[0o342, 0o226, 0o222, 0o000]), // checker board (stipple)
    tty_acs_entry::new(b'b', &[0o342, 0o220, 0o211, 0o000]),
    tty_acs_entry::new(b'c', &[0o342, 0o220, 0o214, 0o000]),
    tty_acs_entry::new(b'd', &[0o342, 0o220, 0o215, 0o000]),
    tty_acs_entry::new(b'e', &[0o342, 0o220, 0o212, 0o000]),
    tty_acs_entry::new(b'f', &[0o302, 0o260, 0o000, 0o000]), // degree symbol
    tty_acs_entry::new(b'g', &[0o302, 0o261, 0o000, 0o000]), // plus/minus
    tty_acs_entry::new(b'h', &[0o342, 0o220, 0o244, 0o000]),
    tty_acs_entry::new(b'i', &[0o342, 0o220, 0o213, 0o000]),
    tty_acs_entry::new(b'j', &[0o342, 0o224, 0o230, 0o000]), // lower right corner
    tty_acs_entry::new(b'k', &[0o342, 0o224, 0o220, 0o000]), // upper right corner
    tty_acs_entry::new(b'l', &[0o342, 0o224, 0o214, 0o000]), // upper left corner
    tty_acs_entry::new(b'm', &[0o342, 0o224, 0o224, 0o000]), // lower left corner
    tty_acs_entry::new(b'n', &[0o342, 0o224, 0o274, 0o000]), // large plus or crossover
    tty_acs_entry::new(b'o', &[0o342, 0o216, 0o272, 0o000]), // scan line 1
    tty_acs_entry::new(b'p', &[0o342, 0o216, 0o273, 0o000]), // scan line 3
    tty_acs_entry::new(b'q', &[0o342, 0o224, 0o200, 0o000]), // horizontal line
    tty_acs_entry::new(b'r', &[0o342, 0o216, 0o274, 0o000]), // scan line 7
    tty_acs_entry::new(b's', &[0o342, 0o216, 0o275, 0o000]), // scan line 9
    tty_acs_entry::new(b't', &[0o342, 0o224, 0o234, 0o000]), // tee pointing right
    tty_acs_entry::new(b'u', &[0o342, 0o224, 0o244, 0o000]), // tee pointing left
    tty_acs_entry::new(b'v', &[0o342, 0o224, 0o264, 0o000]), // tee pointing up
    tty_acs_entry::new(b'w', &[0o342, 0o224, 0o254, 0o000]), // tee pointing down
    tty_acs_entry::new(b'x', &[0o342, 0o224, 0o202, 0o000]), // vertical line
    tty_acs_entry::new(b'y', &[0o342, 0o211, 0o244, 0o000]), // less-than-or-equal-to
    tty_acs_entry::new(b'z', &[0o342, 0o211, 0o245, 0o000]), // greater-than-or-equal-to
    tty_acs_entry::new(b'{', &[0o317, 0o200, 0o000, 0o000]), // greek pi
    tty_acs_entry::new(b'|', &[0o342, 0o211, 0o240, 0o000]), // not-equal
    tty_acs_entry::new(b'}', &[0o302, 0o243, 0o000, 0o000]), // UK pound sign
    tty_acs_entry::new(b'~', &[0o302, 0o267, 0o000, 0o000]), // bullet
];

#[repr(C)]
pub struct tty_acs_reverse_entry {
    pub string: &'static [u8; 4],
    pub key: u8,
}
impl tty_acs_reverse_entry {
    #[expect(clippy::trivially_copy_pass_by_ref, reason = "false positive")]
    const fn new(string: &'static [u8; 4], key: u8) -> Self {
        Self { string, key }
    }
}

static TTY_ACS_REVERSE2: [tty_acs_reverse_entry; 1] = [tty_acs_reverse_entry::new(
    &[0o302, 0o267, 0o000, 0o000],
    b'~',
)];

static TTY_ACS_REVERSE3: [tty_acs_reverse_entry; 32] = [
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o200, 0o000], b'q'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o201, 0o000], b'q'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o202, 0o000], b'x'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o203, 0o000], b'x'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o214, 0o000], b'l'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o217, 0o000], b'k'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o220, 0o000], b'k'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o223, 0o000], b'l'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o224, 0o000], b'm'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o227, 0o000], b'm'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o230, 0o000], b'j'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o233, 0o000], b'j'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o234, 0o000], b't'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o243, 0o000], b't'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o244, 0o000], b'u'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o253, 0o000], b'u'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o263, 0o000], b'w'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o264, 0o000], b'v'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o273, 0o000], b'v'),
    tty_acs_reverse_entry::new(&[0o342, 0o224, 0o274, 0o000], b'n'),
    tty_acs_reverse_entry::new(&[0o342, 0o225, 0o213, 0o000], b'n'),
    tty_acs_reverse_entry::new(&[0o342, 0o225, 0o220, 0o000], b'q'),
    tty_acs_reverse_entry::new(&[0o342, 0o225, 0o221, 0o000], b'x'),
    tty_acs_reverse_entry::new(&[0o342, 0o225, 0o224, 0o000], b'l'),
    tty_acs_reverse_entry::new(&[0o342, 0o225, 0o227, 0o000], b'k'),
    tty_acs_reverse_entry::new(&[0o342, 0o225, 0o232, 0o000], b'm'),
    tty_acs_reverse_entry::new(&[0o342, 0o225, 0o235, 0o000], b'j'),
    tty_acs_reverse_entry::new(&[0o342, 0o225, 0o240, 0o000], b't'),
    tty_acs_reverse_entry::new(&[0o342, 0o225, 0o243, 0o000], b'u'),
    tty_acs_reverse_entry::new(&[0o342, 0o225, 0o246, 0o000], b'w'),
    tty_acs_reverse_entry::new(&[0o342, 0o225, 0o251, 0o000], b'v'),
    tty_acs_reverse_entry::new(&[0o342, 0o225, 0o254, 0o000], b'n'),
];

/// UTF-8 double borders.
static TTY_ACS_DOUBLE_BORDERS_LIST: [utf8_data; 13] = [
    utf8_data::new([0o000, 0o000, 0o000, 0o000], 0, 0, 0),
    utf8_data::new([0o342, 0o225, 0o221, 0o000], 0, 3, 1), // U+2551
    utf8_data::new([0o342, 0o225, 0o220, 0o000], 0, 3, 1), // U+2550
    utf8_data::new([0o342, 0o225, 0o224, 0o000], 0, 3, 1), // U+2554
    utf8_data::new([0o342, 0o225, 0o227, 0o000], 0, 3, 1), // U+2557
    utf8_data::new([0o342, 0o225, 0o232, 0o000], 0, 3, 1), // U+255A
    utf8_data::new([0o342, 0o225, 0o235, 0o000], 0, 3, 1), // U+255D
    utf8_data::new([0o342, 0o225, 0o246, 0o000], 0, 3, 1), // U+2566
    utf8_data::new([0o342, 0o225, 0o251, 0o000], 0, 3, 1), // U+2569
    utf8_data::new([0o342, 0o225, 0o240, 0o000], 0, 3, 1), // U+2560
    utf8_data::new([0o342, 0o225, 0o243, 0o000], 0, 3, 1), // U+2563
    utf8_data::new([0o342, 0o225, 0o254, 0o000], 0, 3, 1), // U+256C
    utf8_data::new([0o302, 0o267, 0o000, 0o000], 0, 2, 1), // U+00B7
];

/// UTF-8 heavy borders.
static TTY_ACS_HEAVY_BORDERS_LIST: [utf8_data; 13] = [
    utf8_data::new([0o000, 0o000, 0o000, 0o000], 0, 0, 0),
    utf8_data::new([0o342, 0o224, 0o203, 0o000], 0, 3, 1), // U+2503
    utf8_data::new([0o342, 0o224, 0o201, 0o000], 0, 3, 1), // U+2501
    utf8_data::new([0o342, 0o224, 0o217, 0o000], 0, 3, 1), // U+250F
    utf8_data::new([0o342, 0o224, 0o223, 0o000], 0, 3, 1), // U+2513
    utf8_data::new([0o342, 0o224, 0o227, 0o000], 0, 3, 1), // U+2517
    utf8_data::new([0o342, 0o224, 0o233, 0o000], 0, 3, 1), // U+251B
    utf8_data::new([0o342, 0o224, 0o263, 0o000], 0, 3, 1), // U+2533
    utf8_data::new([0o342, 0o224, 0o273, 0o000], 0, 3, 1), // U+253B
    utf8_data::new([0o342, 0o224, 0o243, 0o000], 0, 3, 1), // U+2523
    utf8_data::new([0o342, 0o224, 0o253, 0o000], 0, 3, 1), // U+252B
    utf8_data::new([0o342, 0o225, 0o213, 0o000], 0, 3, 1), // U+254B
    utf8_data::new([0o302, 0o267, 0o000, 0o000], 0, 2, 1), // U+00B7
];

/// UTF-8 rounded borders.
static TTY_ACS_ROUNDED_BORDERS_LIST: [utf8_data; 13] = [
    utf8_data::new([0o000, 0o000, 0o000, 0o000], 0, 0, 0),
    utf8_data::new([0o342, 0o224, 0o202, 0o000], 0, 3, 1), // U+2502
    utf8_data::new([0o342, 0o224, 0o200, 0o000], 0, 3, 1), // U+2500
    utf8_data::new([0o342, 0o225, 0o255, 0o000], 0, 3, 1), // U+256D
    utf8_data::new([0o342, 0o225, 0o256, 0o000], 0, 3, 1), // U+256E
    utf8_data::new([0o342, 0o225, 0o260, 0o000], 0, 3, 1), // U+2570
    utf8_data::new([0o342, 0o225, 0o257, 0o000], 0, 3, 1), // U+256F
    utf8_data::new([0o342, 0o224, 0o263, 0o000], 0, 3, 1), // U+2533
    utf8_data::new([0o342, 0o224, 0o273, 0o000], 0, 3, 1), // U+253B
    utf8_data::new([0o342, 0o224, 0o234, 0o000], 0, 3, 1), // U+2524
    utf8_data::new([0o342, 0o224, 0o244, 0o000], 0, 3, 1), // U+251C
    utf8_data::new([0o342, 0o225, 0o213, 0o000], 0, 3, 1), // U+254B
    utf8_data::new([0o302, 0o267, 0o000, 0o000], 0, 2, 1), // U+00B7
];

/// C `vendor/tmux/tty-acs.c:166`: `const struct utf8_data *tty_acs_double_borders(int cell_type)`
pub fn tty_acs_double_borders(cell_type: cell_type) -> &'static utf8_data {
    &TTY_ACS_DOUBLE_BORDERS_LIST[cell_type as usize]
}

/// C `vendor/tmux/tty-acs.c:173`: `const struct utf8_data *tty_acs_heavy_borders(int cell_type)`
pub fn tty_acs_heavy_borders(cell_type: cell_type) -> &'static utf8_data {
    &TTY_ACS_HEAVY_BORDERS_LIST[cell_type as usize]
}

/// Get cell border character for rounded style.
/// C `vendor/tmux/tty-acs.c:180`: `const struct utf8_data *tty_acs_rounded_borders(int cell_type)`
pub fn tty_acs_rounded_borders(cell_type: cell_type) -> &'static utf8_data {
    &TTY_ACS_ROUNDED_BORDERS_LIST[cell_type as usize]
}

/// C `vendor/tmux/tty-acs.c:186`: `static int tty_acs_cmp(const void *key, const void *value)`
pub fn tty_acs_cmp(test: u8, entry: &tty_acs_entry) -> std::cmp::Ordering {
    test.cmp(&entry.key)
}

/// C `vendor/tmux/tty-acs.c:195`: `static int tty_acs_reverse_cmp(const void *key, const void *value)`
pub unsafe fn tty_acs_reverse_cmp(
    key: *const u8,
    entry: *const tty_acs_reverse_entry,
) -> std::cmp::Ordering {
    unsafe { i32_to_ordering(libc::strcmp(key, (*entry).string.as_ptr().cast())) }
}

/// Should this terminal use ACS instead of UTF-8 line drawing?
/// C `vendor/tmux/tty-acs.c:205`: `int tty_acs_needed(struct tty *tty)`
pub unsafe fn tty_acs_needed(tty: *const tty) -> bool {
    unsafe {
        if tty.is_null() {
            return false;
        }

        if tty_term_has((*tty).term, tty_code_code::TTYC_U8)
            && tty_term_number((*tty).term, tty_code_code::TTYC_U8) == 0
        {
            return true;
        }

        if (*(*tty).client).flags.intersects(client_flag::UTF8) {
            return false;
        }
        true
    }
}

/// Retrieve ACS to output as UTF-8.
/// C `vendor/tmux/tty-acs.c:231`: `const char *tty_acs_get(struct tty *tty, u_char ch)`
pub unsafe fn tty_acs_get(tty: *mut tty, ch: u8) -> *const u8 {
    unsafe {
        // Use the ACS set instead of UTF-8 if needed.
        if tty_acs_needed(tty) {
            if (*(*tty).term).acs[ch as usize][0] == b'\0' {
                return null();
            }
            return &raw const (*(*tty).term).acs[ch as usize][0];
        }

        let Ok(entry) = TTY_ACS_TABLE.binary_search_by(|e| tty_acs_cmp(ch, e).reverse()) else {
            return null_mut();
        };

        TTY_ACS_TABLE[entry].string.as_ptr().cast()
    }
}

/// Reverse UTF-8 into ACS.
/// C `vendor/tmux/tty-acs.c:252`: `int tty_acs_reverse_get(__unused struct tty *tty, const char *s, size_t slen)`
pub unsafe fn tty_acs_reverse_get(_tty: *const tty, s: *const u8, slen: usize) -> i32 {
    unsafe {
        let table = if slen == 2 {
            TTY_ACS_REVERSE2.as_slice()
        } else if slen == 3 {
            TTY_ACS_REVERSE3.as_slice()
        } else {
            return -1;
        };
        let Ok(entry) = table.binary_search_by(|e| tty_acs_reverse_cmp(s, e).reverse()) else {
            return -1;
        };
        table[entry].key as _
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::cmp::Ordering;

    // Read a NUL-terminated C string (as returned by tty_acs_get) into a Vec.
    unsafe fn cstr_bytes(p: *const u8) -> Vec<u8> {
        assert!(!p.is_null(), "unexpected NULL C string");
        let mut v = Vec::new();
        let mut i = 0usize;
        unsafe {
            while *p.add(i) != 0 {
                v.push(*p.add(i));
                i += 1;
            }
        }
        v
    }

    // With a NULL tty, tty_acs_needed() returns 0, so tty_acs_get() takes the
    // pure UTF-8 table (bsearch) path. This lets us drive the table directly.
    // C `vendor/tmux/tty-acs.c:231` tty_acs_get + tty_acs_table.
    #[test]
    fn get_known_line_drawing_mappings() {
        unsafe {
            // 'q' -> horizontal line U+2500 "\342\224\200"
            assert_eq!(cstr_bytes(tty_acs_get(null_mut(), b'q')), vec![0o342, 0o224, 0o200]);
            // 'x' -> vertical line U+2502 "\342\224\202"
            assert_eq!(cstr_bytes(tty_acs_get(null_mut(), b'x')), vec![0o342, 0o224, 0o202]);
            // Corners: j lower-right, k upper-right, l upper-left, m lower-left.
            assert_eq!(cstr_bytes(tty_acs_get(null_mut(), b'j')), vec![0o342, 0o224, 0o230]);
            assert_eq!(cstr_bytes(tty_acs_get(null_mut(), b'k')), vec![0o342, 0o224, 0o220]);
            assert_eq!(cstr_bytes(tty_acs_get(null_mut(), b'l')), vec![0o342, 0o224, 0o214]);
            assert_eq!(cstr_bytes(tty_acs_get(null_mut(), b'm')), vec![0o342, 0o224, 0o224]);
            // 'n' -> large plus / crossover U+253C.
            assert_eq!(cstr_bytes(tty_acs_get(null_mut(), b'n')), vec![0o342, 0o224, 0o274]);
        }
    }

    // Two-byte UTF-8 entries and the table boundaries.
    #[test]
    fn get_two_byte_and_boundary_entries() {
        unsafe {
            // 'f' -> degree symbol U+00B0 "\302\260" (2 bytes).
            assert_eq!(cstr_bytes(tty_acs_get(null_mut(), b'f')), vec![0o302, 0o260]);
            // 'g' -> plus/minus U+00B1 "\302\261".
            assert_eq!(cstr_bytes(tty_acs_get(null_mut(), b'g')), vec![0o302, 0o261]);
            // First table entry '+' -> arrow right U+2192 "\342\206\222".
            assert_eq!(cstr_bytes(tty_acs_get(null_mut(), b'+')), vec![0o342, 0o206, 0o222]);
            // Last table entry '~' -> bullet U+00B7 "\302\267".
            assert_eq!(cstr_bytes(tty_acs_get(null_mut(), b'~')), vec![0o302, 0o267]);
        }
    }

    // Characters not in tty_acs_table return NULL (bsearch miss).
    #[test]
    fn get_out_of_table_returns_null() {
        unsafe {
            // Just below the first key '+' (0x2b): '*' (0x2a).
            assert!(tty_acs_get(null_mut(), b'*').is_null());
            // Just above the last key '~' (0x7e): 0x7f (DEL).
            assert!(tty_acs_get(null_mut(), 0x7f).is_null());
            // 0x00 well below the table.
            assert!(tty_acs_get(null_mut(), 0).is_null());
            // '0' is present but the other digits are not.
            assert!(tty_acs_get(null_mut(), b'1').is_null());
            assert!(tty_acs_get(null_mut(), b'9').is_null());
            // Uppercase letters and other gaps are absent.
            assert!(tty_acs_get(null_mut(), b'A').is_null());
            assert!(tty_acs_get(null_mut(), b'Z').is_null());
            // '_' (0x5f) sits between 'Z' (0x5a) and '`' (0x60): absent.
            assert!(tty_acs_get(null_mut(), b'_').is_null());
            // A space is not in the table.
            assert!(tty_acs_get(null_mut(), b' ').is_null());
        }
    }

    // Reverse lookup of 3-byte UTF-8 sequences -> ACS key.
    // C `vendor/tmux/tty-acs.c:252` tty_acs_reverse_get + tty_acs_reverse3.
    #[test]
    fn reverse_get_three_byte() {
        unsafe {
            // U+2500 "\342\224\200" -> 'q'.
            let s = [0o342u8, 0o224, 0o200, 0];
            assert_eq!(tty_acs_reverse_get(null(), s.as_ptr(), 3), b'q' as i32);
            // U+2502 "\342\224\202" -> 'x'.
            let s = [0o342u8, 0o224, 0o202, 0];
            assert_eq!(tty_acs_reverse_get(null(), s.as_ptr(), 3), b'x' as i32);
            // U+2501 (heavy horizontal) "\342\224\201" -> 'q'.
            let s = [0o342u8, 0o224, 0o201, 0];
            assert_eq!(tty_acs_reverse_get(null(), s.as_ptr(), 3), b'q' as i32);
            // U+2554 double upper-left "\342\225\224" -> 'l'.
            let s = [0o342u8, 0o225, 0o224, 0];
            assert_eq!(tty_acs_reverse_get(null(), s.as_ptr(), 3), b'l' as i32);
            // Last reverse3 entry U+256C "\342\225\254" -> 'n'.
            let s = [0o342u8, 0o225, 0o254, 0];
            assert_eq!(tty_acs_reverse_get(null(), s.as_ptr(), 3), b'n' as i32);
            // First reverse3 entry U+2500 already covered; check U+254B "\342\225\213" -> 'n'.
            let s = [0o342u8, 0o225, 0o213, 0];
            assert_eq!(tty_acs_reverse_get(null(), s.as_ptr(), 3), b'n' as i32);
        }
    }

    // Reverse lookup of the sole 2-byte entry (bullet).
    #[test]
    fn reverse_get_two_byte() {
        unsafe {
            // U+00B7 "\302\267" -> '~' (only entry in tty_acs_reverse2).
            let s = [0o302u8, 0o267, 0];
            assert_eq!(tty_acs_reverse_get(null(), s.as_ptr(), 2), b'~' as i32);
        }
    }

    // Unknown sequences and invalid lengths return -1.
    #[test]
    fn reverse_get_misses_and_bad_lengths() {
        unsafe {
            // A 3-byte sequence not in reverse3 -> -1 (U+2504 "\342\224\204").
            let s = [0o342u8, 0o224, 0o204, 0];
            assert_eq!(tty_acs_reverse_get(null(), s.as_ptr(), 3), -1);
            // A 2-byte sequence that is not the bullet -> -1 (U+00B0 "\302\260").
            let s = [0o302u8, 0o260, 0];
            assert_eq!(tty_acs_reverse_get(null(), s.as_ptr(), 2), -1);
            // slen == 1 and slen == 4 are unsupported -> -1.
            let s = [0o342u8, 0o224, 0o200, 0];
            assert_eq!(tty_acs_reverse_get(null(), s.as_ptr(), 1), -1);
            assert_eq!(tty_acs_reverse_get(null(), s.as_ptr(), 4), -1);
            assert_eq!(tty_acs_reverse_get(null(), s.as_ptr(), 0), -1);
        }
    }

    // Round-trip: get(key) yields a UTF-8 string, and reverse of that string
    // (slen == 3) yields the same key for the plain box-drawing entries.
    #[test]
    fn get_reverse_round_trip() {
        unsafe {
            // Only the keys whose forward UTF-8 also appears in tty_acs_reverse3.
            // (e.g. 'w' -> U+252C is intentionally absent from reverse3, so it is
            // not reversible; see vendor/tmux/tty-acs.c tty_acs_reverse3.)
            for &key in &[b'q', b'x', b'j', b'k', b'l', b'm', b't', b'u', b'v', b'n'] {
                let bytes = cstr_bytes(tty_acs_get(null_mut(), key));
                assert_eq!(bytes.len(), 3, "expected 3-byte UTF-8 for {}", key as char);
                let mut buf = [0u8; 4];
                buf[..3].copy_from_slice(&bytes);
                assert_eq!(
                    tty_acs_reverse_get(null(), buf.as_ptr(), 3),
                    key as i32,
                    "round trip failed for {}",
                    key as char
                );
            }
            // Bullet round-trips through the 2-byte table.
            let bytes = cstr_bytes(tty_acs_get(null_mut(), b'~'));
            assert_eq!(bytes, vec![0o302, 0o267]);
            let mut buf = [0u8; 3];
            buf[..2].copy_from_slice(&bytes);
            assert_eq!(tty_acs_reverse_get(null(), buf.as_ptr(), 2), b'~' as i32);
        }
    }

    // tty_acs_cmp is C's (test - entry->key) reduced to an Ordering.
    // C `vendor/tmux/tty-acs.c:186`.
    #[test]
    fn cmp_orders_by_key() {
        let entry = tty_acs_entry::new(b'q', &[0o342, 0o224, 0o200, 0o000]);
        assert_eq!(tty_acs_cmp(b'q', &entry), Ordering::Equal);
        assert_eq!(tty_acs_cmp(b'p', &entry), Ordering::Less);
        assert_eq!(tty_acs_cmp(b'r', &entry), Ordering::Greater);
    }

    // The main table is sorted ascending by key (bsearch precondition).
    #[test]
    fn table_is_sorted_by_key() {
        assert!(TTY_ACS_TABLE.windows(2).all(|w| w[0].key < w[1].key));
        assert_eq!(TTY_ACS_TABLE.len(), 36);
    }

    // The reverse tables are sorted ascending by their UTF-8 string (bsearch
    // precondition, ordering matches C strcmp / lexicographic byte order).
    #[test]
    fn reverse_tables_are_sorted() {
        assert!(TTY_ACS_REVERSE3.windows(2).all(|w| w[0].string < w[1].string));
        assert_eq!(TTY_ACS_REVERSE3.len(), 32);
        assert_eq!(TTY_ACS_REVERSE2.len(), 1);
    }

    // Border style lookups index the list by cell_type.
    // C `vendor/tmux/tty-acs.c:166/173/180`.
    #[test]
    fn border_style_lookups() {
        // Index 0 (CELL_INSIDE) is the empty sentinel entry in every list.
        let d = tty_acs_double_borders(cell_type::CELL_INSIDE);
        assert_eq!(d.size, 0);
        assert_eq!(d.width, 0);

        // Double vertical (CELL_TOPBOTTOM=1) -> U+2551 "\342\225\221".
        let d = tty_acs_double_borders(cell_type::CELL_TOPBOTTOM);
        assert_eq!(&d.data[..3], &[0o342, 0o225, 0o221]);
        assert_eq!(d.size, 3);
        assert_eq!(d.width, 1);

        // Heavy vertical (CELL_TOPBOTTOM=1) -> U+2503 "\342\224\203".
        let h = tty_acs_heavy_borders(cell_type::CELL_TOPBOTTOM);
        assert_eq!(&h.data[..3], &[0o342, 0o224, 0o203]);

        // Rounded horizontal (CELL_LEFTRIGHT=2) -> U+2500 "\342\224\200".
        let r = tty_acs_rounded_borders(cell_type::CELL_LEFTRIGHT);
        assert_eq!(&r.data[..3], &[0o342, 0o224, 0o200]);

        // Rounded top-left corner (CELL_TOPLEFT=3) -> U+256D "\342\225\255".
        let r = tty_acs_rounded_borders(cell_type::CELL_TOPLEFT);
        assert_eq!(&r.data[..3], &[0o342, 0o225, 0o255]);

        // Last cell_type CELL_OUTSIDE=12 -> bullet U+00B7 "\302\267" in each list.
        let d = tty_acs_double_borders(cell_type::CELL_OUTSIDE);
        assert_eq!(&d.data[..2], &[0o302, 0o267]);
        assert_eq!(d.size, 2);
    }
}