910 lines
35 KiB
Rust
910 lines
35 KiB
Rust
//! Regressionen zu Ereigniszustellung, Hostgrenzen und Forms-Zustand.
|
||
use tb_frontend::forms::{FormCatalog, ObjectClass};
|
||
use tb_runtime::host::{CaptureHost, Ereignis, Host, MausArt, MausEreignis};
|
||
use tb_runtime::screen::TextScreen;
|
||
use tb_runtime::value::Value;
|
||
use tb_vm::interp::{RunEvent, Vm};
|
||
|
||
#[path = "../../../tests/support/prozessfrist.rs"]
|
||
mod prozessfrist;
|
||
|
||
fn vm(src: &str) -> Vm {
|
||
let mut catalog = FormCatalog::default();
|
||
catalog.add("Form1", ObjectClass::Form, None, false);
|
||
catalog.add("Text1", ObjectClass::TextBox, Some("Form1"), false);
|
||
catalog.add("Text2", ObjectClass::TextBox, Some("Form1"), false);
|
||
catalog.add("Timer1", ObjectClass::Timer, Some("Form1"), false);
|
||
catalog.add("Menu1", ObjectClass::Menu, Some("Form1"), false);
|
||
catalog.add("Item1", ObjectClass::Menu, Some("Menu1"), false);
|
||
Vm::new(
|
||
tb_vm::compile_source_with_forms("FORM1", src, &catalog)
|
||
.unwrap_or_else(|d| panic!("{d:?}")),
|
||
)
|
||
}
|
||
|
||
fn stop(vm: &mut Vm, host: &mut dyn Host) {
|
||
assert!(matches!(vm.run(host), RunEvent::Stopped { .. }));
|
||
}
|
||
|
||
fn string(vm: &Vm, name: &str) -> String {
|
||
match vm.inspect(name) {
|
||
Some(Value::Str(s)) => s.to_string(),
|
||
other => panic!("{other:?}"),
|
||
}
|
||
}
|
||
|
||
fn integer(vm: &Vm, name: &str) -> i16 {
|
||
match vm.inspect(name) {
|
||
Some(Value::Int(n)) => n,
|
||
other => panic!("{other:?}"),
|
||
}
|
||
}
|
||
|
||
fn key(s: &str) -> Ereignis {
|
||
Ereignis::Taste(s.into(), 0)
|
||
}
|
||
fn mouse() -> Ereignis {
|
||
Ereignis::Maus(MausEreignis {
|
||
art: MausArt::Druck,
|
||
taste: 1,
|
||
shift: 0,
|
||
zeile: 1,
|
||
spalte: 1,
|
||
})
|
||
}
|
||
|
||
#[test]
|
||
fn beide_signale_werden_zugestellt_und_beginnen_in_quellreihenfolge() {
|
||
let mut vm = vm("ON SIGNAL(1) GOSUB IntHandler\nON SIGNAL(2) GOSUB TermHandler\nSIGNAL(1) ON\nSIGNAL(2) ON\nSTOP\nDOEVENTS\nEND\nIntHandler:\ns$ = s$ + \"1\"\nRETURN\nTermHandler:\ns$ = s$ + \"2\"\nRETURN");
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host);
|
||
host.ereignis(Ereignis::Signal(2));
|
||
host.ereignis(Ereignis::Signal(1));
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(string(&vm, "s"), "12");
|
||
for n in [0, 3] {
|
||
assert!(
|
||
tb_vm::compile_source("TEST", &format!("ON SIGNAL({n}) GOSUB H\nEND\nH:\nRETURN"))
|
||
.is_err()
|
||
);
|
||
let mut bad = vm_for_source(&format!("n% = {n}\nON SIGNAL(n%) GOSUB H\nEND\nH:\nRETURN"));
|
||
assert!(matches!(
|
||
bad.run(&mut host),
|
||
RunEvent::Error { code: 5, .. }
|
||
));
|
||
}
|
||
}
|
||
|
||
fn vm_for_source(src: &str) -> Vm {
|
||
Vm::new(tb_vm::compile_source("TEST", src).unwrap())
|
||
}
|
||
|
||
#[test]
|
||
fn key_on_off_stop_gelten_fuer_alle_konsoleneingaben() {
|
||
for state in ["ON", "OFF", "STOP"] {
|
||
for input in ["s$ = INKEY$", "INPUT s$", "LINE INPUT s$", "s$ = INPUT$(1)"] {
|
||
let mut vm = vm_for_source(&format!("ON KEY(15) GOSUB H\nKEY 15, CHR$(0) + CHR$(30)\nKEY(15) {state}\nSTOP\n{input}\nKEY(15) ON\nDOEVENTS\nEND\nH:\nn% = n% + 1\nRETURN"));
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host);
|
||
host.ereignis(key("a"));
|
||
if state == "ON" {
|
||
host.ereignis(key("b"));
|
||
}
|
||
host.ereignis(key("\r"));
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended, "{state}: {input}");
|
||
assert_eq!(
|
||
string(&vm, "s"),
|
||
if state == "ON" { "b" } else { "a" },
|
||
"{state}: {input}"
|
||
);
|
||
assert_eq!(
|
||
integer(&vm, "n"),
|
||
if state == "OFF" { 0 } else { 1 },
|
||
"{state}: {input}"
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn taste_maus_und_trap_behalten_die_annahmereihenfolge() {
|
||
for (events, expected) in [
|
||
(vec![key("a"), mouse()], "aM"),
|
||
(vec![mouse(), key("a")], "Ma"),
|
||
(
|
||
vec![key("a"), mouse(), key("b"), key("t"), mouse()],
|
||
"aMbTM",
|
||
),
|
||
] {
|
||
let mut vm = vm("DIM SHARED s$\nON KEY(15) GOSUB H\nKEY 15, CHR$(0) + CHR$(20)\nKEY(15) ON\nForm1.Show\nText1.SetFocus\nSTOP\nn% = DOEVENTS + LEN(s$)\nDOEVENTS\nDOEVENTS\nDOEVENTS\nDOEVENTS\nEND\nH:\ns$ = s$ + \"T\"\nRETURN\nSUB Text1_KeyPress(KeyAscii AS INTEGER)\nSHARED s$\ns$ = s$ + CHR$(KeyAscii)\nEND SUB\nSUB Form_MouseDown(Button AS INTEGER, Shift AS INTEGER, X AS SINGLE, Y AS SINGLE)\nSHARED s$\ns$ = s$ + \"M\"\nEND SUB");
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host);
|
||
for event in events {
|
||
host.ereignis(event);
|
||
}
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(string(&vm, "s"), expected);
|
||
assert!(
|
||
matches!(vm.inspect("n"), Some(Value::Int(n)) if n > 0),
|
||
"DOEVENTS muss vor der Auswertung von LEN zustellen"
|
||
);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn fokus_handler_laufen_geordnet_bis_zur_rueckkehr() {
|
||
let mut vm = vm("DIM SHARED s$\nText1.TabIndex = 0\nText2.TabIndex = 1\nForm1.Show\nText1.SetFocus\nSTOP\nDOEVENTS\nEND\nSUB Text1_LostFocus()\nSHARED s$\ns$ = s$ + \"L\"\ns$ = s$ + \"l\"\nEND SUB\nSUB Text2_GotFocus()\nSHARED s$\ns$ = s$ + \"G\"\ns$ = s$ + \"g\"\nEND SUB");
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host);
|
||
host.ereignis(key("\t"));
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(string(&vm, "s"), "LlGg");
|
||
}
|
||
|
||
#[test]
|
||
fn doevents_verhindert_rekursion_derselben_forms_prozedur() {
|
||
let mut vm = vm("DIM SHARED s$\nForm1.Show\nText1.SetFocus\nSTOP\nDOEVENTS\nEND\nSUB Text1_KeyPress(KeyAscii AS INTEGER)\nSHARED s$\ns$ = s$ + CHR$(KeyAscii)\nDOEVENTS\ns$ = s$ + \"r\"\nEND SUB");
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host);
|
||
host.ereignis(key("a"));
|
||
host.ereignis(key("b"));
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(string(&vm, "s"), "arbr");
|
||
}
|
||
|
||
#[test]
|
||
fn offenes_menu_sperrt_traps_und_wartende_forms_timer_an_allen_zustellpunkten() {
|
||
let mut vm = vm("DIM SHARED n%\nON UEVENT GOSUB H\nUEVENT ON\nMenu1.Caption = \"&Datei\"\nItem1.Caption = \"&Ende\"\nForm1.Show\nSTOP\nCALL SetUEvent\nn% = n% + 1\nDOEVENTS\nSLEEP .001\nLINE INPUT s$\nSTOP\nDOEVENTS\nEND\nH:\nn% = n% + 10\nRETURN\nSUB Timer1_Timer()\nSHARED n%\nn% = n% + 100\nEND SUB");
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host);
|
||
vm.forms.handle_key("d", 4);
|
||
assert!(vm.forms.menu_is_open());
|
||
vm.queue_form_event(tb_ui::forms::FormEvent {
|
||
object: 3,
|
||
array_index: None,
|
||
name: "TIMER".into(),
|
||
args: vec![],
|
||
});
|
||
// Erst die blockierende Konsole holt Enter ab, damit das Menü offen bleibt.
|
||
struct InputHost(CaptureHost);
|
||
impl Host for InputHost {
|
||
fn present(&mut self, s: &TextScreen) {
|
||
self.0.present(s);
|
||
}
|
||
fn next_event(&mut self, block: bool) -> Option<Ereignis> {
|
||
block.then(|| key("\r"))
|
||
}
|
||
fn jetzt_ms(&mut self) -> u64 {
|
||
self.0.jetzt_ms()
|
||
}
|
||
fn warten(&mut self, deadline: Option<u64>) -> Option<Ereignis> {
|
||
if deadline.is_none() {
|
||
self.next_event(true)
|
||
} else {
|
||
self.0.warten(deadline)
|
||
}
|
||
}
|
||
}
|
||
stop(&mut vm, &mut InputHost(CaptureHost::default()));
|
||
assert_eq!(integer(&vm, "n"), 1);
|
||
assert!(vm.forms.menu_is_open());
|
||
host.ereignis(key("\u{1b}"));
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(integer(&vm, "n"), 111);
|
||
}
|
||
|
||
#[test]
|
||
fn ohne_zeitbedarf_keine_uhrabfrage_und_keine_mausansammlung() {
|
||
struct OhneUhr(CaptureHost);
|
||
impl Host for OhneUhr {
|
||
fn present(&mut self, s: &TextScreen) {
|
||
self.0.present(s);
|
||
}
|
||
fn next_event(&mut self, b: bool) -> Option<Ereignis> {
|
||
self.0.next_event(b)
|
||
}
|
||
fn jetzt_ms(&mut self) -> u64 {
|
||
panic!("unerwartete Uhrabfrage")
|
||
}
|
||
fn warten(&mut self, _: Option<u64>) -> Option<Ereignis> {
|
||
panic!("unerwartetes Warten")
|
||
}
|
||
}
|
||
for src in ["a% = 1\na% = 2\nEND", "Form1.Show\na% = 1\nDOEVENTS\nEND"] {
|
||
let mut vm = vm(src);
|
||
let mut host = OhneUhr(CaptureHost::default());
|
||
for _ in 0..500 {
|
||
host.0.ereignis(mouse());
|
||
}
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert!(vm.rt.eingaben.is_empty());
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn sleep_folgt_nur_der_hostfrist_und_forms_timer_beendet_es() {
|
||
let _frist = prozessfrist::Prozessfrist::neu("Host-SLEEP", std::time::Duration::from_secs(5));
|
||
struct WarteHost {
|
||
now: u64,
|
||
deadlines: Vec<Option<u64>>,
|
||
timer: bool,
|
||
}
|
||
impl Host for WarteHost {
|
||
fn present(&mut self, _: &TextScreen) {}
|
||
fn next_event(&mut self, _: bool) -> Option<Ereignis> {
|
||
None
|
||
}
|
||
fn jetzt_ms(&mut self) -> u64 {
|
||
self.now
|
||
}
|
||
fn warten(&mut self, deadline: Option<u64>) -> Option<Ereignis> {
|
||
self.deadlines.push(deadline);
|
||
if self.deadlines.len() == 1 && !self.timer {
|
||
// Reale Zeit verstreicht bei eingefrorener Hostuhr. Erst die
|
||
// folgende Host-Wartephase darf die Deadline erreichen.
|
||
std::thread::sleep(std::time::Duration::from_millis(10));
|
||
return Some(Ereignis::Groesse { cols: 80, rows: 25 });
|
||
}
|
||
self.now = deadline.expect("Deadline fehlt");
|
||
None
|
||
}
|
||
}
|
||
let mut host = WarteHost {
|
||
now: 0,
|
||
deadlines: vec![],
|
||
timer: false,
|
||
};
|
||
let mut plain = vm_for_source("SLEEP .001\nEND");
|
||
assert_eq!(plain.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(host.deadlines, [Some(1), Some(1)]);
|
||
let mut vm = vm("DIM SHARED n%\nForm1.Show\nTimer1.Interval = 100\nTimer1.Enabled = -1\nSLEEP 60\nEND\nSUB Timer1_Timer()\nSHARED n%\nn% = n% + 1\nEND SUB");
|
||
let mut host = WarteHost {
|
||
now: 0,
|
||
deadlines: vec![],
|
||
timer: true,
|
||
};
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(host.deadlines, [Some(100)]);
|
||
assert_eq!(integer(&vm, "n"), 1);
|
||
}
|
||
|
||
#[test]
|
||
fn dialog_erhaelt_stop_markierung_unverbrauchter_tasten() {
|
||
let mut vm = vm_for_source("ON KEY(15) GOSUB H\nKEY 15, CHR$(0) + CHR$(30)\nKEY(15) STOP\nSTOP\nx% = MSGBOX(\"Weiter\")\nKEY(15) ON\nDOEVENTS\ns$ = INKEY$\nEND\nH:\nn% = n% + 1\nRETURN");
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host);
|
||
host.ereignis(key("\r"));
|
||
host.ereignis(key("a"));
|
||
vm.rt.pump(&mut host, false);
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(string(&vm, "s"), "a");
|
||
assert_eq!(integer(&vm, "n"), 1);
|
||
}
|
||
|
||
#[test]
|
||
fn unload_aus_unload_handler_ruft_dieselbe_prozedur_nicht_rekursiv_auf() {
|
||
let mut vm = vm("DIM SHARED s$\nForm1.Show\nUNLOAD Form1\nEND\nSUB Form_Unload(Cancel AS INTEGER)\nSHARED s$\ns$ = s$ + \"u\"\nUNLOAD Form1\ns$ = s$ + \"r\"\nEND SUB");
|
||
assert_eq!(vm.run(&mut CaptureHost::default()), RunEvent::Ended);
|
||
assert_eq!(string(&vm, "s"), "ur");
|
||
assert!(!vm.forms.is_loaded(0));
|
||
}
|
||
|
||
// Nachverifikation V1–V5: unveränderte Sollwerte aus den Review-Proben.
|
||
#[test]
|
||
fn review_signal_waehrend_blockierender_eingabe() {
|
||
struct Input {
|
||
reads: usize,
|
||
}
|
||
impl Host for Input {
|
||
fn present(&mut self, _: &TextScreen) {}
|
||
fn next_event(&mut self, block: bool) -> Option<Ereignis> {
|
||
if !block {
|
||
return None;
|
||
}
|
||
self.reads += 1;
|
||
Some(if self.reads == 1 {
|
||
Ereignis::Signal(2)
|
||
} else {
|
||
Ereignis::Ende
|
||
})
|
||
}
|
||
fn jetzt_ms(&mut self) -> u64 {
|
||
0
|
||
}
|
||
fn warten(&mut self, _: Option<u64>) -> Option<Ereignis> {
|
||
self.next_event(true)
|
||
}
|
||
}
|
||
let mut results = vec![];
|
||
for statement in ["INPUT s$", "LINE INPUT s$", "s$ = INPUT$(1)"] {
|
||
let src =
|
||
format!("ON SIGNAL(2) GOSUB H\nSIGNAL(2) ON\n{statement}\nEND\nH:\nPRINT \"H\"\nEND");
|
||
let mut vm = Vm::new(tb_vm::compile_source("TEST", &src).unwrap());
|
||
let result = vm.run(&mut Input { reads: 0 });
|
||
println!(
|
||
"{statement}: {result:?}; Ausgabe={:?}",
|
||
tb_runtime::snapshot::text(&vm.rt.screen)
|
||
);
|
||
results.push(result);
|
||
}
|
||
assert!(results.iter().all(|result| *result == RunEvent::Ended));
|
||
}
|
||
|
||
#[test]
|
||
fn review_objektargument_darf_gotfocus_nicht_vorziehen() {
|
||
for action in [
|
||
"CALL Mark(Text1)",
|
||
"n% = Text1.TabIndex\nCALL Mark(Text1)",
|
||
"Text1.Text = \"neu\"\nCALL Mark(Text1)",
|
||
"Text1.Refresh\nCALL Mark(Text1)",
|
||
"LOAD Form1\nCALL Mark(Text1)",
|
||
] {
|
||
let mut vm = vm(&format!("DIM SHARED s$\nText1.TabIndex = 0\nText2.TabIndex = 1\nForm1.Show\nText1.SetFocus\nSTOP\nDOEVENTS\nEND\nSUB Text1_LostFocus()\nSHARED s$\n{action}\ns$ = s$ + \"l\"\nEND SUB\nSUB Mark(c AS CONTROL)\nSHARED s$\ns$ = s$ + \"L\"\nEND SUB\nSUB Text2_GotFocus()\nSHARED s$\ns$ = s$ + \"G\"\ns$ = s$ + \"g\"\nEND SUB"));
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host);
|
||
host.ereignis(key("\t"));
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended, "{action}");
|
||
assert_eq!(string(&vm, "s"), "LlGg", "{action}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn review_gleichzeitig_key_und_uevent_behalten_prioritaet() {
|
||
let mut vm = vm("ON KEY(15) GOSUB K\nKEY 15, CHR$(0) + CHR$(20)\nKEY(15) ON\nON UEVENT GOSUB U\nUEVENT ON\nSTOP\nDOEVENTS\nEND\nK:\ns$ = s$ + \"K\"\nRETURN\nU:\ns$ = s$ + \"U\"\nRETURN");
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host);
|
||
host.ereignis(key("t"));
|
||
vm.rt.pump(&mut host, false);
|
||
vm.rt.traps.melden(tb_runtime::traps::Quelle::UEvent);
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(string(&vm, "s"), "KU");
|
||
}
|
||
|
||
#[test]
|
||
fn review_modale_eingabe_vor_eof_wird_zugestellt() {
|
||
let mut vm = vm("DIM SHARED s$\nForm1.Show 1\nEND\nSUB Form_MouseDown(Button AS INTEGER, Shift AS INTEGER, X AS SINGLE, Y AS SINGLE)\nSHARED s$\ns$ = \"M\"\nUNLOAD Form1\nEND SUB");
|
||
let mut host = CaptureHost::default();
|
||
host.ereignis_nach(2, mouse());
|
||
host.ereignis_nach(2, Ereignis::Ende);
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(string(&vm, "s"), "M");
|
||
}
|
||
|
||
#[test]
|
||
fn eof_leert_angenommene_eingaben_bei_modalen_und_modellosen_forms() {
|
||
for modal in [false, true] {
|
||
let show = if modal { "Form1.Show 1" } else { "Form1.Show" };
|
||
let mut vm = vm(&format!("DIM SHARED s$\n{show}\nEND\nSUB Form_MouseDown(Button AS INTEGER, Shift AS INTEGER, X AS SINGLE, Y AS SINGLE)\nSHARED s$\ns$ = s$ + \"M\"\nEND SUB"));
|
||
let mut host = CaptureHost::default();
|
||
if !modal {
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
}
|
||
host.ereignis_nach(2, mouse());
|
||
host.ereignis_nach(2, mouse());
|
||
host.ereignis_nach(2, Ereignis::Ende);
|
||
let result = if modal {
|
||
vm.run(&mut host)
|
||
} else {
|
||
vm.run_visible_forms(&mut host)
|
||
};
|
||
assert_eq!(result, RunEvent::Ended, "modal={modal}");
|
||
assert_eq!(string(&vm, "s"), "MM", "modal={modal}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn review_menu_schliessen_stellt_pending_trap_vor_erneutem_warten_zu() {
|
||
struct MenuHost {
|
||
time: u64,
|
||
waits: usize,
|
||
}
|
||
impl Host for MenuHost {
|
||
fn present(&mut self, _: &TextScreen) {}
|
||
fn next_event(&mut self, _: bool) -> Option<Ereignis> {
|
||
None
|
||
}
|
||
fn jetzt_ms(&mut self) -> u64 {
|
||
self.time
|
||
}
|
||
fn warten(&mut self, deadline: Option<u64>) -> Option<Ereignis> {
|
||
self.waits += 1;
|
||
if self.waits == 1 {
|
||
return Some(key("\u{1b}"));
|
||
}
|
||
self.time = deadline.unwrap();
|
||
None
|
||
}
|
||
}
|
||
let mut vm = vm("ON UEVENT GOSUB H\nUEVENT ON\nMenu1.Caption = \"&Datei\"\nItem1.Caption = \"&Ende\"\nForm1.Show\nSTOP\nSLEEP 60\nEND\nH:\ns$ = \"U\"\nRETURN");
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host);
|
||
vm.forms.handle_key("d", 4);
|
||
vm.rt.traps.melden(tb_runtime::traps::Quelle::UEvent);
|
||
let mut host = MenuHost { time: 0, waits: 0 };
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
println!(
|
||
"Menü/SLEEP: Zeit={}, Warteaufrufe={}, Handler={}",
|
||
host.time,
|
||
host.waits,
|
||
string(&vm, "s")
|
||
);
|
||
assert_eq!(host.waits, 1);
|
||
}
|
||
|
||
#[test]
|
||
fn review_maus_vor_getrappter_taste() {
|
||
let mut vm = vm("DIM SHARED s$\nON KEY(15) GOSUB H\nKEY 15, CHR$(0) + CHR$(20)\nKEY(15) ON\nForm1.Show\nSTOP\nDOEVENTS\nDOEVENTS\nEND\nH:\ns$ = s$ + \"K\"\nRETURN\nSUB Form_MouseDown(Button AS INTEGER, Shift AS INTEGER, X AS SINGLE, Y AS SINGLE)\nSHARED s$\ns$ = s$ + \"M\"\nEND SUB");
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host);
|
||
host.ereignis(mouse());
|
||
host.ereignis(key("t"));
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(string(&vm, "s"), "MK");
|
||
}
|
||
|
||
/// Ereignisse treffen erst beim Warten ein, auch mitten in einer Eingabe.
|
||
struct EingabeHost {
|
||
events: std::collections::VecDeque<Ereignis>,
|
||
now: u64,
|
||
deadlines: Vec<Option<u64>>,
|
||
}
|
||
impl Host for EingabeHost {
|
||
fn present(&mut self, _: &TextScreen) {}
|
||
fn next_event(&mut self, _: bool) -> Option<Ereignis> {
|
||
None
|
||
}
|
||
fn jetzt_ms(&mut self) -> u64 {
|
||
self.now
|
||
}
|
||
fn warten(&mut self, deadline: Option<u64>) -> Option<Ereignis> {
|
||
self.deadlines.push(deadline);
|
||
if let Some(deadline) = deadline {
|
||
self.now = deadline;
|
||
None
|
||
} else {
|
||
Some(self.events.pop_front().unwrap_or(Ereignis::Ende))
|
||
}
|
||
}
|
||
}
|
||
fn eingabe_host(events: Vec<Ereignis>) -> EingabeHost {
|
||
EingabeHost {
|
||
events: events.into(),
|
||
now: 0,
|
||
deadlines: vec![],
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn input_fortsetzung_erhaelt_teiltext_ausdruck_und_byref_ziel() {
|
||
for (statement, expected, enter) in [
|
||
("INPUT s$", "ab", true),
|
||
("LINE INPUT s$", "ab", true),
|
||
("s$ = \"x\" + INPUT$(2) + \"y\"", "xaby", false),
|
||
] {
|
||
let src = format!("ON SIGNAL(2) GOSUB H\nSIGNAL(2) ON\nCALL Lesen(s$)\nEND\nH:\nn% = n% + 1\nRETURN\nSUB Lesen(s$)\n{statement}\nEND SUB");
|
||
let mut vm = vm_for_source(&src);
|
||
let mut events = vec![key("a"), Ereignis::Signal(2), key("b")];
|
||
if enter {
|
||
events.push(key("\r"));
|
||
}
|
||
let mut host = eingabe_host(events);
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended, "{statement}");
|
||
assert_eq!(string(&vm, "s"), expected);
|
||
assert_eq!(integer(&vm, "n"), 1);
|
||
assert_eq!(host.deadlines.len(), if enter { 4 } else { 3 });
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn handler_eingabe_und_stop_bewahren_die_aeussere_eingabe() {
|
||
let mut vm = vm_for_source(
|
||
"ON SIGNAL(2) GOSUB H\nSIGNAL(2) ON\nINPUT s$\nEND\nH:\nSTOP\nINPUT t$\nRETURN",
|
||
);
|
||
let mut host = eingabe_host(vec![
|
||
key("a"),
|
||
Ereignis::Signal(2),
|
||
key("h"),
|
||
key("\r"),
|
||
key("b"),
|
||
key("\r"),
|
||
]);
|
||
stop(&mut vm, &mut host);
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(string(&vm, "s"), "ab");
|
||
assert_eq!(string(&vm, "t"), "h");
|
||
}
|
||
|
||
#[test]
|
||
fn timer_waehrend_input_wird_vor_erneutem_warten_zugestellt() {
|
||
let mut vm = vm_for_source(
|
||
"ON TIMER(1) GOSUB H\nTIMER ON\nINPUT s$\nEND\nH:\nn% = n% + 1\nTIMER OFF\nRETURN",
|
||
);
|
||
let mut host = eingabe_host(vec![key("a"), key("\r")]);
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(string(&vm, "s"), "a");
|
||
assert_eq!(integer(&vm, "n"), 1);
|
||
assert_eq!(host.deadlines, [Some(1000), None, None]);
|
||
}
|
||
|
||
#[test]
|
||
fn input_redo_verliert_weder_referenzen_noch_teiltext_beim_trap() {
|
||
let mut vm =
|
||
vm_for_source("ON SIGNAL(2) GOSUB H\nSIGNAL(2) ON\nINPUT \"Zahl:\"; n%\nEND\nH:\nRETURN");
|
||
let mut host = eingabe_host(vec![
|
||
key("x"),
|
||
key("\r"),
|
||
key("4"),
|
||
Ereignis::Signal(2),
|
||
key("2"),
|
||
key("\r"),
|
||
]);
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(integer(&vm, "n"), 42);
|
||
assert_eq!(
|
||
tb_runtime::snapshot::text(&vm.rt.screen)
|
||
.matches("Zahl:")
|
||
.count(),
|
||
2
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn lokaler_error_handler_nach_trap_verwirft_abgebrochene_teileingabe() {
|
||
let mut vm = vm_for_source("ON SIGNAL(2) GOSUB H\nSIGNAL(2) ON\nCALL Lesen(s$)\nEND\nH:\nERROR 5\nRETURN\nSUB Lesen(s$)\nON LOCAL ERROR GOTO Fehler\nINPUT s$\nEXIT SUB\nFehler:\nINPUT s$\nRESUME NEXT\nEND SUB");
|
||
let mut host = eingabe_host(vec![key("a"), Ereignis::Signal(2), key("b"), key("\r")]);
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(string(&vm, "s"), "b");
|
||
}
|
||
|
||
#[test]
|
||
fn randomize_eingabe_teilt_den_fortsetzbaren_konsolenpfad() {
|
||
let mut vm = vm_for_source(
|
||
"ON SIGNAL(2) GOSUB H\nSIGNAL(2) ON\nRANDOMIZE\nEND\nH:\nn% = n% + 1\nRETURN",
|
||
);
|
||
let mut host = eingabe_host(vec![key("4"), Ereignis::Signal(2), key("2"), key("\r")]);
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(integer(&vm, "n"), 1);
|
||
assert_eq!(
|
||
tb_runtime::snapshot::text(&vm.rt.screen)
|
||
.matches("Random Number Seed")
|
||
.count(),
|
||
1
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn return_label_verwirft_abgebrochene_eingabe_und_ausdruck() {
|
||
for statement in ["INPUT s$", "s$ = \"alt\" + INPUT$(2)"] {
|
||
let mut vm = vm_for_source(&format!("ON SIGNAL(2) GOSUB H\nSIGNAL(2) ON\n{statement}\nEND\nWeiter:\nINPUT t$\nEND\nH:\nRETURN Weiter"));
|
||
let mut host = eingabe_host(vec![key("a"), Ereignis::Signal(2), key("b"), key("\r")]);
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended, "{statement}");
|
||
assert_eq!(string(&vm, "s"), "");
|
||
assert_eq!(string(&vm, "t"), "b");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn spaete_timeraktivierung_nutzt_hostzeit_auch_ueber_control_parameter() {
|
||
for (setup, start) in [
|
||
("", "Timer1.Interval = 100"),
|
||
("", "CALL Starten(Timer1)"),
|
||
(
|
||
"Timer1.Enabled = 0\nTimer1.Interval = 100",
|
||
"Timer1.Enabled = -1",
|
||
),
|
||
] {
|
||
let mut vm = vm(&format!("DIM SHARED n%\nForm1.Show\n{setup}\nSTOP\n{start}\nSTOP\nDOEVENTS\nSTOP\nDOEVENTS\nEND\nSUB Starten(t AS CONTROL)\nt.Interval = 100\nEND SUB\nSUB Timer1_Timer()\nSHARED n%\nn% = n% + 1\nEND SUB"));
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host);
|
||
host.uhr_vorruecken(1000);
|
||
stop(&mut vm, &mut host);
|
||
assert_eq!(vm.forms.next_deadline(), Some(1100));
|
||
host.uhr_vorruecken(99);
|
||
stop(&mut vm, &mut host);
|
||
assert_eq!(integer(&vm, "n"), 0);
|
||
host.uhr_vorruecken(1);
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(integer(&vm, "n"), 1);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn intervallaenderung_im_handler_verwirft_bereits_faellige_altintervalle() {
|
||
let mut vm = vm("DIM SHARED n%\nForm1.Show\nTimer1.Interval = 100\nSLEEP 60\nSTOP\nDOEVENTS\nSTOP\nDOEVENTS\nEND\nSUB Timer1_Timer()\nSHARED n%\nn% = n% + 1\nIF n% = 1 THEN\nSTOP\nTimer1.Interval = 200\nELSE\nTimer1.Interval = 0\nEND IF\nEND SUB");
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host); // Im ersten Handler bei 100 ms.
|
||
assert_eq!(host.jetzt_ms(), 100);
|
||
host.uhr_vorruecken(350);
|
||
stop(&mut vm, &mut host); // Alter Rückstau darf nach dem Handler nicht laufen.
|
||
assert_eq!(integer(&vm, "n"), 1);
|
||
assert_eq!(vm.forms.next_deadline(), Some(650));
|
||
host.uhr_vorruecken(199);
|
||
stop(&mut vm, &mut host);
|
||
assert_eq!(integer(&vm, "n"), 1);
|
||
host.uhr_vorruecken(1);
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(integer(&vm, "n"), 2);
|
||
assert_eq!(vm.forms.next_deadline(), None);
|
||
}
|
||
|
||
#[test]
|
||
fn formular_tastatur_fallback_fuehrt_alle_drei_basic_handler_aus() {
|
||
let mut catalog = FormCatalog::default();
|
||
catalog.add("Form1", ObjectClass::Form, None, false);
|
||
for (input, expected) in [("a", "DPU"), ("\0;", "DU")] {
|
||
let src = "DIM SHARED s$\nForm1.Show\nSTOP\nDOEVENTS\nEND\nSUB Form_KeyDown(KeyCode AS INTEGER, Shift AS INTEGER)\nSHARED s$\ns$ = s$ + \"D\"\nEND SUB\nSUB Form_KeyPress(KeyAscii AS INTEGER)\nSHARED s$\ns$ = s$ + \"P\"\nEND SUB\nSUB Form_KeyUp(KeyCode AS INTEGER, Shift AS INTEGER)\nSHARED s$\ns$ = s$ + \"U\"\nEND SUB";
|
||
let mut vm = Vm::new(tb_vm::compile_source_with_forms("FORM1", src, &catalog).unwrap());
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host);
|
||
host.ereignis(key(input));
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
assert_eq!(
|
||
string(&vm, "s"),
|
||
expected,
|
||
"FORM_KEYDOWN/KEYPRESS/KEYUP: Status implementiert, Hosttaste {input:?}"
|
||
);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn registrierte_form_ereignisse_erreichen_basic_aus_realen_quellen() {
|
||
use tb_frontend::forms::{self, EventParamType};
|
||
for name in forms::events(ObjectClass::Form) {
|
||
let mut catalog = FormCatalog::default();
|
||
catalog.add("Form1", ObjectClass::Form, None, false);
|
||
catalog.add("Source", ObjectClass::TextBox, Some("Form1"), false);
|
||
let args = forms::event_params(name)
|
||
.unwrap()
|
||
.iter()
|
||
.map(|(n, t)| {
|
||
format!(
|
||
"{n} AS {}",
|
||
match t {
|
||
EventParamType::Integer => "INTEGER",
|
||
EventParamType::Single => "SINGLE",
|
||
EventParamType::Control => "CONTROL",
|
||
}
|
||
)
|
||
})
|
||
.collect::<Vec<_>>()
|
||
.join(", ");
|
||
let operation = match *name {
|
||
"LOAD" | "GOTFOCUS" => "Form1.Show",
|
||
"LOSTFOCUS" => "Form1.Hide",
|
||
"UNLOAD" => "Form1.Unload",
|
||
"PAINT" => "Form1.Refresh",
|
||
"RESIZE" => "Form1.Width = 70",
|
||
"DRAGOVER" | "DRAGDROP" => "Source.Drag 1",
|
||
"KEYDOWN" | "KEYPRESS" | "KEYUP" | "MOUSEDOWN" | "MOUSEMOVE" | "MOUSEUP" | "CLICK"
|
||
| "DBLCLICK" => "",
|
||
other => panic!("FORM_{other}: Status implementiert, Auslöser fehlt"),
|
||
};
|
||
let setup = if matches!(*name, "LOAD" | "GOTFOCUS") {
|
||
""
|
||
} else {
|
||
"Form1.Show"
|
||
};
|
||
let src = format!("DIM SHARED n%\nSource.Left=2\nSource.Top=2\n{setup}\nn%=0\nSTOP\n{operation}\nDOEVENTS\nEND\nSUB Form_{name}({args})\nSHARED n%\nn%=n%+1\nEND SUB");
|
||
let mut vm = Vm::new(
|
||
tb_vm::compile_source_with_forms("FORM1", &src, &catalog)
|
||
.unwrap_or_else(|d| panic!("{name}: {d:?}")),
|
||
);
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host);
|
||
if name.starts_with("KEY") {
|
||
host.ereignis(key("a"));
|
||
}
|
||
let events: &[MausArt] = match *name {
|
||
"MOUSEDOWN" => &[MausArt::Druck],
|
||
"MOUSEMOVE" | "DRAGOVER" => &[MausArt::Bewegung],
|
||
"MOUSEUP" | "DRAGDROP" => &[MausArt::Bewegung, MausArt::Loslassen],
|
||
"CLICK" => &[MausArt::Druck, MausArt::Loslassen],
|
||
"DBLCLICK" => &[
|
||
MausArt::Druck,
|
||
MausArt::Loslassen,
|
||
MausArt::Druck,
|
||
MausArt::Loslassen,
|
||
],
|
||
_ => &[],
|
||
};
|
||
for art in events {
|
||
host.ereignis(Ereignis::Maus(MausEreignis {
|
||
art: *art,
|
||
taste: 1,
|
||
shift: 0,
|
||
zeile: 1,
|
||
spalte: 1,
|
||
}));
|
||
}
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended, "FORM_{name}");
|
||
event_nachgewiesen(&format!("FORM_{name}"), integer(&vm, "n")).unwrap();
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn registrierte_control_ereignisse_erreichen_basic_aus_realen_quellen() {
|
||
use tb_frontend::forms::{self, EventParamType};
|
||
let mut failures = Vec::new();
|
||
for class in ObjectClass::ALL
|
||
.iter()
|
||
.copied()
|
||
.filter(|c| *c != ObjectClass::Form)
|
||
{
|
||
for name in forms::events(class) {
|
||
let mut catalog = FormCatalog::default();
|
||
catalog.add("Form1", ObjectClass::Form, None, false);
|
||
if class == ObjectClass::Menu {
|
||
catalog.add("Bar", ObjectClass::Menu, Some("Form1"), false);
|
||
}
|
||
catalog.add(
|
||
"Probe",
|
||
class,
|
||
Some(if class == ObjectClass::Menu {
|
||
"Bar"
|
||
} else {
|
||
"Form1"
|
||
}),
|
||
false,
|
||
);
|
||
catalog.add("Source", ObjectClass::TextBox, Some("Form1"), false);
|
||
let args = forms::event_params(name)
|
||
.unwrap()
|
||
.iter()
|
||
.map(|(n, t)| {
|
||
format!(
|
||
"{n} AS {}",
|
||
match t {
|
||
EventParamType::Integer => "INTEGER",
|
||
EventParamType::Single => "SINGLE",
|
||
EventParamType::Control => "CONTROL",
|
||
}
|
||
)
|
||
})
|
||
.collect::<Vec<_>>()
|
||
.join(", ");
|
||
let mut setup = String::from(
|
||
"Form1.Width=60\nForm1.Height=15\nForm1.Show\nSource.Left=40\nSource.Top=2\n",
|
||
);
|
||
if !matches!(class, ObjectClass::Timer | ObjectClass::Menu) {
|
||
setup.push_str("Probe.Left=10\nProbe.Top=4\n");
|
||
}
|
||
let operation = match *name {
|
||
"GOTFOCUS" => String::new(),
|
||
"LOSTFOCUS" => "Source.SetFocus".into(),
|
||
"PAINT" => "Probe.Refresh".into(),
|
||
"DRAGOVER" | "DRAGDROP" => "Source.Drag 1".into(),
|
||
"CHANGE" => match class {
|
||
ObjectClass::Label => "Probe.Caption=\"changed\"".into(),
|
||
ObjectClass::HScrollBar | ObjectClass::VScrollBar => "Probe.Value=1".into(),
|
||
ObjectClass::DirListBox => {
|
||
format!("Probe.Path=\"{}\"", std::env::temp_dir().display())
|
||
}
|
||
ObjectClass::DriveListBox => "Probe.Drive=\"/\"".into(),
|
||
_ => "Probe.Text=\"changed\"".into(),
|
||
},
|
||
"PATHCHANGE" => format!("Probe.Path=\"{}\"", std::env::temp_dir().display()),
|
||
"PATTERNCHANGE" => "Probe.Pattern=\"*.bas\"".into(),
|
||
"TIMER" => "Probe.Interval=1\nProbe.Enabled=-1".into(),
|
||
"CLICK" if class == ObjectClass::Menu => {
|
||
setup.push_str("Probe.Caption=\"&Go\"\nProbe.Shortcut=\"F3\"\n");
|
||
String::new()
|
||
}
|
||
"CLICK" | "DBLCLICK" | "MOUSEDOWN" | "MOUSEMOVE" | "MOUSEUP" | "KEYDOWN"
|
||
| "KEYPRESS" | "KEYUP" | "DROPDOWN" | "CUSTOM" => String::new(),
|
||
other => panic!(
|
||
"{}_{other}: Status implementiert, Auslöser fehlt",
|
||
class.name()
|
||
),
|
||
};
|
||
let src=format!("DIM SHARED n%\n{setup}\nn%=0\nSTOP\n{operation}\nSTOP\nDOEVENTS\nEND\nSUB Probe_{name}({args})\nSHARED n%\nn%=n%+1\nEND SUB");
|
||
let mut vm = Vm::new(
|
||
tb_vm::compile_source_with_forms("FORM1", &src, &catalog)
|
||
.unwrap_or_else(|d| panic!("{}_{name}: {d:?}", class.name())),
|
||
);
|
||
let mut host = CaptureHost::default();
|
||
let initial = vm.run(&mut host);
|
||
assert!(
|
||
matches!(initial, RunEvent::Stopped { .. }),
|
||
"{}_{name}: {initial:?}",
|
||
class.name()
|
||
);
|
||
if *name == "LOSTFOCUS" {
|
||
vm.forms.focus((1, None)).unwrap();
|
||
}
|
||
let second = vm.run(&mut host);
|
||
assert!(
|
||
matches!(second, RunEvent::Stopped { .. }),
|
||
"{}_{name}: {second:?}",
|
||
class.name()
|
||
);
|
||
if name.starts_with("KEY") || matches!(*name, "DROPDOWN" | "CUSTOM") {
|
||
vm.forms.focus((1, None)).unwrap();
|
||
}
|
||
if *name == "TIMER" {
|
||
host.uhr_vorruecken(2);
|
||
}
|
||
if name.starts_with("KEY") {
|
||
host.ereignis(key("a"));
|
||
}
|
||
if *name == "DROPDOWN" {
|
||
host.ereignis(Ereignis::Taste("\0P".into(), 4));
|
||
}
|
||
if *name == "CUSTOM" {
|
||
host.ereignis(key("\0H"));
|
||
}
|
||
if class == ObjectClass::Menu {
|
||
host.ereignis(key("\0="));
|
||
}
|
||
let events: &[MausArt] = match *name {
|
||
"MOUSEDOWN" | "GOTFOCUS" => &[MausArt::Druck],
|
||
"MOUSEMOVE" | "DRAGOVER" => &[MausArt::Bewegung],
|
||
"MOUSEUP" | "DRAGDROP" => &[MausArt::Bewegung, MausArt::Loslassen],
|
||
"CLICK" if class != ObjectClass::Menu => &[MausArt::Druck, MausArt::Loslassen],
|
||
"DBLCLICK" => &[
|
||
MausArt::Druck,
|
||
MausArt::Loslassen,
|
||
MausArt::Druck,
|
||
MausArt::Loslassen,
|
||
],
|
||
_ => &[],
|
||
};
|
||
for art in events {
|
||
host.ereignis(Ereignis::Maus(MausEreignis {
|
||
art: *art,
|
||
taste: 1,
|
||
shift: 0,
|
||
zeile: 5,
|
||
spalte: 11,
|
||
}));
|
||
}
|
||
let result = vm.run(&mut host);
|
||
if result != RunEvent::Ended || integer(&vm, "n") == 0 {
|
||
failures.push(format!(
|
||
"{}_{name}: Status implementiert, Handler unerreicht: {result:?}",
|
||
class.name()
|
||
));
|
||
}
|
||
}
|
||
}
|
||
assert!(failures.is_empty(), "{}", failures.join("\n"));
|
||
}
|
||
|
||
#[test]
|
||
fn shell_und_irr_funktionssignaturen_erreichen_die_runtime() {
|
||
let mut vm = vm_for_source(
|
||
"DIM a(1) AS DOUBLE\na(0)=-100\na(1)=110\nr#=IRR#(a,.1)\ns&=SHELL(\"exit 7\")\nEND",
|
||
);
|
||
assert_eq!(vm.run(&mut CaptureHost::default()), RunEvent::Ended);
|
||
assert!(matches!(vm.inspect("r"),Some(Value::Dbl(n)) if (n-0.1).abs()<1e-8));
|
||
assert!(matches!(vm.inspect("s"), Some(Value::Lng(7))));
|
||
}
|
||
|
||
fn event_nachgewiesen(name: &str, count: i16) -> Result<(), String> {
|
||
if count > 0 {
|
||
Ok(())
|
||
} else {
|
||
Err(format!(
|
||
"{name}: Status implementiert, fehlender Auslösepfad zum BASIC-Handler"
|
||
))
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn fehlender_ereignispfad_wird_namentlich_erkannt() {
|
||
let mut catalog = FormCatalog::default();
|
||
catalog.add("Form1", ObjectClass::Form, None, false);
|
||
let mut module=tb_vm::compile_source_with_forms("FORM1","DIM SHARED n%\nForm1.Show\nSTOP\nDOEVENTS\nEND\nSUB Form_KeyPress(KeyAscii AS INTEGER)\nSHARED n%\nn%=n%+1\nEND SUB",&catalog).unwrap();
|
||
module.event_procs.clear(); // künstlich fehlende Dispatch-Bindung
|
||
let mut vm = Vm::new(module);
|
||
let mut host = CaptureHost::default();
|
||
stop(&mut vm, &mut host);
|
||
host.ereignis(key("a"));
|
||
assert_eq!(vm.run(&mut host), RunEvent::Ended);
|
||
let error = event_nachgewiesen("FORM_KEYPRESS", integer(&vm, "n")).unwrap_err();
|
||
assert!(
|
||
error.contains("FORM_KEYPRESS")
|
||
&& error.contains("implementiert")
|
||
&& error.contains("Auslösepfad")
|
||
);
|
||
}
|