565 lines
20 KiB
Rust
565 lines
20 KiB
Rust
use crossterm::event::{Event, KeyCode as K, KeyEvent, KeyModifiers as M};
|
|
use std::{
|
|
fs,
|
|
path::PathBuf,
|
|
sync::atomic::{AtomicUsize, Ordering},
|
|
};
|
|
use tb_ide::{
|
|
app::{App, DialogKind, Execution, Field, WindowKind},
|
|
commands::Command,
|
|
};
|
|
use tb_runtime::{snapshot, value::Value};
|
|
struct Temp(PathBuf);
|
|
impl Temp {
|
|
fn new() -> Self {
|
|
static N: AtomicUsize = AtomicUsize::new(0);
|
|
let p = std::env::temp_dir().join(format!(
|
|
"tb-execution-{}-{}",
|
|
std::process::id(),
|
|
N.fetch_add(1, Ordering::Relaxed)
|
|
));
|
|
fs::create_dir_all(&p).unwrap();
|
|
Self(p.canonicalize().unwrap())
|
|
}
|
|
fn app(&self, source: &str) -> App {
|
|
let path = self.0.join("main.bas");
|
|
fs::write(&path, source).unwrap();
|
|
let mut app = App::new(&self.0, self.0.join("options"), (100, 30)).unwrap();
|
|
app.load_initial_project(path).unwrap();
|
|
app.options.syntax_checking = false;
|
|
app
|
|
}
|
|
}
|
|
impl Drop for Temp {
|
|
fn drop(&mut self) {
|
|
let _ = fs::remove_dir_all(&self.0);
|
|
}
|
|
}
|
|
fn key(a: &mut App, k: K, m: M) {
|
|
a.handle(Event::Key(KeyEvent::new(k, m)));
|
|
}
|
|
fn tick(a: &mut App) {
|
|
for _ in 0..20 {
|
|
a.tick_execution(0);
|
|
}
|
|
}
|
|
fn output(a: &App) -> String {
|
|
snapshot::text(a.session.screen())
|
|
}
|
|
fn edit_window(a: &mut App) {
|
|
let id = a
|
|
.windows
|
|
.iter()
|
|
.find(|w| matches!(w.kind, WindowKind::Code(_)))
|
|
.unwrap()
|
|
.id;
|
|
a.execute(Command::FocusWindow(id));
|
|
}
|
|
#[test]
|
|
fn f5_input_pause_copy_and_single_delivery_keep_the_same_vm() {
|
|
let t = Temp::new();
|
|
let mut a = t.app("LINE INPUT \"Name: \"; s$\nPRINT s$\nEND\n");
|
|
key(&mut a, K::F(5), M::NONE);
|
|
tick(&mut a);
|
|
assert_eq!(a.execution, Execution::Waiting);
|
|
key(&mut a, K::Char('a'), M::NONE);
|
|
tick(&mut a);
|
|
edit_window(&mut a);
|
|
key(&mut a, K::Char('a'), M::CONTROL);
|
|
key(&mut a, K::Char('c'), M::CONTROL);
|
|
assert!(a.editor.clipboard.starts_with("LINE INPUT"));
|
|
assert_eq!(a.execution, Execution::Waiting);
|
|
key(&mut a, K::Pause, M::CONTROL);
|
|
assert_eq!(a.execution, Execution::Paused);
|
|
assert!(a.message.contains("main.bas"));
|
|
key(&mut a, K::F(5), M::NONE);
|
|
assert!(a.dialog.is_none());
|
|
a.execute(Command::Output);
|
|
key(&mut a, K::Char('b'), M::NONE);
|
|
key(&mut a, K::Enter, M::NONE);
|
|
tick(&mut a);
|
|
assert_eq!(a.execution, Execution::Ended, "{}", a.message);
|
|
assert_eq!(output(&a), "Name: ? ab\nab\n");
|
|
assert!(!a.quit);
|
|
assert!(a.session.vm.is_none());
|
|
key(&mut a, K::F(5), M::SHIFT);
|
|
tick(&mut a);
|
|
key(&mut a, K::Char('c'), M::CONTROL);
|
|
tick(&mut a);
|
|
assert_eq!(a.execution, Execution::Paused);
|
|
assert_eq!(output(&a), "Name: ? \n");
|
|
}
|
|
#[test]
|
|
fn changed_paused_source_requires_explicit_old_revision_or_restart() {
|
|
let t = Temp::new();
|
|
let mut a = t.app("STOP\nPRINT \"old\"\nEND\n");
|
|
a.execute(Command::Start);
|
|
tick(&mut a);
|
|
assert_eq!(a.execution, Execution::Paused);
|
|
let id = a.project.members()[0];
|
|
a.project
|
|
.replace_text(
|
|
id,
|
|
0..a.project.document(id).unwrap().code().len(),
|
|
"STOP\nPRINT \"new\"\nEND\n",
|
|
)
|
|
.unwrap();
|
|
a.execute(Command::Continue);
|
|
assert!(matches!(
|
|
a.dialog.as_ref().unwrap().kind,
|
|
DialogKind::ResumeRevision
|
|
));
|
|
a.dialog.as_mut().unwrap().fields[0] =
|
|
Field::choice("Fortsetzen", vec!["restart".into(), "old".into()], 1);
|
|
key(&mut a, K::Enter, M::NONE);
|
|
assert!(a.session.old_revision);
|
|
assert!(a
|
|
.title(a.active_window().unwrap())
|
|
.contains("ALTES KOMPILAT"));
|
|
tick(&mut a);
|
|
assert_eq!(output(&a), "old\n");
|
|
a.execute(Command::Restart);
|
|
tick(&mut a);
|
|
a.project
|
|
.replace_text(
|
|
id,
|
|
0..a.project.document(id).unwrap().code().len(),
|
|
"' comment\nPRINT \"latest\"\nEND\n",
|
|
)
|
|
.unwrap();
|
|
a.execute(Command::Continue);
|
|
key(&mut a, K::Enter, M::NONE);
|
|
tick(&mut a);
|
|
assert_eq!(output(&a), "latest\n");
|
|
assert!(!a.session.old_revision);
|
|
a.project
|
|
.replace_text(
|
|
id,
|
|
0..a.project.document(id).unwrap().code().len(),
|
|
"PRINT (\n",
|
|
)
|
|
.unwrap();
|
|
a.execute(Command::Start);
|
|
assert_eq!(a.execution, Execution::Error);
|
|
assert!(a.session.vm.is_none());
|
|
}
|
|
#[test]
|
|
fn output_viewports_resize_and_end_preserve_buffer_and_basic_colors() {
|
|
let t = Temp::new();
|
|
let mut a = t.app("COLOR 4,1\nPRINT \"visible\"\nSTOP\nEND\n");
|
|
a.execute(Command::Start);
|
|
tick(&mut a);
|
|
let original = output(&a);
|
|
let size = (a.session.screen().cols(), a.session.screen().rows());
|
|
let active = a.active;
|
|
let w = a.windows.iter_mut().find(|w| w.id == active).unwrap();
|
|
w.normal = ratatui::layout::Rect::new(3, 3, 30, 8);
|
|
let mut terminal = ratatui::Terminal::new(ratatui::backend::TestBackend::new(100, 30)).unwrap();
|
|
terminal.draw(|f| a.render(f)).unwrap();
|
|
assert_eq!(terminal.backend().buffer()[(4, 4)].symbol(), "v");
|
|
assert_eq!(
|
|
terminal.backend().buffer()[(4, 4)].fg,
|
|
tb_ui::screen::basic_color(4)
|
|
);
|
|
key(&mut a, K::F(4), M::NONE);
|
|
terminal.draw(|f| a.render(f)).unwrap();
|
|
assert_eq!(terminal.backend().buffer()[(0, 0)].symbol(), "v");
|
|
assert_eq!((a.session.screen().cols(), a.session.screen().rows()), size);
|
|
a.handle(Event::Resize(120, 40));
|
|
assert_eq!(
|
|
(a.session.screen().cols(), a.session.screen().rows()),
|
|
(120, 40)
|
|
);
|
|
key(&mut a, K::F(4), M::NONE);
|
|
a.execute(Command::Continue);
|
|
tick(&mut a);
|
|
assert_eq!(a.execution, Execution::Ended);
|
|
assert_eq!(output(&a), original);
|
|
}
|
|
#[test]
|
|
fn restart_command_run_targets_and_missing_target_preserve_documents() {
|
|
let t = Temp::new();
|
|
let mut a = t.app("PRINT COMMAND$\nn%=n%+1\nSTOP\nEND\n");
|
|
a.execute(Command::CommandLine);
|
|
a.dialog.as_mut().unwrap().fields[0] = Field::text("args", "one two");
|
|
key(&mut a, K::Enter, M::NONE);
|
|
for _ in 0..3 {
|
|
a.execute(Command::Restart);
|
|
tick(&mut a);
|
|
assert_eq!(output(&a), "one two\n");
|
|
assert!(matches!(
|
|
a.session.vm.as_ref().unwrap().inspect("n"),
|
|
Some(Value::Int(1))
|
|
));
|
|
}
|
|
let id = a.project.members()[0];
|
|
let path = a.project.document(id).unwrap().source_path().to_path_buf();
|
|
fs::write(t.0.join("other.bas"), "PRINT \"foreign\"\nEND\n").unwrap();
|
|
a.project
|
|
.replace_text(
|
|
id,
|
|
0..a.project.document(id).unwrap().code().len(),
|
|
"RUN \"OTHER\"\n",
|
|
)
|
|
.unwrap();
|
|
a.execute(Command::Start);
|
|
tick(&mut a);
|
|
assert_eq!(output(&a), "foreign\n");
|
|
assert_eq!(a.project.document(id).unwrap().source_path(), path);
|
|
assert_eq!(a.project.document(id).unwrap().code(), "RUN \"OTHER\"\n");
|
|
a.project
|
|
.replace_text(
|
|
id,
|
|
0..a.project.document(id).unwrap().code().len(),
|
|
"RUN \"missing\"\n",
|
|
)
|
|
.unwrap();
|
|
a.execute(Command::Start);
|
|
tick(&mut a);
|
|
assert_eq!(a.execution, Execution::Error);
|
|
assert!(a.message.contains("nicht gefunden"));
|
|
assert_eq!(a.project.document(id).unwrap().code(), "RUN \"missing\"\n");
|
|
assert!(!a.quit);
|
|
a.project
|
|
.replace_text(
|
|
id,
|
|
0..a.project.document(id).unwrap().code().len(),
|
|
"10 PRINT \"skip\"\n20 STOP\n30 RUN 40\n40 PRINT \"target\"\n50 END\n",
|
|
)
|
|
.unwrap();
|
|
a.execute(Command::Start);
|
|
tick(&mut a);
|
|
a.execute(Command::Continue);
|
|
tick(&mut a);
|
|
assert_eq!(output(&a), "target\n");
|
|
}
|
|
#[test]
|
|
fn print_uses_utf8_protected_output_and_does_not_mutate_source() {
|
|
let t = Temp::new();
|
|
let mut a = t.app("PRINT \"Grüße\"\n");
|
|
let id = a.project.members()[0];
|
|
let WindowKind::Code(v) = a.active_window().unwrap().kind else {
|
|
panic!()
|
|
};
|
|
a.project.view_mut(v).unwrap().anchor = Some(0);
|
|
a.project.view_mut(v).unwrap().cursor = 5;
|
|
a.execute(Command::Print);
|
|
assert!(a.dialog.as_ref().unwrap().fields[0]
|
|
.string()
|
|
.ends_with("LPT1.TXT"));
|
|
key(&mut a, K::Enter, M::NONE);
|
|
assert_eq!(fs::read_to_string(t.0.join("LPT1.TXT")).unwrap(), "PRINT");
|
|
a.execute(Command::Print);
|
|
key(&mut a, K::Enter, M::NONE);
|
|
assert!(!a.dialog.as_ref().unwrap().error.is_empty());
|
|
a.dialog.as_mut().unwrap().fields[1] = Field::toggle("overwrite", true);
|
|
a.dialog.as_mut().unwrap().fields[2] = Field::toggle("selection", false);
|
|
key(&mut a, K::Enter, M::NONE);
|
|
assert_eq!(
|
|
fs::read_to_string(t.0.join("LPT1.TXT")).unwrap(),
|
|
"PRINT \"Grüße\"\n"
|
|
);
|
|
a.execute(Command::Print);
|
|
a.dialog.as_mut().unwrap().fields[0] =
|
|
Field::text("path", t.0.join("main.bas").display().to_string());
|
|
a.dialog.as_mut().unwrap().fields[1] = Field::toggle("overwrite", true);
|
|
key(&mut a, K::Enter, M::NONE);
|
|
assert!(!a.dialog.as_ref().unwrap().error.is_empty());
|
|
assert_eq!(a.project.document(id).unwrap().code(), "PRINT \"Grüße\"\n");
|
|
assert_eq!(
|
|
fs::read_to_string(t.0.join("main.bas")).unwrap(),
|
|
"PRINT \"Grüße\"\n"
|
|
);
|
|
key(&mut a, K::Esc, M::NONE);
|
|
fs::write(t.0.join("blocked"), "existing destination parent").unwrap();
|
|
a.execute(Command::Print);
|
|
a.dialog.as_mut().unwrap().fields[0] =
|
|
Field::text("path", t.0.join("blocked/print.txt").display().to_string());
|
|
key(&mut a, K::Enter, M::NONE);
|
|
assert!(!a.dialog.as_ref().unwrap().error.is_empty());
|
|
assert_eq!(
|
|
fs::read_to_string(t.0.join("blocked")).unwrap(),
|
|
"existing destination parent"
|
|
);
|
|
assert_eq!(a.project.document(id).unwrap().code(), "PRINT \"Grüße\"\n");
|
|
}
|
|
#[test]
|
|
fn shell_request_is_resumed_once_and_error_is_basic_error() {
|
|
let t = Temp::new();
|
|
let mut a = t.app("PRINT SHELL(\"exit 7\")\nEND\n");
|
|
a.execute(Command::Start);
|
|
tick(&mut a);
|
|
assert_eq!(
|
|
a.session.host.shell_request.take().as_deref(),
|
|
Some("exit 7")
|
|
);
|
|
a.session.host.shell_result = Some(Ok(7));
|
|
tick(&mut a);
|
|
assert_eq!(output(&a), " 7 \n");
|
|
assert!(a.session.host.shell_request.is_none());
|
|
a.execute(Command::Start);
|
|
tick(&mut a);
|
|
a.session.host.shell_request = None;
|
|
a.session.host.shell_result = Some(Err(tb_runtime::errors::RuntimeError(53)));
|
|
tick(&mut a);
|
|
assert_eq!(a.execution, Execution::Error);
|
|
assert!(a.message.contains("53"));
|
|
}
|
|
#[test]
|
|
fn startup_selection_matches_shared_cli_pipeline_and_legacy_mak() {
|
|
use tb_vm::project_io::{new_execution, SourceLoader};
|
|
let t = Temp::new();
|
|
fs::write(t.0.join("a.bas"), "PRINT \"A\"\n").unwrap();
|
|
fs::write(t.0.join("b.bas"), "PRINT \"B\"\n").unwrap();
|
|
for (file, name) in [("one.frm", "One"), ("two.frm", "Two")] {
|
|
fs::write(
|
|
t.0.join(file),
|
|
format!("VERSION 1.00\nBEGIN Form {name}\nEND\n"),
|
|
)
|
|
.unwrap();
|
|
}
|
|
for startup in [None, Some("b.bas"), Some("two.frm")] {
|
|
fs::write(
|
|
t.0.join("p.mak"),
|
|
format!(
|
|
"a.bas\nb.bas\none.frm\ntwo.frm\n{}",
|
|
startup
|
|
.map(|s| format!("' $STARTUP: \"{s}\"\n"))
|
|
.unwrap_or_default()
|
|
),
|
|
)
|
|
.unwrap();
|
|
let mut a = App::new(&t.0, t.0.join("options"), (80, 25)).unwrap();
|
|
a.load_initial_project(t.0.join("p.mak")).unwrap();
|
|
a.session.command = "args".into();
|
|
a.execute(Command::Start);
|
|
let sources = SourceLoader::default().load(&t.0.join("p.mak")).unwrap();
|
|
let module = sources.compile(&mut Default::default(), "CLI").unwrap();
|
|
let module = tb_vm::bytecode::CompiledModule::from_tbc(&module.to_tbc()).unwrap();
|
|
let mut cli = new_execution(module, "args", Some((80, 25)), None).unwrap();
|
|
let ide = a.session.vm.as_ref().unwrap();
|
|
assert_eq!(ide.rt.command, cli.rt.command);
|
|
assert_eq!(ide.forms.active_form(), cli.forms.active_form());
|
|
assert_eq!(ide.forms.has_visible_forms(), startup != Some("b.bas"));
|
|
assert_eq!(
|
|
sources.units[0].name.to_ascii_uppercase(),
|
|
if startup == Some("two.frm") {
|
|
"TWO"
|
|
} else if startup == Some("b.bas") {
|
|
"B"
|
|
} else {
|
|
"A"
|
|
}
|
|
);
|
|
if startup == Some("b.bas") {
|
|
tick(&mut a);
|
|
assert_eq!(
|
|
cli.run(&mut tb_runtime::host::CaptureHost::default()),
|
|
tb_vm::interp::RunEvent::Ended
|
|
);
|
|
assert_eq!(output(&a), "B\nA\n");
|
|
assert_eq!(output(&a), snapshot::text(&cli.rt.screen));
|
|
}
|
|
}
|
|
}
|
|
#[test]
|
|
fn ide_and_cli_run_wrapper_match_input_time_and_forms_script() {
|
|
let t = Temp::new();
|
|
let form="VERSION 1.00\nBEGIN Form Form1\n BEGIN Timer Timer1\n END\nEND\nTimer1.Interval=100\nTimer1.Enabled=-1\nSLEEP 10\nForm1.Hide\nCLS\nLINE INPUT s$\nPRINT s$; COMMAND$\nEND\nSUB Timer1_Timer\nTimer1.Enabled=0\nEND SUB\n";
|
|
fs::write(t.0.join("form.frm"), form).unwrap();
|
|
let mut a = App::new(&t.0, t.0.join("options"), (80, 25)).unwrap();
|
|
a.load_initial_project(t.0.join("form.frm")).unwrap();
|
|
a.session.command = "!".into();
|
|
a.execute(Command::Start);
|
|
a.tick_execution(0);
|
|
assert_eq!(a.execution, Execution::Waiting);
|
|
a.tick_execution(100);
|
|
a.handle(Event::Paste("hello\n".into()));
|
|
for _ in 0..20 {
|
|
a.tick_execution(100);
|
|
}
|
|
assert_eq!(a.execution, Execution::Ended, "{}", a.message);
|
|
// CLI wrapper gets the same scripted input at the same host deadline.
|
|
struct ScriptHost {
|
|
now: u64,
|
|
events: std::collections::VecDeque<tb_runtime::host::Ereignis>,
|
|
}
|
|
impl tb_runtime::host::Host for ScriptHost {
|
|
fn present(&mut self, _: &tb_runtime::screen::TextScreen) {}
|
|
fn next_event(&mut self, _: bool) -> Option<tb_runtime::host::Ereignis> {
|
|
self.events.pop_front()
|
|
}
|
|
fn jetzt_ms(&mut self) -> u64 {
|
|
self.now
|
|
}
|
|
fn warten(&mut self, deadline: Option<u64>) -> Option<tb_runtime::host::Ereignis> {
|
|
if let Some(d) = deadline {
|
|
self.now = d;
|
|
None
|
|
} else {
|
|
self.events.extend(
|
|
"hello\r"
|
|
.chars()
|
|
.map(|c| tb_runtime::host::Ereignis::Taste(c.to_string(), 0)),
|
|
);
|
|
self.events.pop_front()
|
|
}
|
|
}
|
|
}
|
|
let module = tb_vm::project_io::load_program(&t.0.join("form.frm")).unwrap();
|
|
let mut cli = tb_vm::project_io::new_execution(module, "!", Some((80, 25)), None).unwrap();
|
|
assert_eq!(
|
|
cli.run(&mut ScriptHost {
|
|
now: 0,
|
|
events: Default::default()
|
|
}),
|
|
tb_vm::interp::RunEvent::Ended
|
|
);
|
|
assert_eq!(output(&a), snapshot::text(&cli.rt.screen));
|
|
assert_eq!(output(&a), "? hello\nhello!\n");
|
|
}
|
|
|
|
#[test]
|
|
fn restart_drops_files_data_traps_and_queued_actions() {
|
|
let t = Temp::new();
|
|
let mut a=t.app(&format!("DATA 7\nSTOP\nREAD n%\nOPEN \"{}\" FOR OUTPUT AS #1\nON TIMER(1) GOSUB H\nTIMER ON\nSTOP\nEND\nH:\nRETURN\n",t.0.join("opened.txt").display()));
|
|
a.execute(Command::Shell);
|
|
assert!(a.session.file_shell);
|
|
a.execute(Command::Start);
|
|
tick(&mut a);
|
|
assert!(!a.session.file_shell);
|
|
assert!(a.session.host.shell_request.is_none());
|
|
for _ in 0..3 {
|
|
let vm = a.session.vm.as_ref().unwrap();
|
|
assert!(!vm.rt.dateien.ist_offen(1));
|
|
assert_eq!(vm.rt.traps.naechste_frist(), None);
|
|
assert!(matches!(vm.inspect("n"), Some(Value::Int(0))));
|
|
a.execute(Command::Continue);
|
|
tick(&mut a);
|
|
let vm = a.session.vm.as_ref().unwrap();
|
|
assert!(vm.rt.dateien.ist_offen(1));
|
|
assert!(vm.rt.traps.naechste_frist().is_some());
|
|
assert!(matches!(vm.inspect("n"), Some(Value::Int(7))));
|
|
a.session
|
|
.host
|
|
.events
|
|
.push_back(tb_runtime::host::Ereignis::Taste("stale".into(), 0));
|
|
a.execute(Command::Restart);
|
|
tick(&mut a);
|
|
assert!(a.session.host.events.is_empty());
|
|
}
|
|
}
|
|
#[test]
|
|
fn named_run_of_current_target_uses_edited_sources() {
|
|
let t = Temp::new();
|
|
let mut a = t.app("PRINT \"disk\"\nEND\n");
|
|
let id = a.project.members()[0];
|
|
a.project
|
|
.replace_text(
|
|
id,
|
|
0..a.project.document(id).unwrap().code().len(),
|
|
"RUN \"MAIN.BAS\"\n",
|
|
)
|
|
.unwrap();
|
|
a.execute(Command::Start);
|
|
a.tick_execution(0);
|
|
assert!(a.session.project_target);
|
|
a.project
|
|
.replace_text(
|
|
id,
|
|
0..a.project.document(id).unwrap().code().len(),
|
|
"PRINT \"edited\"\nEND\n",
|
|
)
|
|
.unwrap();
|
|
tick(&mut a);
|
|
assert_eq!(output(&a), "edited\n");
|
|
}
|
|
#[test]
|
|
fn explicit_end_and_system_end_visible_forms_but_natural_end_keeps_them_live() {
|
|
let t = Temp::new();
|
|
for ending in ["END", "SYSTEM", ""] {
|
|
let path = t.0.join("form.frm");
|
|
fs::write(
|
|
&path,
|
|
format!("VERSION 1.00\nBEGIN Form Form1\nEND\n{ending}\n"),
|
|
)
|
|
.unwrap();
|
|
let mut a = App::new(&t.0, t.0.join("options"), (80, 25)).unwrap();
|
|
a.load_initial_project(path).unwrap();
|
|
a.execute(Command::Start);
|
|
assert!(a.session.vm.as_ref().unwrap().forms.has_visible_forms());
|
|
tick(&mut a);
|
|
if ending.is_empty() {
|
|
assert_eq!(a.execution, Execution::Waiting);
|
|
key(&mut a, K::F(4), M::NONE);
|
|
assert!(a.session.fullscreen);
|
|
a.handle(Event::Resize(40, 10));
|
|
key(&mut a, K::Pause, M::CONTROL);
|
|
assert_eq!(a.execution, Execution::Paused);
|
|
a.handle(Event::Resize(80, 25));
|
|
key(&mut a, K::F(5), M::NONE);
|
|
tick(&mut a);
|
|
assert_eq!(a.execution, Execution::Waiting);
|
|
assert!(a.session.vm.as_ref().unwrap().forms.has_visible_forms());
|
|
} else {
|
|
assert_eq!(a.execution, Execution::Ended);
|
|
assert!(a.session.vm.is_none());
|
|
}
|
|
assert!(!a.quit);
|
|
}
|
|
}
|
|
#[test]
|
|
fn comment_only_source_change_also_requires_revision_choice() {
|
|
let t = Temp::new();
|
|
let mut a = t.app("STOP ' old\nPRINT 1\nEND\n");
|
|
a.execute(Command::Start);
|
|
tick(&mut a);
|
|
let compiled = a.current_compilation().unwrap().to_tbc();
|
|
let id = a.project.members()[0];
|
|
a.project
|
|
.replace_text(
|
|
id,
|
|
0..a.project.document(id).unwrap().code().len(),
|
|
"STOP ' new\nPRINT 1\nEND\n",
|
|
)
|
|
.unwrap();
|
|
assert_eq!(a.compile_current().unwrap().to_tbc(), compiled);
|
|
a.execute(Command::Continue);
|
|
assert!(matches!(
|
|
a.dialog.as_ref().unwrap().kind,
|
|
DialogKind::ResumeRevision
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn platform_probe_records_each_basic_key_once_and_keeps_ide_keys_out() {
|
|
let t = Temp::new();
|
|
let log = t.0.join("platform-events.log");
|
|
let source = include_str!("../../../tests/platform/input.frm")
|
|
.replace("platform-events.log", &log.to_string_lossy());
|
|
let path = t.0.join("input.frm");
|
|
fs::write(&path, source).unwrap();
|
|
let mut a = t.app("");
|
|
a.load_initial_project(path).unwrap();
|
|
a.execute(Command::Start);
|
|
tick(&mut a);
|
|
key(&mut a, K::Char('a'), M::NONE);
|
|
tick(&mut a);
|
|
a.handle(Event::Key(KeyEvent::new_with_kind(
|
|
K::Char('a'),
|
|
M::NONE,
|
|
crossterm::event::KeyEventKind::Release,
|
|
)));
|
|
tick(&mut a);
|
|
let events = fs::read_to_string(&log).unwrap();
|
|
assert_eq!(
|
|
events.replace('\r', ""),
|
|
"Down: 97 : 0 \nPress: 97 : 0 \nUp: 97 : 0 \n"
|
|
);
|
|
edit_window(&mut a);
|
|
key(&mut a, K::F(1), M::NONE);
|
|
tick(&mut a);
|
|
assert_eq!(fs::read_to_string(&log).unwrap(), events);
|
|
assert!(matches!(a.active_window().unwrap().kind, WindowKind::Help));
|
|
}
|