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
|
use crossterm::event::{Event, KeyEvent};
use helix_core::{test, Selection, Transaction};
use helix_term::{application::Application, args::Args, config::Config};
use helix_view::{doc, input::parse_macro};
#[derive(Clone, Debug)]
pub struct TestCase {
pub in_text: String,
pub in_selection: Selection,
pub in_keys: String,
pub out_text: String,
pub out_selection: Selection,
}
impl<S: Into<String>> From<(S, S, S)> for TestCase {
fn from((input, keys, output): (S, S, S)) -> Self {
let (in_text, in_selection) = test::print(&input.into());
let (out_text, out_selection) = test::print(&output.into());
TestCase {
in_text,
in_selection,
in_keys: keys.into(),
out_text,
out_selection,
}
}
}
pub fn test_key_sequence<T: Into<TestCase>>(
app: Option<Application>,
test_case: T,
test_fn: &dyn Fn(&mut Application),
) -> anyhow::Result<()> {
let test_case = test_case.into();
let mut app =
app.unwrap_or_else(|| Application::new(Args::default(), Config::default()).unwrap());
let (view, doc) = helix_view::current!(app.editor);
let sel = doc.selection(view.id).clone();
// replace the initial text with the input text
doc.apply(
&Transaction::change_by_selection(&doc.text(), &sel, |_| {
(0, doc.text().len_chars(), Some((&test_case.in_text).into()))
})
.with_selection(test_case.in_selection.clone()),
view.id,
);
let input_keys = parse_macro(&test_case.in_keys)?
.into_iter()
.map(|key_event| Event::Key(KeyEvent::from(key_event)));
for key in input_keys {
app.handle_terminal_events(Ok(key));
}
test_fn(&mut app);
Ok(())
}
/// Use this for very simple test cases where there is one input
/// document, selection, and sequence of key presses, and you just
/// want to verify the resulting document and selection.
pub fn test_key_sequence_text_result<T: Into<TestCase>>(
args: Args,
config: Config,
test_case: T,
) -> anyhow::Result<()> {
let test_case = test_case.into();
let app = Application::new(args, config).unwrap();
test_key_sequence(Some(app), test_case.clone(), &|app| {
let doc = doc!(app.editor);
assert_eq!(&test_case.out_text, doc.text());
let mut selections: Vec<_> = doc.selections().values().cloned().collect();
assert_eq!(1, selections.len());
let sel = selections.pop().unwrap();
assert_eq!(test_case.out_selection, sel);
})?;
Ok(())
}
|
