549 lines
18 KiB
Rust
549 lines
18 KiB
Rust
//! Unveränderte ursprüngliche Reviewproben und ergänzende Regressionen des Projektkompilats.
|
|
use tb_frontend::{
|
|
forms::FormCatalog,
|
|
source::{SourceSegment, SourceUnit},
|
|
};
|
|
use tb_runtime::{host::CaptureHost, value::Value};
|
|
use tb_vm::{
|
|
bytecode::CompiledModule,
|
|
compile_project,
|
|
interp::{RunEvent, Vm},
|
|
};
|
|
|
|
fn units(files: &[(&str, &str)]) -> Vec<SourceUnit> {
|
|
files
|
|
.iter()
|
|
.map(|(name, code)| SourceUnit::new(name, &format!("{name}.bas"), code))
|
|
.collect()
|
|
}
|
|
fn compile(files: &[(&str, &str)]) -> Result<CompiledModule, Vec<tb_frontend::Diagnostic>> {
|
|
compile_project("APP", &units(files), &FormCatalog::default(), &[])
|
|
}
|
|
fn run(module: CompiledModule) -> (RunEvent, String) {
|
|
let bytes = module.to_tbc();
|
|
let loaded = CompiledModule::from_tbc(&bytes).unwrap();
|
|
assert_eq!(bytes, loaded.to_tbc());
|
|
let mut vm = Vm::new(loaded);
|
|
let event = vm.run(&mut CaptureHost::default());
|
|
(event, tb_runtime::snapshot::text(&vm.rt.screen))
|
|
}
|
|
|
|
#[test]
|
|
fn v1_zweige_und_schleifen_behalten_eigene_quellorte() {
|
|
let mut failures = vec![];
|
|
for (name, code, line) in [
|
|
(
|
|
"ELSEIF",
|
|
"IF 0 THEN\nPRINT 1\nELSEIF 1/0 THEN\nPRINT 2\nEND IF",
|
|
3,
|
|
),
|
|
("CASE", "SELECT CASE 1\nCASE 1/0\nPRINT 2\nEND SELECT", 2),
|
|
("NEXT", "FOR i%=32767 TO 32767\nPRINT 1\nNEXT", 3),
|
|
("LOOP", "DO\nPRINT 1\nLOOP UNTIL 1/0", 3),
|
|
] {
|
|
let (event, _) = run(compile(&[("MAIN", code)]).unwrap());
|
|
if !matches!(event, RunEvent::Error { line: found, .. } if found == line) {
|
|
failures.push(format!("{name}: erwartet Zeile {line}, erhalten {event:?}"));
|
|
}
|
|
}
|
|
let source = SourceUnit {
|
|
name: "MAIN".into(),
|
|
segments: vec![
|
|
SourceSegment {
|
|
file: "main.bas".into(),
|
|
first_line: 1,
|
|
text: "IF 0 THEN\nPRINT 1\n".into(),
|
|
},
|
|
SourceSegment {
|
|
file: "cond.bi".into(),
|
|
first_line: 1,
|
|
text: "ELSEIF 1/0 THEN\nPRINT 2\n".into(),
|
|
},
|
|
SourceSegment {
|
|
file: "main.bas".into(),
|
|
first_line: 4,
|
|
text: "END IF\n".into(),
|
|
},
|
|
],
|
|
};
|
|
let mut vm = Vm::new(compile_project("APP", &[source], &FormCatalog::default(), &[]).unwrap());
|
|
let event = vm.run(&mut CaptureHost::default());
|
|
if vm.current_file() != "cond.bi" {
|
|
failures.push(format!(
|
|
"Include: {event:?} aus {} statt cond.bi",
|
|
vm.current_file()
|
|
));
|
|
}
|
|
// Das gleiche Problem darf nicht nur durch Umbenennen der Fehlermeldung behoben werden.
|
|
let mut vm = Vm::new(
|
|
compile(&[("MAIN", "IF 0 THEN\nPRINT 1\nELSEIF 1 THEN\nPRINT 2\nEND IF")]).unwrap(),
|
|
);
|
|
vm.add_module_breakpoint(0, 3);
|
|
let event = vm.run(&mut CaptureHost::default());
|
|
if event != (RunEvent::Breakpoint { line: 3 }) {
|
|
failures.push(format!("Breakpoint ELSEIF: {event:?}"));
|
|
}
|
|
assert!(failures.is_empty(), "{}", failures.join("\n"));
|
|
}
|
|
|
|
#[test]
|
|
fn v2_importierte_deklarationen_behalten_kontext_und_abhaengigkeiten() {
|
|
let cases = [
|
|
(
|
|
"DEFINT",
|
|
"PRINT Doppelt(3)\nEND",
|
|
"DEFINT A-Z\nFUNCTION Doppelt(x)\nDoppelt=x*2\nEND FUNCTION",
|
|
" 6 \n",
|
|
),
|
|
(
|
|
"CONST",
|
|
"CONST A=3\nPRINT B\nEND",
|
|
"CONST A=3\nCONST B=A+1",
|
|
" 4 \n",
|
|
),
|
|
(
|
|
"TYPE",
|
|
"TYPE Inner\nx AS INTEGER\nEND TYPE\nDIM a AS Outer\na.i.x=3\nPRINT a.i.x\nEND",
|
|
"TYPE Inner\nx AS INTEGER\nEND TYPE\nTYPE Outer\ni AS Inner\nEND TYPE",
|
|
" 3 \n",
|
|
),
|
|
];
|
|
let mut failures = vec![];
|
|
for (name, main, lib, output) in cases {
|
|
match compile(&[("MAIN", main), ("LIB", lib)]) {
|
|
Err(e) => failures.push(format!("{name}: {e:?}")),
|
|
Ok(module) => {
|
|
let actual = run(module);
|
|
if actual != (RunEvent::Ended, output.into()) {
|
|
failures.push(format!("{name}: {actual:?}"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
assert!(failures.is_empty(), "{}", failures.join("\n"));
|
|
}
|
|
|
|
#[test]
|
|
fn v3_form_metabefehle_erzeugen_getrennte_formularobjekte() {
|
|
let module = compile(&[
|
|
(
|
|
"A",
|
|
"'$FORM\nCaption=\"a\"\nCALL SetupB\nPRINT Caption\nEND",
|
|
),
|
|
("B", "'$FORM\nSUB SetupB\nCaption=\"b\"\nEND SUB"),
|
|
])
|
|
.unwrap();
|
|
let names: Vec<_> = module.objects.iter().map(|o| o.name.clone()).collect();
|
|
let actual = run(module);
|
|
assert_eq!(
|
|
actual,
|
|
(RunEvent::Ended, "a\n".into()),
|
|
"Objekte: {names:?}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn v4_common_behaelt_typidentitaet_und_initialisiert_arrays_einmal() {
|
|
let mut failures = vec![];
|
|
for (name, files, want) in [
|
|
(
|
|
"Suffixe",
|
|
vec![(
|
|
"MAIN",
|
|
"COMMON SHARED c%, c$\nc%=7\nc$=\"ok\"\nPRINT c%;c$\nEND",
|
|
)],
|
|
" 7 ok\n",
|
|
),
|
|
(
|
|
"Array",
|
|
vec![
|
|
("MAIN", "COMMON SHARED a%(2)\na%(1)=7\nCALL F\nEND"),
|
|
("LIB", "COMMON SHARED a%(2)\nSUB F\nPRINT a%(1)\nEND SUB"),
|
|
],
|
|
" 7 \n",
|
|
),
|
|
] {
|
|
match compile(&files) {
|
|
Err(e) => failures.push(format!("{name}: {e:?}")),
|
|
Ok(module) => {
|
|
let actual = run(module);
|
|
if actual != (RunEvent::Ended, want.into()) {
|
|
failures.push(format!("{name}: {actual:?}"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
assert!(failures.is_empty(), "{}", failures.join("\n"));
|
|
}
|
|
|
|
#[test]
|
|
fn v5_load_und_unload_loesen_den_expliziten_container_auf() {
|
|
use tb_frontend::forms::ObjectClass;
|
|
let mut catalog = FormCatalog::default();
|
|
for name in ["Form1", "Form2"] {
|
|
catalog.add(name, ObjectClass::Form, None, false);
|
|
catalog.add("Text1", ObjectClass::TextBox, Some(name), true);
|
|
}
|
|
let source = units(&[("MAIN", "LOAD Form2!Text1(3)\nForm2!Text1(3).Text=\"b\"\nPRINT Form2!Text1(3).Text\nUNLOAD Form2!Text1(3)\nEND")]);
|
|
let module = compile_project("APP", &source, &catalog, &[]).unwrap();
|
|
assert_eq!(run(module), (RunEvent::Ended, "b\n".into()));
|
|
}
|
|
|
|
#[test]
|
|
fn v6_linkerdiagnose_nennt_den_urspruenglichen_dateiort() {
|
|
let errors = compile(&[
|
|
("MAIN", "DECLARE SUB F(x%)\nCALL F(1)\nEND"),
|
|
("LIB", "SUB F(x$)\nEND SUB"),
|
|
])
|
|
.unwrap_err();
|
|
assert!(
|
|
errors
|
|
.iter()
|
|
.any(|d| d.message.contains("Parameter type mismatch")),
|
|
"{errors:?}"
|
|
);
|
|
assert!(
|
|
errors
|
|
.iter()
|
|
.all(|d| d.file.is_some() && d.pos.line > 0 && d.pos.column > 0),
|
|
"{errors:?}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn modulbreakpoint_rundlauf_inspektion_und_numerische_erl_bleiben_getrennt() {
|
|
let main = format!(
|
|
"DIM a%(2)\nTYPE T\nx AS INTEGER\nEND TYPE\nDIM r AS T\na%(1)=7\nr.x=8\n{}CALL F\nEND",
|
|
"\n\nn%=1\n"
|
|
);
|
|
let lib = format!("SUB F\n{}200 ERROR 6\nEND SUB", "\n".repeat(8));
|
|
let module = compile(&[("MAIN", &main), ("LIB", &lib)]).unwrap();
|
|
let bytes = module.to_tbc();
|
|
let loaded = CompiledModule::from_tbc(&bytes).unwrap();
|
|
assert_eq!(bytes, loaded.to_tbc());
|
|
let mut vm = Vm::new(loaded);
|
|
vm.add_module_breakpoint(1, 10);
|
|
let mut host = CaptureHost::default();
|
|
assert_eq!(vm.run(&mut host), RunEvent::Breakpoint { line: 10 });
|
|
assert_eq!(vm.current_module(), 1);
|
|
assert_eq!(vm.current_file(), "LIB.bas");
|
|
assert!(matches!(
|
|
vm.inspect_element("MAIN!a%", &[1]),
|
|
Some(Value::Int(7))
|
|
));
|
|
assert!(matches!(
|
|
vm.inspect_field("MAIN!r", &[0]),
|
|
Some(Value::Int(8))
|
|
));
|
|
vm.remove_module_breakpoint(1, 10);
|
|
vm.set_step(true);
|
|
assert_eq!(vm.run(&mut host), RunEvent::Stepped { line: 10 });
|
|
assert_eq!(vm.current_source_pos().column, 5);
|
|
vm.set_step(false);
|
|
assert!(matches!(
|
|
vm.run(&mut host),
|
|
RunEvent::Error {
|
|
code: 6,
|
|
line: 10,
|
|
..
|
|
}
|
|
));
|
|
let source = format!("{}ERROR 6", "\n".repeat(41));
|
|
assert!(matches!(
|
|
run(compile(&[("MAIN", &source)]).unwrap()).0,
|
|
RunEvent::Error {
|
|
code: 6,
|
|
line: 42,
|
|
..
|
|
}
|
|
));
|
|
let module = compile(&[(
|
|
"MAIN",
|
|
"ON ERROR RESUME NEXT\n200 ERROR 6\nPRINT ERR;ERL\nEND",
|
|
)])
|
|
.unwrap();
|
|
assert_eq!(run(module), (RunEvent::Ended, " 6 200 \n".into()));
|
|
}
|
|
|
|
#[test]
|
|
fn importkontext_bleibt_auch_bei_abweichenden_lokalen_definitionen_erhalten() {
|
|
for (files, expected) in [
|
|
(vec![("MAIN", "CONST A=99\nPRINT B\nEND"), ("LIB", "CONST A=3\nCONST B=A+1")], " 4 \n"),
|
|
(vec![("MAIN", "PRINT C\nEND"), ("LIB", "CONST C=B+1"), ("BASE", "CONST B=3")], " 4 \n"),
|
|
(vec![("MAIN", "TYPE Inner\nx AS STRING * 3\nEND TYPE\nDIM a AS Outer\na.i.x=3\nPRINT a.i.x\nEND"), ("LIB", "TYPE Inner\nx AS INTEGER\nEND TYPE\nTYPE Outer\ni AS Inner\nEND TYPE")], " 3 \n"),
|
|
(vec![("MAIN", "DEFSTR A-Z\nx%=3\nCALL Twice(x%)\nPRINT x%\nPRINT Doppelt(3)\nEND"), ("LIB", "DEFINT A-Z\nSUB Twice(x)\nx=x*2\nEND SUB\nFUNCTION Doppelt(x)\nDoppelt=x*2\nEND FUNCTION")], " 6 \n 6 \n"),
|
|
] {
|
|
let actual = run(compile(&files).unwrap_or_else(|e| panic!("{files:?}: {e:?}")));
|
|
assert_eq!(actual, (RunEvent::Ended, expected.into()), "{files:?}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn common_vertraege_und_linkfehler_haben_echte_quellorte() {
|
|
for (left, right) in [
|
|
("COMMON SHARED a%(2)", "COMMON SHARED a%(3)"),
|
|
("COMMON SHARED a%(1 TO 2)", "COMMON SHARED a%(0 TO 2)"),
|
|
("COMMON SHARED a%(2)", "COMMON SHARED a%(2,2)"),
|
|
("COMMON SHARED a AS INTEGER", "COMMON SHARED a AS STRING"),
|
|
("COMMON SHARED a%(2)", "COMMON SHARED a%"),
|
|
] {
|
|
let units = [
|
|
SourceUnit::new("MAIN", "main.bas", &format!("{left}\nEND")),
|
|
SourceUnit {
|
|
name: "LIB".into(),
|
|
segments: vec![SourceSegment {
|
|
file: "shared.bi".into(),
|
|
first_line: 42,
|
|
text: format!(" {right}\n"),
|
|
}],
|
|
},
|
|
];
|
|
let errors = compile_project("APP", &units, &FormCatalog::default(), &[]).unwrap_err();
|
|
assert!(
|
|
errors.iter().any(|e| e.file.as_deref() == Some("shared.bi")
|
|
&& e.pos.line == 42
|
|
&& e.pos.column > 1
|
|
&& e.message.contains("COMMON")),
|
|
"{errors:?}"
|
|
);
|
|
}
|
|
let files = [
|
|
(
|
|
"MAIN",
|
|
"COMMON SHARED a%(2),a$(2)\na%(1)=7\na$(1)=\"ok\"\nCALL F\nEND",
|
|
),
|
|
(
|
|
"LIB",
|
|
"COMMON SHARED a%(2),a$(2)\nSUB F\nPRINT a%(1);a$(1)\nEND SUB",
|
|
),
|
|
];
|
|
assert_eq!(
|
|
run(compile(&files).unwrap()),
|
|
(RunEvent::Ended, " 7 ok\n".into())
|
|
);
|
|
let errors =
|
|
compile(&[("MAIN", "' header\nDECLARE SUB F(x$)\nSUB F(x%)\nEND SUB")]).unwrap_err();
|
|
assert!(
|
|
errors.iter().any(|e| e.pos.line == 3
|
|
&& e.file.as_deref() == Some("MAIN.bas")
|
|
&& e.message.contains("Parameter")),
|
|
"{errors:?}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn schleifengrenzen_tragen_breakpoint_include_und_resume() {
|
|
for (source, line) in [
|
|
("FOR i%=1 TO 2\nPRINT i%\nNEXT\nEND", 3),
|
|
("DO\nPRINT 1\nLOOP UNTIL 1\nEND", 3),
|
|
("i%=1\nWHILE i%\ni%=0\nWEND\nEND", 4),
|
|
(
|
|
"SELECT CASE 2\nCASE 1\nPRINT 1\nCASE 2\nPRINT 2\nEND SELECT",
|
|
4,
|
|
),
|
|
] {
|
|
let module = compile(&[("MAIN", source)]).unwrap();
|
|
let mut vm = Vm::new(CompiledModule::from_tbc(&module.to_tbc()).unwrap());
|
|
vm.add_module_breakpoint(0, line);
|
|
assert_eq!(
|
|
vm.run(&mut CaptureHost::default()),
|
|
RunEvent::Breakpoint { line }
|
|
);
|
|
assert_eq!(vm.current_file(), "MAIN.bas");
|
|
assert_eq!(vm.current_source_pos().column, 1);
|
|
vm.remove_module_breakpoint(0, line);
|
|
assert_eq!(vm.run(&mut CaptureHost::default()), RunEvent::Ended);
|
|
}
|
|
let actual = run(compile(&[("MAIN", "x%=1\nWHILE 1/x%\nx%=0\nWEND")]).unwrap());
|
|
assert!(
|
|
matches!(
|
|
actual.0,
|
|
RunEvent::Error {
|
|
code: 11,
|
|
line: 2,
|
|
..
|
|
}
|
|
),
|
|
"{actual:?}"
|
|
);
|
|
let actual = run(compile(&[(
|
|
"MAIN",
|
|
"ON ERROR GOTO H\nDO\nn%=n%+1\nLOOP UNTIL 1/x%\nPRINT n%\nEND\nH:\nx%=1\nRESUME",
|
|
)])
|
|
.unwrap());
|
|
assert_eq!(actual, (RunEvent::Ended, " 1 \n".into()));
|
|
let actual = run(compile(&[(
|
|
"MAIN",
|
|
"ON ERROR RESUME NEXT\nFOR i%=32767 TO 32767\nNEXT\nPRINT ERR\nEND",
|
|
)])
|
|
.unwrap());
|
|
assert_eq!(actual, (RunEvent::Ended, " 6 \n".into()));
|
|
let unit = SourceUnit {
|
|
name: "MAIN".into(),
|
|
segments: vec![
|
|
SourceSegment {
|
|
file: "main.bas".into(),
|
|
first_line: 1,
|
|
text: "DO\nPRINT 1\n".into(),
|
|
},
|
|
SourceSegment {
|
|
file: "end.bi".into(),
|
|
first_line: 42,
|
|
text: " LOOP UNTIL 1/0\n".into(),
|
|
},
|
|
],
|
|
};
|
|
let module = compile_project("APP", &[unit], &FormCatalog::default(), &[]).unwrap();
|
|
let mut vm = Vm::new(CompiledModule::from_tbc(&module.to_tbc()).unwrap());
|
|
assert!(matches!(
|
|
vm.run(&mut CaptureHost::default()),
|
|
RunEvent::Error {
|
|
code: 11,
|
|
line: 42,
|
|
..
|
|
}
|
|
));
|
|
assert_eq!(vm.current_file(), "end.bi");
|
|
assert_eq!(vm.current_source_pos().column, 3);
|
|
}
|
|
|
|
#[test]
|
|
fn debugger_unterscheidet_typisierte_scalar_und_arraynamen() {
|
|
let mut vm = Vm::new(
|
|
compile(&[(
|
|
"MAIN",
|
|
"COMMON SHARED c%,c$,a%(2),a$(2)\nc%=7\nc$=\"ok\"\na%(1)=8\na$(1)=\"array\"\nSTOP",
|
|
)])
|
|
.unwrap(),
|
|
);
|
|
assert!(matches!(
|
|
vm.run(&mut CaptureHost::default()),
|
|
RunEvent::Stopped { .. }
|
|
));
|
|
assert!(matches!(vm.inspect("c%"), Some(Value::Int(7))));
|
|
assert!(matches!(vm.inspect("c$"),Some(Value::Str(s)) if s.as_ref()=="ok"));
|
|
assert!(matches!(
|
|
vm.inspect_element("a%", &[1]),
|
|
Some(Value::Int(8))
|
|
));
|
|
assert!(matches!(vm.inspect_element("a$",&[1]),Some(Value::Str(s)) if s.as_ref()=="array"));
|
|
}
|
|
|
|
#[test]
|
|
fn common_arrays_behalten_dynamische_grenzen_und_kompatible_offene_deklarationen() {
|
|
for (left, right) in [
|
|
("COMMON SHARED a%(2)", "COMMON SHARED a%()"),
|
|
("COMMON SHARED a%(2.4)", "COMMON SHARED a%(2)"),
|
|
("COMMON SHARED a%(n%+2)", "COMMON SHARED a%(n%+2)"),
|
|
] {
|
|
let files = [
|
|
("MAIN", format!("{left}\na%(1)=7\nCALL F\nEND")),
|
|
("LIB", format!("{right}\nSUB F\nPRINT a%(1)\nEND SUB")),
|
|
];
|
|
let files: Vec<_> = files.iter().map(|(n, s)| (*n, s.as_str())).collect();
|
|
assert_eq!(
|
|
run(compile(&files).unwrap()),
|
|
(RunEvent::Ended, " 7 \n".into()),
|
|
"{files:?}"
|
|
);
|
|
}
|
|
let module = compile(&[
|
|
("MAIN", "COMMON SHARED a%(n%+2)\nEND"),
|
|
("LIB", "COMMON SHARED a%(n%+3)"),
|
|
])
|
|
.unwrap();
|
|
let mut vm = Vm::new(CompiledModule::from_tbc(&module.to_tbc()).unwrap());
|
|
assert!(matches!(
|
|
vm.run(&mut CaptureHost::default()),
|
|
RunEvent::Error {
|
|
code: 13,
|
|
line: 1,
|
|
..
|
|
}
|
|
));
|
|
assert_eq!(vm.current_file(), "LIB.bas");
|
|
}
|
|
|
|
#[test]
|
|
fn prozedurlokaler_deftype_veraendert_keine_nachfolgende_signatur() {
|
|
let files=[("MAIN","PRINT F(3)\nEND"),("LIB","DEFINT A-Z\nSUB Setup\nDEFSTR A-Z\nx=\"local\"\nEND SUB\nFUNCTION F(x)\nF=x*2\nEND FUNCTION")];
|
|
assert_eq!(
|
|
run(compile(&files).unwrap()),
|
|
(RunEvent::Ended, " 6 \n".into())
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gemischte_frm_und_form_module_haben_getrennte_ereignisbindungen() {
|
|
let form=tb_ui::frm::read_text("A.frm","VERSION 1.00\nBEGIN Form A\n Caption = \"design\"\nEND\nSUB Form_Load\nCaption=\"a\"\nEND SUB").unwrap();
|
|
let sources = units(&[
|
|
(
|
|
"MAIN",
|
|
"B.Show\na$=A.Caption\nb$=B.Caption\nA.Hide\nB.Hide\nCLS\nPRINT a$;b$\nEND",
|
|
),
|
|
("A", &form.code),
|
|
("B", "'$FORM\nSUB Form_Load\nCaption=\"b\"\nEND SUB"),
|
|
]);
|
|
let module = compile_project("APP", &sources, &form.catalog(), &[form]).unwrap();
|
|
assert_eq!(module.event_procs.len(), 2);
|
|
assert_ne!(module.event_procs[0].object, module.event_procs[1].object);
|
|
assert_eq!(run(module), (RunEvent::Ended, "ab\n".into()));
|
|
}
|
|
|
|
#[test]
|
|
fn diagnostik_bei_literalen_im_include_hat_die_exakte_spalte() {
|
|
let unit = SourceUnit {
|
|
name: "MAIN".into(),
|
|
segments: vec![
|
|
SourceSegment {
|
|
file: "main.bas".into(),
|
|
first_line: 1,
|
|
text: "DECLARE SUB F(x%)\n".into(),
|
|
},
|
|
SourceSegment {
|
|
file: "args.bi".into(),
|
|
first_line: 42,
|
|
text: " CALL F(\"wrong\")\n".into(),
|
|
},
|
|
],
|
|
};
|
|
let errors = compile_project("APP", &[unit], &FormCatalog::default(), &[]).unwrap_err();
|
|
assert!(
|
|
errors.iter().any(|e| e.file.as_deref() == Some("args.bi")
|
|
&& e.pos.line == 42
|
|
&& e.pos.column == 10
|
|
&& e.message.contains("Parameter type mismatch")),
|
|
"{errors:?}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn spaetere_common_konflikte_und_doppelte_module_werden_am_ursprung_gemeldet() {
|
|
let errors = compile(&[
|
|
("MAIN", "COMMON a%()\nEND"),
|
|
("LIB", "COMMON a%(2)"),
|
|
("THIRD", "' head\nCOMMON a%(3)"),
|
|
])
|
|
.unwrap_err();
|
|
assert!(
|
|
errors.iter().any(|e| e.file.as_deref() == Some("THIRD.bas")
|
|
&& e.pos.line == 2
|
|
&& e.message.contains("COMMON")),
|
|
"{errors:?}"
|
|
);
|
|
let units = [
|
|
SourceUnit::new("SAME", "first.bas", "END"),
|
|
SourceUnit::new("SAME", "second.bas", "' head\n END"),
|
|
];
|
|
let errors = compile_project("APP", &units, &FormCatalog::default(), &[]).unwrap_err();
|
|
assert!(
|
|
errors
|
|
.iter()
|
|
.any(|e| e.file.as_deref() == Some("second.bas")
|
|
&& e.pos.line == 2
|
|
&& e.pos.column == 3
|
|
&& e.message.contains("Duplicate")),
|
|
"{errors:?}"
|
|
);
|
|
}
|