d84914ef1e5a
empty_start.rs
//! The app starts with no project and no popup; File > Close goes back to that empty state.
use egui_kittest::Harness;
use egui_kittest::kittest::Queryable;
use serde_json::json;
use texturecraft_engine::Session;
use texturecraft_ui_egui::{TextureCraftApp, menus};
fn harness(session: Session) -> Harness<'static, TextureCraftApp> {
let mut harness = Harness::builder().with_size(egui::vec2(1600.0, 960.0)).build_eframe(|cc| TextureCraftApp::new(cc, session));
// The exact-text checks below need English, whatever the OS language is
harness.state_mut().ui.prefs.language = "en".into();
harness.run_steps(4);
harness
}
fn empty() -> Harness<'static, TextureCraftApp> {
harness(Session::closed().unwrap())
}
fn open_project() -> Harness<'static, TextureCraftApp> {
harness(texturecraft_engine::sample_session(256, 64).unwrap())
}
/// Texts painted this frame as (text, left edge)
fn painted(harness: &Harness<'static, TextureCraftApp>) -> Vec<(String, f32)> {
harness
.output()
.shapes
.iter()
.filter_map(|shape| match &shape.shape {
egui::Shape::Text(text) => Some((text.galley.text().to_string(), text.pos.x)),
_ => None,
})
.collect()
}
fn has_camera_picker(harness: &Harness<'static, TextureCraftApp>) -> bool {
painted(harness).iter().any(|(text, _)| text == "Default camera")
}
fn invoke(harness: &mut Harness<'static, TextureCraftApp>, id: &str) {
let ctx = harness.ctx.clone();
menus::invoke(harness.state_mut(), &ctx, id);
harness.run_steps(3);
}
#[test]
fn starts_with_no_project_and_no_popup() {
let harness = empty();
let ui = &harness.state().ui;
assert!(!harness.state().session.project_open);
assert!(!ui.windows.new_project && !ui.windows.about && !ui.windows.settings && !ui.windows.export, "no window opens by itself");
assert!(harness.query_by_label("Continue with the sample project").is_none() && harness.query_by_label("Recent projects").is_none(), "no start window");
assert!(harness.query_by_label("No properties found").is_some(), "Properties says it has nothing");
}
#[test]
fn project_items_are_disabled_without_a_project() {
let harness = empty();
let app = harness.state();
for id in [
"file.save",
"file.saveAs",
"file.saveCopy",
"file.close",
"ui.export",
"file.exportMesh",
"ui.projectConfig",
"edit.undo",
"edit.redo",
"file.reimportMesh",
"ui.mode.bake",
"ui.mode.render",
"ui.uvChecker",
"viewport.displayMaterial",
"tool.paint",
"tool.eraser",
"viewport.quickMask",
"layer.add.paint",
"layer.add.fill",
"layer.remove",
"bake.run",
"resource.import",
"material.load",
] {
assert!(!menus::enabled(app, id), "{id} needs a project");
}
for id in
["ui.newProject", "file.open", "project.sample", "ui.settings", "ui.about", "ui.quit", "ui.hideUi", "ui.resetUi", "viewport.frame", "ui.layout.split"]
{
assert!(menus::enabled(app, id), "{id} works without a project");
}
let open = open_project();
for id in ["file.save", "file.close", "ui.export", "layer.add.paint", "ui.mode.bake"] {
assert!(menus::enabled(open.state(), id), "{id} is on with a project");
}
}
#[test]
fn the_empty_views_keep_the_view_picker_and_drop_the_camera_picker() {
let empty = empty();
assert!(!has_camera_picker(&empty), "no camera picker");
// The picker shows "Material" right of the tool shelf and the Assets panel: one per view in the split layout
let pickers = painted(&empty).iter().filter(|(text, x)| text == "Material" && *x > 400.0).count();
assert_eq!(pickers, 2, "each of the two views keeps its view picker");
let open = open_project();
assert!(has_camera_picker(&open), "with a project the camera picker is there");
}
#[test]
fn the_status_bar_has_the_version_but_no_frame_time_or_layer_memory() {
for harness in [empty(), open_project()] {
assert!(harness.query_by_label_contains("Version:").is_some());
assert!(harness.query_by_label_contains("Layer memory").is_none());
assert!(harness.query_by_label_contains(" ms").is_none(), "no frame time");
}
}
#[test]
fn close_unloads_the_project_back_to_the_empty_state() {
let mut harness = open_project();
assert!(harness.state().session.project_open && harness.state().session.set_count() == 2);
invoke(&mut harness, "file.close");
assert!(!harness.state().session.project_open, "Close leaves no project open");
assert!(harness.state().session.path.is_none() && !harness.state().session.modified);
assert!(harness.query_by_label("No properties found").is_some());
assert!(!has_camera_picker(&harness));
assert!(!menus::enabled(harness.state(), "file.save"));
}
#[test]
fn creating_or_opening_a_project_from_the_empty_state_works() {
let mut harness = empty();
assert!(harness.state_mut().run("project.new", json!({"mesh": "cube", "resolution": 128})).is_some());
harness.run_steps(3);
assert!(harness.state().session.project_open);
assert!(menus::enabled(harness.state(), "file.save") && has_camera_picker(&harness));
invoke(&mut harness, "file.close");
invoke(&mut harness, "ui.newProject");
assert!(harness.state().ui.windows.new_project, "New project opens its dialog from the empty state");
let mut harness = empty();
invoke(&mut harness, "project.sample");
assert!(harness.state().session.project_open && harness.state().session.set_count() == 2, "the sample is still one menu click away");
}
#[test]
fn using_every_panel_and_menu_item_in_the_empty_state_does_not_panic() {
let mut harness = empty();
for item in menus::CATALOG
.iter()
.filter(|item| item.label != "-" && !matches!(item.id, "ui.quit" | "file.open" | "project.sample" | "ui.layout.load" | "ui.help.checkForUpdates"))
{
invoke(&mut harness, item.id);
}
for mode in ["ui.mode.bake", "ui.mode.render", "ui.mode.paint"] {
invoke(&mut harness, mode);
}
for id in ["ui.layout.2d", "ui.layout.3d", "ui.layout.split"] {
invoke(&mut harness, id);
}
assert!(!harness.state().session.project_open, "none of these opened a project");
assert!(!harness.state().session.can_undo(), "and none changed it");
}
#[test]
fn close_drops_the_pending_resize_and_the_viewport_images() {
let mut harness = open_project();
harness.state_mut().start_resize(0, 128);
assert!(harness.state().resize.is_some(), "a resize is running");
let had_image = texturecraft_ui_egui::control::screenshot(harness.state(), texturecraft_ui_egui::viewport::VIEW_3D).is_some();
invoke(&mut harness, "file.close");
assert!(harness.state().resize.is_none(), "Close drops the resize of the closed project");
assert!(!harness.state().session.modified, "a late resize result does not mark the empty project modified");
if had_image {
assert!(
texturecraft_ui_egui::control::screenshot(harness.state(), texturecraft_ui_egui::viewport::VIEW_3D).is_none(),
"no image of the closed project"
);
}
}
fn assert_eventually_released<T: ?Sized>(reference: &std::sync::Weak<T>) {
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
while reference.strong_count() > 0 && std::time::Instant::now() < deadline {
std::thread::sleep(std::time::Duration::from_millis(5));
}
assert_eq!(reference.strong_count(), 0, "the old project must be released after background work finishes");
}
#[test]
fn control_project_replacement_discards_the_old_resize() {
let mut harness = open_project();
let resource = std::sync::Arc::new(vec![0; 1_048_576]);
let old_resource = std::sync::Arc::downgrade(&resource);
harness.state_mut().session.doc.resources.insert("lifetime-probe.bin".into(), resource);
let old_mesh = std::sync::Arc::downgrade(&harness.state().session.mesh);
harness.state_mut().start_resize(0, 128);
assert!(harness.state().resize.is_some());
let resize_progress = std::sync::Arc::downgrade(&harness.state().resize.as_ref().unwrap().progress);
let owners_before = resize_progress.strong_count();
let ctx = harness.ctx.clone();
let reply = texturecraft_ui_egui::control::handle(
harness.state_mut(),
&ctx,
"command.run",
&json!({"id": "project.new", "params": {"mesh": "cube", "resolution": 128}}),
);
assert_eq!(reply["ok"], true);
assert!(harness.state().session.project_open);
assert!(harness.state().resize.is_none(), "the previous project's resize must be discarded");
let owners_after = resize_progress.strong_count();
eprintln!("control resize progress owners: {owners_before} before, {owners_after} after replacement");
assert!(owners_after < owners_before && owners_after <= 1);
assert_eventually_released(&resize_progress);
assert_eventually_released(&old_mesh);
assert_eventually_released(&old_resource);
eprintln!(
"released old mesh and 1_048_576-byte resource after replacement: mesh={}, resource={}, progress={}",
old_mesh.strong_count(),
old_resource.strong_count(),
resize_progress.strong_count()
);
harness.run_steps(3);
assert!(!harness.state().session.modified && !harness.state().session.can_undo(), "the old resize must not change the new project");
}
#[test]
fn control_close_rejects_a_viewport_capture_before_the_next_frame() {
let mut harness = open_project();
let ctx = harness.ctx.clone();
let reply = texturecraft_ui_egui::control::handle(harness.state_mut(), &ctx, "command.run", &json!({"id": "file.close"}));
assert_eq!(reply["ok"], true);
assert!(!harness.state().session.project_open);
assert!(texturecraft_ui_egui::control::screenshot(harness.state(), texturecraft_ui_egui::viewport::VIEW_3D).is_none());
}
#[test]
fn control_close_dismisses_the_export_dialog() {
let mut harness = open_project();
harness.state_mut().ui.windows.export = true;
let ctx = harness.ctx.clone();
let reply = texturecraft_ui_egui::control::handle(harness.state_mut(), &ctx, "command.run", &json!({"id": "file.close"}));
assert_eq!(reply["ok"], true);
assert!(!harness.state().session.project_open);
assert!(!harness.state().ui.windows.export, "Close dismisses the dialog before the next frame");
}
#[test]
fn uploaded_project_replacement_discards_the_old_resize() {
let mut harness = open_project();
let bytes = harness.state().session.to_project_bytes().unwrap();
let resource = std::sync::Arc::new(vec![0; 2_097_152]);
let old_resource = std::sync::Arc::downgrade(&resource);
harness.state_mut().session.doc.resources.insert("lifetime-probe.bin".into(), resource);
let old_mesh = std::sync::Arc::downgrade(&harness.state().session.mesh);
harness.state_mut().start_resize(0, 128);
assert!(harness.state().resize.is_some());
let resize_progress = std::sync::Arc::downgrade(&harness.state().resize.as_ref().unwrap().progress);
let owners_before = resize_progress.strong_count();
texturecraft_ui_egui::web_files::load(harness.state_mut(), "replacement.tcraft", bytes);
assert!(harness.state().session.project_open);
assert!(harness.state().resize.is_none(), "the previous project's resize must be discarded");
let owners_after = resize_progress.strong_count();
eprintln!("upload resize progress owners: {owners_before} before, {owners_after} after replacement");
assert!(owners_after < owners_before && owners_after <= 1);
assert_eventually_released(&resize_progress);
assert_eventually_released(&old_mesh);
assert_eventually_released(&old_resource);
eprintln!(
"released old mesh and 2_097_152-byte resource after replacement: mesh={}, resource={}, progress={}",
old_mesh.strong_count(),
old_resource.strong_count(),
resize_progress.strong_count()
);
harness.run_steps(3);
assert!(!harness.state().session.modified && !harness.state().session.can_undo(), "the old resize must not change the uploaded project");
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn file_new_discards_the_old_resize() {
let path = std::env::temp_dir().join(format!("texturecraft-file-new-resize-{}.obj", std::process::id()));
std::fs::write(&path, "v 0 0 0\nv 1 0 0\nv 0 1 0\nvt 0 0\nvt 1 0\nvt 0 1\nf 1/1 2/2 3/3\n").unwrap();
let mut harness = open_project();
harness.state_mut().start_resize(0, 128);
assert!(harness.state().resize.is_some());
let result = harness.state_mut().run("file.new", json!({"mesh": path.display().to_string(), "resolution": 128}));
let _ = std::fs::remove_file(&path);
assert!(result.is_some());
assert!(harness.state().session.project_open);
assert!(harness.state().resize.is_none(), "the previous project's resize must be discarded");
harness.run_steps(3);
assert!(!harness.state().session.modified && !harness.state().session.can_undo(), "the old resize must not change the mesh project");
}
#[test]
fn closed_session_rejects_project_control_operations() {
for (method, params) in [("ui.bake.start", json!({"ts": 0})), ("debug.paintTest", json!({"from": [640, 400], "to": [650, 400], "frames": 2}))] {
let mut harness = empty();
let ctx = harness.ctx.clone();
let reply = texturecraft_ui_egui::control::handle(harness.state_mut(), &ctx, method, ¶ms);
assert_eq!(reply["ok"], false, "{method}: {reply}");
assert!(reply["error"].as_str().unwrap().contains("no project is open"));
assert!(harness.state().bake.is_none());
assert!(harness.state().session.bake_preview.is_none());
harness.run_steps(3);
assert!(!harness.state().session.modified && !harness.state().session.can_undo());
}
}
#[test]
fn close_releases_the_layer_thumbnail_snapshot() {
for _ in 0..2 {
let mut harness = open_project();
let old_mesh = std::sync::Arc::downgrade(&harness.state().session.mesh);
let old_maps: Vec<_> = harness
.state()
.session
.doc
.baked
.values()
.flat_map(|maps| maps.maps.values())
.map(|pixels| (std::sync::Arc::downgrade(pixels), std::mem::size_of_val(pixels.as_slice())))
.collect();
let tracked_bytes: usize = old_maps.iter().map(|(_, bytes)| bytes).sum();
invoke(&mut harness, "file.close");
assert!(!harness.state().session.project_open);
assert_eventually_released(&old_mesh);
for (pixels, _) in &old_maps {
assert_eventually_released(pixels);
}
eprintln!(
"closed thumbnail snapshot: mesh owners={}, {} baked-map allocations ({} bytes) released",
old_mesh.strong_count(),
old_maps.len(),
tracked_bytes
);
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.