tastty-core 0.1.0

Sans-IO core of the tastty terminal session library: VT parser, screen buffer, and byte encoders.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use super::*;

#[test]
fn scroll_up_down() {
    // 3-row terminal with 10 lines of scrollback capacity
    let mut parser = crate::Parser::new(TerminalSize { rows: 3, cols: 80 }, 10);
    // Write enough lines to push content into scrollback
    for i in 0..6 {
        process(&mut parser, format!("line{i}\r\n").as_bytes());
    }
    assert!(parser.screen().scrollback_available() > 0);
    assert_eq!(parser.screen().scrollback(), 0);

    parser.screen_mut().scroll_up(2);
    assert_eq!(
        parser.screen().scrollback(),
        2,
        "scroll_up(2) should advance the scrollback offset by 2",
    );

    parser.screen_mut().scroll_down(1);
    assert_eq!(
        parser.screen().scrollback(),
        1,
        "scroll_down(1) should walk the offset back toward live by 1",
    );

    parser.screen_mut().scroll_reset();
    assert_eq!(
        parser.screen().scrollback(),
        0,
        "scroll_reset must drop back to the live view (offset 0)",
    );
}

#[test]
fn scroll_clamp() {
    let mut parser = crate::Parser::new(TerminalSize { rows: 3, cols: 80 }, 10);
    for i in 0..6 {
        process(&mut parser, format!("line{i}\r\n").as_bytes());
    }
    let available = parser.screen().scrollback_available();
    // Scroll up beyond available
    parser.screen_mut().scroll_up(100);
    assert_eq!(
        parser.screen().scrollback(),
        available,
        "scroll_up beyond capacity must clamp to scrollback_available, not overflow",
    );
    // Scroll down beyond 0
    parser.screen_mut().scroll_down(200);
    assert_eq!(
        parser.screen().scrollback(),
        0,
        "scroll_down past live must clamp to 0, not wrap underneath",
    );
}

#[test]
fn scroll_to_absolute() {
    let mut parser = crate::Parser::new(TerminalSize { rows: 3, cols: 10 }, 100);
    for i in 0..10 {
        parser.process(format!("line {i}\r\n").as_bytes());
    }
    let available = parser.screen().scrollback_available();
    assert!(available > 0);

    // Set absolute offset
    parser.screen_mut().scroll_to(available);
    assert_eq!(
        parser.screen().scrollback(),
        available,
        "scroll_to(available) should pin the view at the oldest visible row",
    );

    // Back to live
    parser.screen_mut().scroll_to(0);
    assert_eq!(
        parser.screen().scrollback(),
        0,
        "scroll_to(0) should snap back to the live view",
    );

    // Clamp beyond available
    parser.screen_mut().scroll_to(9999);
    assert_eq!(
        parser.screen().scrollback(),
        available,
        "scroll_to(out-of-range) must clamp to available rather than panic or overshoot",
    );
}