rust-expect 0.1.0

Next-generation Expect-style terminal automation library for Rust
Documentation 
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

//! Integration tests for send utilities.

use std::time::Duration;

use rust_expect::{ControlChar, HumanTypingConfig};

#[test]
fn control_char_ctrl_c() {
    assert_eq!(ControlChar::CtrlC.as_byte(), 3);
}

#[test]
fn control_char_ctrl_d() {
    assert_eq!(ControlChar::CtrlD.as_byte(), 4);
}

#[test]
fn control_char_ctrl_z() {
    assert_eq!(ControlChar::CtrlZ.as_byte(), 26);
}

#[test]
fn control_char_escape() {
    let esc = ControlChar::Escape;
    assert_eq!(esc.as_byte(), 27);
}

#[test]
fn control_char_tab() {
    // Tab is Ctrl+I
    let tab = ControlChar::CtrlI;
    assert_eq!(tab.as_byte(), 9);
}

#[test]
fn control_char_enter() {
    // Enter/CR is Ctrl+M
    let enter = ControlChar::CtrlM;
    assert_eq!(enter.as_byte(), 13);
}

#[test]
fn control_char_backspace() {
    // Backspace is Ctrl+H
    let backspace = ControlChar::CtrlH;
    assert_eq!(backspace.as_byte(), 8);
}

#[test]
fn control_char_from_char() {
    assert_eq!(ControlChar::from_char('c'), Some(ControlChar::CtrlC));
    assert_eq!(ControlChar::from_char('C'), Some(ControlChar::CtrlC));
    assert_eq!(ControlChar::from_char('d'), Some(ControlChar::CtrlD));
    assert_eq!(ControlChar::from_char('z'), Some(ControlChar::CtrlZ));
    assert_eq!(ControlChar::from_char('?'), None);
}

#[test]
fn control_char_into_u8() {
    let byte: u8 = ControlChar::CtrlC.into();
    assert_eq!(byte, 3);
}

#[test]
fn basic_send_format_line() {
    // Test that line formatting includes line ending
    let line = "echo hello";
    let formatted = format!("{line}\n");
    assert!(formatted.ends_with('\n'));
}

#[test]
fn human_typing_config_default() {
    let config = HumanTypingConfig::default();
    assert_eq!(config.base_delay, Duration::from_millis(100));
    assert_eq!(config.variance, Duration::from_millis(50));
}

#[test]
fn human_typing_config_custom() {
    let config = HumanTypingConfig::new(Duration::from_millis(50), Duration::from_millis(25))
        .typo_chance(0.02)
        .correction_chance(0.9);

    assert_eq!(config.base_delay, Duration::from_millis(50));
    assert_eq!(config.variance, Duration::from_millis(25));
}

#[test]
fn control_char_all_variants() {
    // Test all control characters have valid byte values
    let chars = [
        ControlChar::CtrlA,
        ControlChar::CtrlB,
        ControlChar::CtrlC,
        ControlChar::CtrlD,
        ControlChar::CtrlE,
        ControlChar::CtrlF,
        ControlChar::CtrlG,
        ControlChar::CtrlH,
        ControlChar::CtrlI,
        ControlChar::CtrlJ,
        ControlChar::CtrlK,
        ControlChar::CtrlL,
        ControlChar::CtrlM,
        ControlChar::CtrlN,
        ControlChar::CtrlO,
        ControlChar::CtrlP,
        ControlChar::CtrlQ,
        ControlChar::CtrlR,
        ControlChar::CtrlS,
        ControlChar::CtrlT,
        ControlChar::CtrlU,
        ControlChar::CtrlV,
        ControlChar::CtrlW,
        ControlChar::CtrlX,
        ControlChar::CtrlY,
        ControlChar::CtrlZ,
        ControlChar::Escape,
    ];

    for (i, ctrl) in chars.iter().enumerate() {
        let expected = if i < 26 { (i + 1) as u8 } else { 27 };
        assert_eq!(ctrl.as_byte(), expected);
    }
}