1152 lines
38 KiB
Rust
1152 lines
38 KiB
Rust
use crossterm::event::{
|
|
Event, KeyCode as K, KeyEvent, KeyModifiers as M, MouseButton, MouseEvent, MouseEventKind,
|
|
};
|
|
use ratatui::{backend::TestBackend, Terminal};
|
|
use std::{
|
|
fs,
|
|
path::PathBuf,
|
|
sync::atomic::{AtomicUsize, Ordering},
|
|
};
|
|
use tb_ide::{
|
|
app::{App, DialogKind, Execution, Hit, Mode, WindowKind, WindowState},
|
|
commands::{self, Command},
|
|
export::{ExportStatus, ProjectStamp},
|
|
options::Options,
|
|
};
|
|
|
|
struct Temp(PathBuf);
|
|
impl Temp {
|
|
fn new() -> Self {
|
|
static N: AtomicUsize = AtomicUsize::new(0);
|
|
let path = std::env::temp_dir().join(format!(
|
|
"tb-app-{}-{}",
|
|
std::process::id(),
|
|
N.fetch_add(1, Ordering::Relaxed)
|
|
));
|
|
fs::create_dir_all(&path).unwrap();
|
|
Self(path.canonicalize().unwrap())
|
|
}
|
|
fn app(&self) -> App {
|
|
App::new(&self.0, self.0.join("config/options.ini"), (100, 30)).unwrap()
|
|
}
|
|
}
|
|
impl Drop for Temp {
|
|
fn drop(&mut self) {
|
|
let _ = fs::remove_dir_all(&self.0);
|
|
}
|
|
}
|
|
fn key(app: &mut App, k: K, m: M) {
|
|
app.handle(Event::Key(KeyEvent::new(k, m)));
|
|
}
|
|
fn plain(app: &mut App, k: K) {
|
|
key(app, k, M::NONE);
|
|
}
|
|
fn type_text(app: &mut App, text: &str) {
|
|
for c in text.chars() {
|
|
plain(app, K::Char(c));
|
|
}
|
|
}
|
|
fn field(app: &mut App, index: usize, text: &str) {
|
|
while app.dialog.as_ref().unwrap().focus != index {
|
|
plain(app, K::Tab);
|
|
}
|
|
key(app, K::Char('a'), M::CONTROL);
|
|
plain(app, K::Delete);
|
|
type_text(app, text);
|
|
}
|
|
fn menu(app: &mut App, command: Command) {
|
|
let menus = app.menus();
|
|
let (m, i) = menus
|
|
.iter()
|
|
.enumerate()
|
|
.find_map(|(m, menu)| {
|
|
menu.items
|
|
.iter()
|
|
.position(|i| i.command == Some(command))
|
|
.map(|i| (m, i))
|
|
})
|
|
.unwrap();
|
|
key(app, K::Char(menus[m].mnemonic), M::ALT);
|
|
for _ in 0..i {
|
|
plain(app, K::Down);
|
|
}
|
|
plain(app, K::Enter);
|
|
assert_eq!(app.last_command, Some(command));
|
|
}
|
|
fn draw(app: &mut App) -> (String, ratatui::buffer::Buffer) {
|
|
let mut term = Terminal::new(TestBackend::new(app.size.0, app.size.1)).unwrap();
|
|
term.draw(|f| app.render(f)).unwrap();
|
|
let b = term.backend().buffer().clone();
|
|
let text = b
|
|
.content
|
|
.chunks(app.size.0 as usize)
|
|
.map(|row| row.iter().map(|c| c.symbol()).collect::<String>())
|
|
.collect::<Vec<_>>()
|
|
.join("\n");
|
|
(text, b)
|
|
}
|
|
fn click(app: &mut App, x: u16, y: u16) {
|
|
app.handle(Event::Mouse(MouseEvent {
|
|
kind: MouseEventKind::Down(MouseButton::Left),
|
|
column: x,
|
|
row: y,
|
|
modifiers: M::NONE,
|
|
}));
|
|
}
|
|
|
|
#[test]
|
|
fn start_snapshot_and_reference_menus_have_all_commands() {
|
|
let t = Temp::new();
|
|
let mut app = t.app();
|
|
let (text, b) = draw(&mut app);
|
|
assert!(
|
|
text.contains("[1] Untitled")
|
|
&& text.contains("Project: Untitled")
|
|
&& text.contains("Copyright")
|
|
&& text.contains("00001:001")
|
|
);
|
|
assert_eq!(b[(4, 1)].bg, tb_ide::render::dos(5));
|
|
assert_eq!(b[(4, 1)].fg, tb_ide::render::dos(15));
|
|
assert_eq!(b[(4, 2)].bg, tb_ide::render::dos(1));
|
|
assert_eq!(b[(1, 29)].bg, tb_ide::render::dos(3));
|
|
assert_eq!(b[(1, 0)].bg, tb_ide::render::dos(7));
|
|
plain(&mut app, K::Char('x'));
|
|
assert_eq!(
|
|
app.project
|
|
.document(app.active_document().unwrap())
|
|
.unwrap()
|
|
.code(),
|
|
"x"
|
|
);
|
|
assert_eq!(
|
|
commands::menus(false)
|
|
.iter()
|
|
.map(|m| m.title)
|
|
.collect::<Vec<_>>(),
|
|
["File", "Edit", "View", "Search", "Run", "Debug", "Options", "Window", "Help"]
|
|
);
|
|
assert_eq!(
|
|
commands::menus(true)
|
|
.iter()
|
|
.map(|m| m.title)
|
|
.collect::<Vec<_>>(),
|
|
["File", "Edit", "View", "Tools", "Options", "Window", "Help"]
|
|
);
|
|
let reference = include_str!("../../../docs/ide-referenz.md");
|
|
for designer in [false, true] {
|
|
for m in commands::menus(designer) {
|
|
let mut mnemonics = std::collections::BTreeSet::new();
|
|
for item in m.items.iter().filter(|i| i.command.is_some()) {
|
|
let name = item.text();
|
|
assert!(
|
|
reference.contains(name.trim_end_matches('…'))
|
|
|| item.command == Some(Command::Diagnostics)
|
|
|| matches!(item.command, Some(Command::Tool(_))),
|
|
"Nicht in Referenz: {name}"
|
|
);
|
|
assert!(item.mnemonic().is_some());
|
|
assert!(
|
|
mnemonics.insert(item.mnemonic().unwrap()),
|
|
"Doppeltes Mnemonic in {}: {}",
|
|
m.title,
|
|
item.label
|
|
);
|
|
}
|
|
}
|
|
}
|
|
assert_eq!(
|
|
commands::menus(false)[0]
|
|
.items
|
|
.iter()
|
|
.filter_map(|i| i.command)
|
|
.collect::<Vec<_>>(),
|
|
[
|
|
Command::NewProject,
|
|
Command::OpenProject,
|
|
Command::SaveProject,
|
|
Command::NewForm,
|
|
Command::NewModule,
|
|
Command::AddFile,
|
|
Command::RemoveFile,
|
|
Command::SaveFile,
|
|
Command::SaveAs,
|
|
Command::LoadText,
|
|
Command::SaveText,
|
|
Command::Print,
|
|
Command::Shell,
|
|
Command::Exit
|
|
]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn modal_focus_and_dirty_project_cancel_preserve_document() {
|
|
let t = Temp::new();
|
|
let mut app = t.app();
|
|
type_text(&mut app, "PRINT 7");
|
|
let id = app.active_document().unwrap();
|
|
let active = app.active;
|
|
menu(&mut app, Command::NewModule);
|
|
type_text(&mut app, "Other");
|
|
plain(&mut app, K::F(6));
|
|
key(&mut app, K::Char('c'), M::CONTROL);
|
|
plain(&mut app, K::Esc);
|
|
assert_eq!(app.active, active);
|
|
assert_eq!(app.project.document(id).unwrap().code(), "PRINT 7");
|
|
assert!(app.basic_events.is_empty());
|
|
key(&mut app, K::F(4), M::ALT);
|
|
assert!(matches!(
|
|
app.dialog.as_ref().unwrap().kind,
|
|
DialogKind::Dirty(_)
|
|
));
|
|
plain(&mut app, K::Enter);
|
|
assert!(!app.quit);
|
|
menu(&mut app, Command::NewProject);
|
|
plain(&mut app, K::Right);
|
|
plain(&mut app, K::Enter);
|
|
assert!(matches!(
|
|
app.dialog.as_ref().unwrap().kind,
|
|
DialogKind::Save { .. }
|
|
));
|
|
plain(&mut app, K::Esc);
|
|
assert!(app.project.document(id).unwrap().is_dirty());
|
|
assert!(!app.quit);
|
|
menu(&mut app, Command::SaveProject);
|
|
field(&mut app, 0, &t.0.join("project.mak").display().to_string());
|
|
plain(&mut app, K::Enter);
|
|
assert!(app.dialog.is_none(), "{:?}", app.dialog);
|
|
assert!(!app.project.is_dirty());
|
|
menu(&mut app, Command::Exit);
|
|
assert!(app.quit);
|
|
}
|
|
|
|
#[test]
|
|
fn dispatcher_keeps_function_keys_and_copy_out_of_basic_input() {
|
|
let t = Temp::new();
|
|
let mut app = t.app();
|
|
key(&mut app, K::Char('c'), M::CONTROL);
|
|
assert_eq!(app.last_command, Some(Command::Copy));
|
|
assert!(app.editor.clipboard.is_empty());
|
|
assert!(app.basic_events.is_empty());
|
|
plain(&mut app, K::F(11));
|
|
assert!(app.menu.is_some());
|
|
plain(&mut app, K::Esc);
|
|
menu(&mut app, Command::NewForm);
|
|
let form = app.active_document();
|
|
assert_eq!(app.mode, Mode::Designer);
|
|
plain(&mut app, K::F(2));
|
|
assert!(app.value_focus);
|
|
plain(&mut app, K::F(10));
|
|
assert!(!app.properties && app.menu.is_some());
|
|
plain(&mut app, K::F(10));
|
|
assert!(app.properties && app.menu.is_none());
|
|
plain(&mut app, K::F(12));
|
|
assert_eq!(app.last_command, Some(Command::Events));
|
|
assert_eq!(app.active_document(), form);
|
|
assert!(app.basic_events.is_empty());
|
|
plain(&mut app, K::F(11));
|
|
plain(&mut app, K::Esc);
|
|
menu(&mut app, Command::Code);
|
|
plain(&mut app, K::Enter);
|
|
assert_eq!(app.mode, Mode::Environment);
|
|
app.execution = Execution::Paused;
|
|
plain(&mut app, K::F(10));
|
|
assert_eq!(app.last_command, Some(Command::ProcedureStep));
|
|
assert_eq!(app.availability(Command::ProcedureStep), None);
|
|
menu(&mut app, Command::Output);
|
|
app.execution = Execution::Running;
|
|
plain(&mut app, K::Char('a'));
|
|
assert_eq!(app.basic_events.len(), 1);
|
|
plain(&mut app, K::F(11));
|
|
assert_eq!(app.basic_events.len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn windows_restore_geometry_and_resize_without_document_loss() {
|
|
let t = Temp::new();
|
|
let mut app = t.app();
|
|
app.options.syntax_checking = false; // Dieser Test prüft Fenster mit absichtlich ungültigem Entwurf.
|
|
type_text(&mut app, "abc");
|
|
let doc = app.active_document().unwrap();
|
|
let first = app.active;
|
|
menu(&mut app, Command::NewWindow);
|
|
assert_eq!(app.active_document(), Some(doc));
|
|
assert_eq!(app.windows.len(), 3);
|
|
key(&mut app, K::F(8), M::CONTROL);
|
|
plain(&mut app, K::Left);
|
|
plain(&mut app, K::Up);
|
|
plain(&mut app, K::Enter);
|
|
key(&mut app, K::F(7), M::CONTROL);
|
|
plain(&mut app, K::Right);
|
|
plain(&mut app, K::Down);
|
|
plain(&mut app, K::Enter);
|
|
let normal = app.active_window().unwrap().normal;
|
|
key(&mut app, K::F(9), M::CONTROL);
|
|
assert_eq!(app.active_window().unwrap().state, WindowState::Minimized);
|
|
key(&mut app, K::F(10), M::CONTROL);
|
|
assert_eq!(app.active_window().unwrap().state, WindowState::Maximized);
|
|
key(&mut app, K::F(5), M::CONTROL);
|
|
assert_eq!(app.active_window().unwrap().normal, normal);
|
|
let active = app.active;
|
|
app.handle(Event::Resize(40, 12));
|
|
let (small, _) = draw(&mut app);
|
|
assert!(small.contains("mindestens"));
|
|
assert!(!small.contains("Untitled"));
|
|
plain(&mut app, K::Char('z'));
|
|
app.handle(Event::Resize(80, 25));
|
|
draw(&mut app);
|
|
assert_eq!(app.active, active);
|
|
assert_eq!(app.project.document(doc).unwrap().code(), "abc");
|
|
for w in &app.windows {
|
|
let r = app.rect(w);
|
|
assert!(r.right() <= 80 && r.bottom() <= 24);
|
|
}
|
|
key(&mut app, K::Char('-'), M::ALT);
|
|
assert!(app.control_menu);
|
|
plain(&mut app, K::Esc);
|
|
key(&mut app, K::F(4), M::CONTROL);
|
|
assert_eq!(app.windows.len(), 2);
|
|
assert!(app.project.document(doc).is_ok());
|
|
assert_eq!(app.active, first);
|
|
plain(&mut app, K::F(6));
|
|
assert_ne!(app.active, first);
|
|
key(&mut app, K::F(6), M::SHIFT);
|
|
assert_eq!(app.active, first);
|
|
menu(&mut app, Command::Arrange);
|
|
assert_eq!(app.windows[0].normal.right(), app.windows[1].normal.x);
|
|
}
|
|
|
|
#[test]
|
|
fn status_and_project_buttons_use_the_keyboard_command_path() {
|
|
let t = Temp::new();
|
|
let mut app = t.app();
|
|
draw(&mut app);
|
|
let before = app.active;
|
|
click(&mut app, 17, 29);
|
|
assert_eq!(app.last_command, Some(Command::NextWindow));
|
|
assert_ne!(app.active, before);
|
|
let project = app
|
|
.windows
|
|
.iter()
|
|
.find(|w| w.kind == WindowKind::Project)
|
|
.unwrap()
|
|
.clone();
|
|
let r = app.rect(&project);
|
|
draw(&mut app);
|
|
click(&mut app, r.x + 12, r.y + 2);
|
|
assert_eq!(app.last_command, Some(Command::Code));
|
|
plain(&mut app, K::Esc);
|
|
menu(&mut app, Command::NewForm);
|
|
draw(&mut app);
|
|
let (text, _) = draw(&mut app);
|
|
assert!(text.contains("Property:"));
|
|
assert!(!text.contains("<F6=Window>"));
|
|
}
|
|
|
|
#[test]
|
|
fn export_dialogs_validate_and_render_all_results_without_creating_files() {
|
|
let t = Temp::new();
|
|
let mut app = t.app();
|
|
app.export_backend = false;
|
|
let stamp = ProjectStamp::capture(&app.project);
|
|
for command in [Command::MakeExe, Command::MakeLibrary] {
|
|
menu(&mut app, command);
|
|
let output = if command == Command::MakeLibrary {
|
|
1
|
|
} else {
|
|
3
|
|
};
|
|
let (system, architecture) = if command == Command::MakeExe {
|
|
(
|
|
app.dialog.as_ref().unwrap().fields[1].string(),
|
|
app.dialog.as_ref().unwrap().fields[2].string(),
|
|
)
|
|
} else {
|
|
(String::new(), String::new())
|
|
};
|
|
let (text, _) = draw(&mut app);
|
|
assert!(text.contains("Erzeugen: Phase 6"));
|
|
field(&mut app, output, "");
|
|
plain(&mut app, K::Enter);
|
|
assert!(app.dialog.as_ref().unwrap().error.contains("Ausgabepfad"));
|
|
field(
|
|
&mut app,
|
|
output,
|
|
&t.0.join("notthere/out").display().to_string(),
|
|
);
|
|
plain(&mut app, K::Enter);
|
|
assert!(app
|
|
.dialog
|
|
.as_ref()
|
|
.unwrap()
|
|
.error
|
|
.contains("Zielverzeichnis"));
|
|
field(&mut app, output, &t.0.join("bad.tbc").display().to_string());
|
|
plain(&mut app, K::Enter);
|
|
assert!(app.dialog.as_ref().unwrap().error.contains("TBC"));
|
|
let existing = t.0.join("existing.tbl");
|
|
fs::write(&existing, b"keep").unwrap();
|
|
field(&mut app, output, &existing.display().to_string());
|
|
plain(&mut app, K::Enter);
|
|
assert!(app
|
|
.dialog
|
|
.as_ref()
|
|
.unwrap()
|
|
.error
|
|
.contains("Überschreibentscheidung"));
|
|
plain(&mut app, K::Tab);
|
|
plain(&mut app, K::Char(' '));
|
|
plain(&mut app, K::Enter);
|
|
assert_eq!(fs::read(&existing).unwrap(), b"keep");
|
|
assert!(app.dialog.as_ref().unwrap().request.is_some());
|
|
let target = t.0.join("result.tbl");
|
|
field(&mut app, output, &target.display().to_string());
|
|
plain(&mut app, K::Enter);
|
|
let request = app.dialog.as_ref().unwrap().request.clone().unwrap();
|
|
assert_eq!(request.system, system);
|
|
assert_eq!(request.architecture, architecture);
|
|
assert_eq!(request.project, stamp);
|
|
for status in [
|
|
ExportStatus::Running,
|
|
ExportStatus::Success,
|
|
ExportStatus::Failed("Testfehler".into()),
|
|
ExportStatus::Cancelled,
|
|
] {
|
|
app.export_result(&request, status.clone()).unwrap();
|
|
let (text, _) = draw(&mut app);
|
|
assert!(text.contains(&status.text()), "{text}");
|
|
assert!(!target.exists());
|
|
}
|
|
plain(&mut app, K::Esc);
|
|
assert_eq!(ProjectStamp::capture(&app.project), stamp);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn file_picker_save_conflict_and_project_replacement_use_real_events() {
|
|
let t = Temp::new();
|
|
let mut app = t.app();
|
|
let member = t.0.join("existing.bas");
|
|
fs::write(&member, "PRINT 2\n").unwrap();
|
|
menu(&mut app, Command::AddFile);
|
|
plain(&mut app, K::F(2));
|
|
let DialogKind::Browse { entries, .. } = &app.dialog.as_ref().unwrap().kind else {
|
|
panic!("Dateiwahl fehlt")
|
|
};
|
|
let index = entries.iter().position(|p| p == &member).unwrap();
|
|
for _ in 0..index {
|
|
plain(&mut app, K::Right);
|
|
}
|
|
plain(&mut app, K::Enter);
|
|
assert!(matches!(
|
|
app.dialog.as_ref().unwrap().kind,
|
|
DialogKind::AddFile
|
|
));
|
|
plain(&mut app, K::Enter);
|
|
let id = app.active_document().unwrap();
|
|
type_text(&mut app, "'edit\n");
|
|
fs::write(&member, "external\n").unwrap();
|
|
menu(&mut app, Command::SaveFile);
|
|
plain(&mut app, K::Enter);
|
|
assert!(app
|
|
.dialog
|
|
.as_ref()
|
|
.unwrap()
|
|
.error
|
|
.contains("Überschreibentscheidung"));
|
|
assert_eq!(fs::read_to_string(&member).unwrap(), "external\n");
|
|
plain(&mut app, K::Tab);
|
|
plain(&mut app, K::Char(' '));
|
|
plain(&mut app, K::Enter);
|
|
assert!(app.dialog.is_none());
|
|
assert!(!app.project.document(id).unwrap().is_dirty());
|
|
menu(&mut app, Command::LoadText);
|
|
plain(&mut app, K::F(2));
|
|
plain(&mut app, K::Esc);
|
|
assert!(matches!(
|
|
app.dialog.as_ref().unwrap().kind,
|
|
DialogKind::LoadText
|
|
));
|
|
plain(&mut app, K::Esc);
|
|
let path = t.0.join("sub/p.mak");
|
|
fs::create_dir(path.parent().unwrap()).unwrap();
|
|
fs::write(&path, "main.bas\n").unwrap();
|
|
fs::write(path.parent().unwrap().join("main.bas"), "END\n").unwrap();
|
|
menu(&mut app, Command::OpenProject);
|
|
field(&mut app, 0, &path.display().to_string());
|
|
plain(&mut app, K::Enter);
|
|
assert!(matches!(
|
|
app.dialog.as_ref().unwrap().kind,
|
|
DialogKind::Dirty(_)
|
|
));
|
|
plain(&mut app, K::Right);
|
|
plain(&mut app, K::Right);
|
|
plain(&mut app, K::Enter);
|
|
assert!(app.dialog.is_none());
|
|
assert_eq!(app.project.path(), Some(path.as_path()));
|
|
menu(&mut app, Command::NewProject);
|
|
assert!(app.dialog.is_none());
|
|
assert_eq!(app.project.members().len(), 1);
|
|
assert_eq!(app.project.directory(), path.parent().unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn exit_with_partial_save_retains_dialog_and_unsaved_documents() {
|
|
let t = Temp::new();
|
|
fs::write(t.0.join("a.bas"), "END\n").unwrap();
|
|
fs::write(t.0.join("b.bas"), "END\n").unwrap();
|
|
let mak = t.0.join("p.mak");
|
|
fs::write(&mak, "a.bas\nb.bas\n").unwrap();
|
|
let mut app = t.app();
|
|
app.load_initial_project(mak.clone()).unwrap();
|
|
let ids = app.project.members();
|
|
for id in &ids {
|
|
app.project.replace_text(*id, 0..0, "' changed\n").unwrap();
|
|
}
|
|
let b = t.0.join("b.bas");
|
|
let original = fs::metadata(&b).unwrap().permissions();
|
|
let mut perms = original.clone();
|
|
perms.set_readonly(true);
|
|
fs::set_permissions(&b, perms).unwrap();
|
|
key(&mut app, K::F(4), M::ALT);
|
|
plain(&mut app, K::Right);
|
|
plain(&mut app, K::Enter);
|
|
plain(&mut app, K::Enter);
|
|
assert!(app
|
|
.dialog
|
|
.as_ref()
|
|
.unwrap()
|
|
.error
|
|
.contains("schreibgeschützt"));
|
|
assert!(!app.quit);
|
|
assert!(!app.project.document(ids[0]).unwrap().is_dirty());
|
|
assert!(app.project.document(ids[1]).unwrap().is_dirty());
|
|
assert_eq!(fs::read_to_string(&mak).unwrap(), "a.bas\nb.bas\n");
|
|
fs::set_permissions(&b, original).unwrap();
|
|
plain(&mut app, K::Enter);
|
|
assert!(app.quit);
|
|
assert!(!app.project.is_dirty());
|
|
}
|
|
|
|
#[test]
|
|
fn mouse_focus_is_modal_and_program_abort_is_not_editor_copy() {
|
|
let t = Temp::new();
|
|
let mut app = t.app();
|
|
let active = app.active;
|
|
menu(&mut app, Command::NewModule);
|
|
draw(&mut app);
|
|
click(&mut app, 85, 2);
|
|
assert_eq!(app.active, active);
|
|
plain(&mut app, K::Esc);
|
|
menu(&mut app, Command::Output);
|
|
app.execution = Execution::Running;
|
|
key(&mut app, K::Char('c'), M::CONTROL);
|
|
assert_eq!(app.execution, Execution::Paused);
|
|
assert!(app.basic_events.is_empty());
|
|
plain(&mut app, K::Char('x'));
|
|
assert!(
|
|
app.basic_events.is_empty(),
|
|
"Tasten nach Break gehören nicht mehr BASIC"
|
|
);
|
|
app.execution = Execution::Running;
|
|
let r = app.rect(app.active_window().unwrap());
|
|
let mouse = MouseEvent {
|
|
kind: MouseEventKind::Down(MouseButton::Right),
|
|
column: r.x + 2,
|
|
row: r.y + 2,
|
|
modifiers: M::NONE,
|
|
};
|
|
app.handle(Event::Mouse(mouse));
|
|
let mut local = mouse;
|
|
local.column = 1;
|
|
local.row = 1;
|
|
assert_eq!(app.basic_events.last(), Some(&Event::Mouse(local)));
|
|
app.execution = Execution::Idle;
|
|
menu(&mut app, Command::RightMouse);
|
|
plain(&mut app, K::Char(' '));
|
|
plain(&mut app, K::Enter);
|
|
let before = app.last_command;
|
|
app.handle(Event::Mouse(MouseEvent {
|
|
kind: MouseEventKind::Down(MouseButton::Right),
|
|
column: 2,
|
|
row: 2,
|
|
modifiers: M::NONE,
|
|
}));
|
|
assert_eq!(app.last_command, before);
|
|
menu(&mut app, Command::RightMouse);
|
|
plain(&mut app, K::Char(' '));
|
|
plain(&mut app, K::Enter);
|
|
app.handle(Event::Mouse(MouseEvent {
|
|
kind: MouseEventKind::Down(MouseButton::Right),
|
|
column: 2,
|
|
row: 2,
|
|
modifiers: M::NONE,
|
|
}));
|
|
assert_eq!(app.last_command, Some(Command::Topic));
|
|
}
|
|
|
|
#[test]
|
|
fn designer_form_list_and_context_availability_match_the_active_window() {
|
|
let t = Temp::new();
|
|
fs::write(
|
|
t.0.join("Form1.frm"),
|
|
"VERSION 1.00\nBegin Form Existing\nEnd\n",
|
|
)
|
|
.unwrap();
|
|
let mut app = t.app();
|
|
menu(&mut app, Command::NewForm);
|
|
assert_eq!(
|
|
app.project
|
|
.document(app.active_document().unwrap())
|
|
.unwrap()
|
|
.source_path()
|
|
.file_name()
|
|
.unwrap(),
|
|
"Form2.frm"
|
|
);
|
|
let entries = app.window_commands();
|
|
assert_eq!(entries.len(), 1);
|
|
assert!(entries[0].0.starts_with("• Form:"));
|
|
plain(&mut app, K::F(11));
|
|
key(&mut app, K::Char('h'), M::ALT);
|
|
assert_eq!(app.menus()[app.menu.unwrap().0].title, "Help");
|
|
plain(&mut app, K::Esc);
|
|
menu(&mut app, Command::Code);
|
|
plain(&mut app, K::Enter);
|
|
menu(&mut app, Command::Project);
|
|
assert!(app
|
|
.availability(Command::LoadText)
|
|
.unwrap()
|
|
.contains("Codefenster"));
|
|
}
|
|
|
|
#[test]
|
|
fn clicking_project_members_and_dialog_choices_transfers_focus_and_applies_values() {
|
|
let t = Temp::new();
|
|
let mut app = t.app();
|
|
menu(&mut app, Command::NewForm);
|
|
menu(&mut app, Command::Code);
|
|
plain(&mut app, K::Enter);
|
|
menu(&mut app, Command::Project);
|
|
draw(&mut app);
|
|
let r = app.rect(app.active_window().unwrap());
|
|
// Zweites Mitglied ist das Formular; der Listenklick bindet Enter an Project.
|
|
click(&mut app, r.x + 3, r.y + 5);
|
|
assert_eq!(app.active_window().unwrap().kind, WindowKind::Project);
|
|
plain(&mut app, K::Enter);
|
|
assert_eq!(app.mode, Mode::Designer);
|
|
menu(&mut app, Command::RightMouse);
|
|
draw(&mut app);
|
|
let hit = app
|
|
.hits
|
|
.iter()
|
|
.find(|(_, h)| matches!(h, tb_ide::app::Hit::DialogField(0)))
|
|
.unwrap()
|
|
.0;
|
|
click(&mut app, hit.x, hit.y);
|
|
plain(&mut app, K::Enter);
|
|
assert!(!app.options.right_help);
|
|
}
|
|
|
|
#[test]
|
|
fn options_apply_persist_across_bases_and_preserve_unsaved_values_on_error() {
|
|
let t = Temp::new();
|
|
let mut app = t.app();
|
|
menu(&mut app, Command::Display);
|
|
// Titelhintergrund: Palette 5 -> 6, Desktopzeichen und Tabweite.
|
|
while app.dialog.as_ref().unwrap().focus != 7 {
|
|
plain(&mut app, K::Tab);
|
|
}
|
|
plain(&mut app, K::Right);
|
|
field(&mut app, 14, ".");
|
|
field(&mut app, 15, "4");
|
|
plain(&mut app, K::Enter);
|
|
assert!(app.dialog.is_none());
|
|
let (_, b) = draw(&mut app);
|
|
assert_eq!(b[(4, 1)].bg, tb_ide::render::dos(6));
|
|
assert_eq!(app.options.tab_width, 4);
|
|
let include = t.0.join("includes");
|
|
fs::create_dir(&include).unwrap();
|
|
fs::write(include.join("shared.bi"), "PRINT 42\n").unwrap();
|
|
menu(&mut app, Command::Paths);
|
|
field(&mut app, 2, &include.display().to_string());
|
|
plain(&mut app, K::Enter);
|
|
let id = app.active_document().unwrap();
|
|
app.project
|
|
.replace_text(id, 0..0, "'$INCLUDE: 'shared.bi'\n")
|
|
.unwrap();
|
|
assert!(app.project.sources().unwrap().units[0]
|
|
.segments
|
|
.iter()
|
|
.any(|s| s.text == "PRINT 42\n"));
|
|
menu(&mut app, Command::SyntaxChecking);
|
|
assert!(!app.options.syntax_checking);
|
|
menu(&mut app, Command::SaveOptions);
|
|
plain(&mut app, K::Enter);
|
|
assert!(app.dialog.is_none());
|
|
let elsewhere = t.0.join("elsewhere");
|
|
fs::create_dir(&elsewhere).unwrap();
|
|
let fresh = App::new(&elsewhere, app.config_path.clone(), (80, 25)).unwrap();
|
|
assert_eq!(fresh.options, app.options);
|
|
let mut perms = fs::metadata(&app.config_path).unwrap().permissions();
|
|
let original = perms.clone();
|
|
perms.set_readonly(true);
|
|
fs::set_permissions(&app.config_path, perms).unwrap();
|
|
menu(&mut app, Command::SyntaxChecking);
|
|
menu(&mut app, Command::SaveOptions);
|
|
plain(&mut app, K::Enter);
|
|
assert!(app
|
|
.dialog
|
|
.as_ref()
|
|
.unwrap()
|
|
.error
|
|
.contains("schreibgeschützt"));
|
|
assert_ne!(app.options, app.saved_options);
|
|
fs::set_permissions(&app.config_path, original).unwrap();
|
|
fs::write(
|
|
&app.config_path,
|
|
"version=1\ntab_width=0\ncolor.3=999,5\ndesktop=xx\nfuture=foo\n",
|
|
)
|
|
.unwrap();
|
|
let (defaults, errors, _) = Options::load(&app.config_path);
|
|
assert_eq!(defaults, Options::default());
|
|
assert_eq!(errors.len(), 4);
|
|
}
|
|
|
|
fn await_export(app: &mut App) -> ExportStatus {
|
|
let start = std::time::Instant::now();
|
|
loop {
|
|
app.tick_export();
|
|
let status = app.dialog.as_ref().unwrap().export_status.clone();
|
|
if status != ExportStatus::Running {
|
|
return status;
|
|
}
|
|
assert!(start.elapsed().as_secs() < 10, "Export hängt");
|
|
std::thread::sleep(std::time::Duration::from_millis(2));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn real_library_export_uses_dirty_include_and_mouse_without_runtime_template() {
|
|
let t = Temp::new();
|
|
fs::write(
|
|
t.0.join("lib.bas"),
|
|
"SUB Answer\n'$INCLUDE: 'body.bi'\nEND SUB\n",
|
|
)
|
|
.unwrap();
|
|
fs::write(t.0.join("body.bi"), "PRINT 1\n").unwrap();
|
|
let mut app = t.app();
|
|
app.load_initial_project(t.0.join("lib.bas")).unwrap();
|
|
let include = app.project.find_document(&t.0.join("body.bi")).unwrap();
|
|
app.project
|
|
.replace_text(include, 0..8, "PRINT 42\n")
|
|
.unwrap();
|
|
let stamp = ProjectStamp::capture(&app.project);
|
|
menu(&mut app, Command::MakeLibrary);
|
|
assert_eq!(app.dialog.as_ref().unwrap().fields.len(), 3);
|
|
let out = t.0.join("out.tbl");
|
|
field(&mut app, 1, &out.display().to_string());
|
|
draw(&mut app);
|
|
let r = app
|
|
.hits
|
|
.iter()
|
|
.find(|(_, h)| matches!(h, Hit::DialogSubmit))
|
|
.unwrap()
|
|
.0;
|
|
app.handle(Event::Mouse(MouseEvent {
|
|
kind: MouseEventKind::Down(MouseButton::Left),
|
|
column: r.x,
|
|
row: r.y,
|
|
modifiers: M::NONE,
|
|
}));
|
|
assert_eq!(await_export(&mut app), ExportStatus::Success);
|
|
assert_eq!(ProjectStamp::capture(&app.project), stamp);
|
|
assert!(app.project.document(include).unwrap().is_dirty());
|
|
assert_eq!(
|
|
fs::read_to_string(t.0.join("body.bi")).unwrap(),
|
|
"PRINT 1\n"
|
|
);
|
|
plain(&mut app, K::Esc);
|
|
assert_eq!(app.last_export.as_ref().unwrap().1, ExportStatus::Success);
|
|
fs::remove_file(t.0.join("lib.bas")).unwrap();
|
|
fs::remove_file(t.0.join("body.bi")).unwrap();
|
|
fs::write(t.0.join("consumer.bas"), "CALL Answer\nEND\n").unwrap();
|
|
fs::write(t.0.join("consumer.mak"), "consumer.bas\nout.tbl\n").unwrap();
|
|
app.load_initial_project(t.0.join("consumer.mak")).unwrap();
|
|
app.start_execution().unwrap();
|
|
for n in 0..100 {
|
|
app.tick_execution(n);
|
|
if app.execution == Execution::Ended {
|
|
break;
|
|
}
|
|
}
|
|
assert_eq!(tb_runtime::snapshot::text(app.session.screen()), " 42 \n");
|
|
}
|
|
|
|
#[test]
|
|
fn executable_target_validation_and_missing_template_are_honest() {
|
|
use tb_ide::{
|
|
documents::Destination,
|
|
export::{Artifact, ExportRequest},
|
|
};
|
|
let t = Temp::new();
|
|
let mut app = t.app();
|
|
for (system, arch) in [
|
|
("windows", "aarch64"),
|
|
("macos", "x86_64"),
|
|
("unknown", "x86_64"),
|
|
] {
|
|
assert!(ExportRequest::validate(
|
|
&app.project,
|
|
Artifact::Executable,
|
|
system,
|
|
arch,
|
|
&Destination::new(t.0.join("out"))
|
|
)
|
|
.is_err());
|
|
}
|
|
app.runtime_dir = t.0.join("missing-runtimes");
|
|
menu(&mut app, Command::MakeExe);
|
|
let out = t.0.join("out");
|
|
field(&mut app, 3, &out.display().to_string());
|
|
plain(&mut app, K::Enter);
|
|
let status = await_export(&mut app);
|
|
assert!(
|
|
matches!(&status, ExportStatus::Failed(e) if e.contains("Runtime-Vorlage fehlt")),
|
|
"{status:?}"
|
|
);
|
|
assert!(!out.exists());
|
|
assert!(app.dialog.is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn debugger_reports_absent_library_source_and_can_step_back_to_caller() {
|
|
let t = Temp::new();
|
|
let path = t.0.join("lib.bas");
|
|
fs::write(&path, "SUB Answer\nPRINT 42\nEND SUB\n").unwrap();
|
|
let mut compiler = tb_vm::project::ProjectCompiler::default();
|
|
compiler.debug_symbols = true;
|
|
let bytes = tb_vm::project_io::SourceLoader::default()
|
|
.load(&path)
|
|
.unwrap()
|
|
.compile_library(&mut compiler)
|
|
.unwrap()
|
|
.to_tbl()
|
|
.unwrap();
|
|
fs::write(t.0.join("lib.tbl"), bytes).unwrap();
|
|
fs::remove_file(&path).unwrap();
|
|
fs::write(t.0.join("main.bas"), "CALL Answer\nPRINT 9\nEND\n").unwrap();
|
|
fs::write(t.0.join("main.mak"), "main.bas\nlib.tbl\n").unwrap();
|
|
let mut app = t.app();
|
|
app.load_initial_project(t.0.join("main.mak")).unwrap();
|
|
let documents = app.project.documents().count();
|
|
let mut missing = false;
|
|
for _ in 0..10 {
|
|
app.execute(Command::Step);
|
|
for n in 0..100 {
|
|
app.tick_execution(n);
|
|
if app.execution != Execution::Running {
|
|
break;
|
|
}
|
|
}
|
|
if app.message.contains("Bibliotheksquelle nicht verfügbar") {
|
|
missing = true;
|
|
break;
|
|
}
|
|
}
|
|
assert!(missing, "{}", app.message);
|
|
assert_eq!(app.project.documents().count(), documents);
|
|
assert!(!path.exists());
|
|
app.execute(Command::ProcedureStep);
|
|
for n in 0..100 {
|
|
app.tick_execution(n);
|
|
if app.execution != Execution::Running {
|
|
break;
|
|
}
|
|
}
|
|
app.execute(Command::Continue);
|
|
for n in 0..100 {
|
|
app.tick_execution(n);
|
|
if app.execution == Execution::Ended {
|
|
break;
|
|
}
|
|
}
|
|
assert_eq!(app.execution, Execution::Ended, "{}", app.message);
|
|
assert_eq!(
|
|
tb_runtime::snapshot::text(app.session.screen()),
|
|
" 42 \n 9 \n"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn finalization_failure_is_reported_and_preserves_existing_output() {
|
|
let t = Temp::new();
|
|
let mut app = t.app();
|
|
let target = tb_export::Target::MacosArm64;
|
|
app.runtime_dir = t.0.join("runtimes");
|
|
let template = app
|
|
.runtime_dir
|
|
.join(target.triple())
|
|
.join(target.runtime_name());
|
|
fs::create_dir_all(template.parent().unwrap()).unwrap();
|
|
// Header für den negativen Finalisierungstest, kein ausführbarer Zielnachweis.
|
|
let mut header = vec![0; 256];
|
|
header[..4].copy_from_slice(&[0xcf, 0xfa, 0xed, 0xfe]);
|
|
header[4..8].copy_from_slice(&0x0100000cu32.to_le_bytes());
|
|
header[12..16].copy_from_slice(&2u32.to_le_bytes());
|
|
header.extend_from_slice(&tb_export::runtime_marker(target));
|
|
fs::write(&template, header).unwrap();
|
|
tb_export::prepare_template(&template, target).unwrap();
|
|
menu(&mut app, Command::MakeExe);
|
|
for (n, value) in [(1, "macos"), (2, "aarch64")] {
|
|
while app.dialog.as_ref().unwrap().focus != n {
|
|
plain(&mut app, K::Tab);
|
|
}
|
|
while app.dialog.as_ref().unwrap().fields[n].string() != value {
|
|
plain(&mut app, K::Right);
|
|
}
|
|
}
|
|
let out = t.0.join("existing");
|
|
fs::write(&out, b"old").unwrap();
|
|
field(&mut app, 3, &out.display().to_string());
|
|
plain(&mut app, K::Tab);
|
|
plain(&mut app, K::Char(' '));
|
|
plain(&mut app, K::Enter);
|
|
let status = await_export(&mut app);
|
|
assert!(
|
|
matches!(&status,ExportStatus::Failed(e) if e.contains("Finalisierung")),
|
|
"{status:?}"
|
|
);
|
|
assert_eq!(fs::read(&out).unwrap(), b"old");
|
|
assert!(fs::read_dir(&t.0).unwrap().all(|p| !p
|
|
.unwrap()
|
|
.file_name()
|
|
.to_string_lossy()
|
|
.starts_with(".tb-export-")));
|
|
}
|
|
|
|
// Prüft tatsächlich gerenderte Zellen, einschließlich geerbter Hintergründe.
|
|
fn theme_rgb(color: ratatui::style::Color) -> (u8, u8, u8) {
|
|
use ratatui::style::Color;
|
|
match color {
|
|
Color::Rgb(r, g, b) => (r, g, b),
|
|
Color::Indexed(n @ 16..=231) => {
|
|
let n = n - 16;
|
|
let channel = |v: u8| if v == 0 { 0 } else { 55 + v * 40 };
|
|
(channel(n / 36), channel(n / 6 % 6), channel(n % 6))
|
|
}
|
|
Color::Indexed(n @ 232..=255) => {
|
|
let v = 8 + (n - 232) * 10;
|
|
(v, v, v)
|
|
}
|
|
_ => {
|
|
let n = (0..16)
|
|
.find(|n| tb_ide::render::dos_color(*n, 16) == color)
|
|
.unwrap_or_else(|| panic!("Unbestimmte IDE-Farbe: {color:?}"));
|
|
theme_rgb(tb_ide::render::dos_color(n, u16::MAX))
|
|
}
|
|
}
|
|
}
|
|
fn theme_contrast(fg: ratatui::style::Color, bg: ratatui::style::Color) -> f64 {
|
|
let luminance = |color| {
|
|
let (r, g, b) = theme_rgb(color);
|
|
let linear = |v: u8| {
|
|
let v = f64::from(v) / 255.0;
|
|
if v <= 0.04045 {
|
|
v / 12.92
|
|
} else {
|
|
((v + 0.055) / 1.055).powf(2.4)
|
|
}
|
|
};
|
|
0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b)
|
|
};
|
|
let (a, b) = (luminance(fg), luminance(bg));
|
|
(a.max(b) + 0.05) / (a.min(b) + 0.05)
|
|
}
|
|
fn assert_theme(app: &mut App, context: &str) {
|
|
let (_, b) = draw(app);
|
|
for (i, c) in b.content.iter().enumerate() {
|
|
if !c.symbol().trim().is_empty() {
|
|
let ratio = theme_contrast(c.fg, c.bg);
|
|
assert!(
|
|
ratio >= 4.5,
|
|
"{context} ({},{}): {:?} {:?}/{:?}: {ratio:.2}:1",
|
|
i % app.size.0 as usize,
|
|
i / app.size.0 as usize,
|
|
c.symbol(),
|
|
c.fg,
|
|
c.bg
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn theme_contrast_covers_rendered_states_and_rejects_bad_pairs() {
|
|
use tb_ide::render::dos_color;
|
|
for colors in [256, u16::MAX] {
|
|
for (fg, bg) in tb_ide::options::Options::default().colors {
|
|
assert!(theme_contrast(dos_color(fg, colors), dos_color(bg, colors)) >= 4.5);
|
|
}
|
|
assert!(theme_contrast(dos_color(15, colors), dos_color(7, colors)) < 4.5);
|
|
for n in 0..16 {
|
|
let fg = if matches!(n, 0 | 1 | 4 | 5 | 6 | 8 | 9) {
|
|
15
|
|
} else {
|
|
0
|
|
};
|
|
assert!(
|
|
theme_contrast(dos_color(fg, colors), dos_color(n, colors)) >= 4.5,
|
|
"Palettenbeschriftung {n}"
|
|
);
|
|
}
|
|
}
|
|
let t = Temp::new();
|
|
let mut app = t.app();
|
|
app.options.syntax_checking = false;
|
|
type_text(&mut app, "PRINT 42");
|
|
assert_theme(&mut app, "Editor");
|
|
key(&mut app, K::Char('a'), M::CONTROL);
|
|
assert_theme(&mut app, "Textauswahl");
|
|
for m in 0..app.menus().len() {
|
|
for i in 0..app.menu_entries(m).len() {
|
|
app.menu = Some((m, i));
|
|
assert_theme(&mut app, "Menü einschließlich deaktivierter Einträge");
|
|
}
|
|
}
|
|
app.menu = None;
|
|
for command in [
|
|
Command::Display,
|
|
Command::Paths,
|
|
Command::MakeExe,
|
|
Command::MakeLibrary,
|
|
Command::Find,
|
|
Command::Replace,
|
|
Command::About,
|
|
] {
|
|
app.execute(command);
|
|
assert_theme(&mut app, "Dialog");
|
|
if let Some(d) = &mut app.dialog {
|
|
d.error = "Prüffehler: ungültiger Wert".into();
|
|
}
|
|
assert_theme(&mut app, "Dialogfehler");
|
|
app.dialog = None;
|
|
}
|
|
for command in [
|
|
Command::Project,
|
|
Command::Debug,
|
|
Command::Calls,
|
|
Command::HelpContents,
|
|
Command::Keyboard,
|
|
Command::UsingHelp,
|
|
] {
|
|
app.execute(command);
|
|
assert_theme(&mut app, "Projekt/Debugger/Hilfe");
|
|
plain(&mut app, K::Tab);
|
|
assert_theme(&mut app, "Fokus/Link");
|
|
}
|
|
let path = t.0.join("debug-colors.bas");
|
|
fs::write(&path, "x%=1\nx%=2\nPRINT x%\nEND\n").unwrap();
|
|
let mut debugger = t.app();
|
|
debugger.load_initial_project(path).unwrap();
|
|
plain(&mut debugger, K::Down);
|
|
debugger.execute(Command::Breakpoint);
|
|
assert_theme(&mut debugger, "Ungebundener Breakpoint");
|
|
debugger.execute(Command::Start);
|
|
for _ in 0..30 {
|
|
debugger.tick_execution(0);
|
|
if debugger.execution == tb_ide::app::Execution::Paused {
|
|
break;
|
|
}
|
|
}
|
|
assert_eq!(debugger.execution, tb_ide::app::Execution::Paused);
|
|
assert_theme(&mut debugger, "Gebundener Breakpoint und Ausführungszeile");
|
|
let (_, marks) = draw(&mut debugger);
|
|
assert!(marks
|
|
.content
|
|
.iter()
|
|
.any(|c| c.symbol() == "▶" && c.bg == tb_ide::render::dos(14)));
|
|
// Ein absichtlich schlechtes Standardpaar muss auch die Zellprüfung brechen.
|
|
let mut bad = t.app();
|
|
bad.options.colors[3] = (15, 7);
|
|
assert!(
|
|
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| assert_theme(
|
|
&mut bad,
|
|
"Negativprobe"
|
|
)))
|
|
.is_err()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn theme_color_commands_use_explicit_values_and_never_modify_terminal_palette() {
|
|
crossterm::style::force_color_output(true);
|
|
use ratatui::{
|
|
backend::{Backend, CrosstermBackend},
|
|
buffer::Cell,
|
|
style::Color,
|
|
};
|
|
use tb_ide::render::dos_color;
|
|
assert_eq!(dos_color(1, u16::MAX), Color::Rgb(0, 0, 170));
|
|
assert_eq!(dos_color(5, u16::MAX), Color::Rgb(170, 0, 170));
|
|
assert_eq!(dos_color(6, u16::MAX), Color::Rgb(170, 85, 0));
|
|
for colors in [16, 256, u16::MAX] {
|
|
for n in 0..16 {
|
|
let color = dos_color(n, colors);
|
|
if let Color::Indexed(index) = color {
|
|
assert!(index >= 16);
|
|
}
|
|
let mut cell = Cell::default();
|
|
cell.set_symbol("X")
|
|
.set_bg(color)
|
|
.set_fg(dos_color(15, colors));
|
|
let mut output = Vec::new();
|
|
CrosstermBackend::new(&mut output)
|
|
.draw(std::iter::once((0, 0, &cell)))
|
|
.unwrap();
|
|
let sequence = String::from_utf8(output).unwrap();
|
|
assert!(sequence.contains('X'));
|
|
if colors >= 256 {
|
|
assert!(sequence.contains("48;"));
|
|
}
|
|
if colors > 256 {
|
|
assert!(sequence.contains("48;2;"));
|
|
}
|
|
assert!(!sequence.contains("\x1b]")); // Keine globale Palettenänderung.
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn theme_designer_chrome_and_handles_preserve_program_palette() {
|
|
let t = Temp::new();
|
|
let mut app = t.app();
|
|
app.execute(Command::NewForm);
|
|
let root = app.design_objects().unwrap()[0].0;
|
|
app.design_select(root, false).unwrap();
|
|
let (_, b) = draw(&mut app);
|
|
let handles: Vec<_> = b.content.iter().filter(|c| c.symbol() == "■").collect();
|
|
assert!(!handles.is_empty());
|
|
for c in handles {
|
|
assert_eq!(
|
|
(c.fg, c.bg),
|
|
(tb_ide::render::dos(0), tb_ide::render::dos(14))
|
|
);
|
|
assert!(theme_contrast(c.fg, c.bg) >= 4.5);
|
|
}
|
|
let form = app.design_form().unwrap().clone();
|
|
let (_, screen) = tb_ide::designer::preview(&form, (100, 30)).unwrap();
|
|
let mut buf = ratatui::buffer::Buffer::empty(ratatui::layout::Rect::new(0, 0, 100, 30));
|
|
ratatui::widgets::Widget::render(tb_ui::screen::ScreenWidget(&screen), buf.area, &mut buf);
|
|
for (i, c) in buf.content.iter().enumerate() {
|
|
let original = screen.cell(i / 100 + 1, i % 100 + 1);
|
|
assert_eq!(c.bg, tb_ui::screen::basic_color(original.bg));
|
|
}
|
|
// Vorschau minimieren: ab hier gehören alle sichtbaren Zellen zur IDE.
|
|
app.execute(Command::Minimize);
|
|
for command in [Command::Toolbox, Command::Palette, Command::MenuDesign] {
|
|
app.execute(command);
|
|
assert_theme(&mut app, "Designer-Werkzeug");
|
|
}
|
|
}
|