//! 运行时集成回归与示例验收。测试经真实 Aster 前端、编译器、VM 和展示协议执行,不是手工伪造布局结果。 //! 覆盖共享对象/独立 Mount、源覆盖、绑定、窗口、任务、取消、二维/三维投影及像素。局部辅助函数负责取统计值、收敛刷新和构造可重复输入。 //! 阅读时先看每个测试提交的 Endor 程序,再看后续变更与最终断言;编译成功、回调成功、文档发布成功是不同检查点。 //! use super::*; use crate::document::{NamespaceState, RenderCommand}; const EXAMPLE: &str = include_str!("../../../examples/hello.endor"); const PAGE: &str = include_str!("../../../examples/page.endor"); /// 可选性能基准:分别测世界 UI 和普通三维场景在 1x/2x DPI 下的相机交互更新、变更绘制和同列表缓存绘制。 /// 默认 ignore,需在已确认的构建环境中以 release 单测试线程运行,避免其他测试干扰;下面命令仅为运行说明。 /// cargo test --release --locked scene_interaction_performance -- --ignored --nocapture --test-threads=1 #[test] #[ignore] fn scene_interaction_performance() { use std::time::Instant; /// 对非空毫秒样本排序后返回均值、索引中位数和向上取整秩的 p95;调用方每组固定保留 30 次测量。 fn summary(mut values: Vec) -> String { values.sort_by(f64::total_cmp); format!( "mean={:.3} p50={:.3} p95={:.3}ms", values.iter().sum::() / values.len() as f64, values[values.len() / 2], values[(values.len() * 95).div_ceil(100) - 1] ) } // 每个场景/DPI 组合创建全新会话与像素缓冲,避免上一组合的相机状态和缓存直接污染下一组。 for (name, source) in [ ("world-ui", include_str!("../../../examples/world-ui.endor")), ("scene3d", include_str!("../../../examples/scene3d.endor")), ] { for dpi in [1., 2.] { let (mut session, mut document) = ReplSession::load_with_viewport( source, "app.main", 1, 988, Some(crate::layout::Size { width: 1024., height: 800., }), ) .unwrap(); let (width, height) = ((1024. * dpi) as u32, (800. * dpi) as u32); let mut pixels = vec![0; (width * height) as usize]; let mut updates = Vec::new(); let mut draws = Vec::new(); let mut cached = Vec::new(); // 连续做 33 轮,前三轮预热;每轮使用最新发布版本构造事件,避免基准测到过期输入拒绝。 for sample in 0..33 { let target = document .frame .mounts .iter() .find(|mount| mount.scene3d_viewport) .unwrap(); // 选当前帧第一个三维视口,小幅 orbit;带中心锚点使世界面板等坐标映射路径也有完整输入。 let input = crate::events::Input { window: 1, session: document.frame.session, layout_version: document.frame.layout_version, mount: target.id, kind: "scene-orbit".into(), point: Some([target.x + target.width / 2., target.y + target.height / 2.]), delta: Some([1., 0.]), press_point: None, tab_drop: None, screen_position: None, }; // update 只计派发与完整文档刷新;display_list 构造在后面的绘制计时范围之外。 let start = Instant::now(); document = session.dispatch(&input).unwrap().document.unwrap(); let update = start.elapsed().as_secs_f64() * 1000.; let list = document.display_list(dpi).unwrap(); let start = Instant::now(); crate::software_renderer::SoftwareRenderer::render( &list, &mut pixels, width, height, ) .unwrap(); // 第一次 render 测相机已变化时的绘制;立即用同一列表再画一次,单独统计缓存重用路径。 let draw = start.elapsed().as_secs_f64() * 1000.; let start = Instant::now(); crate::software_renderer::SoftwareRenderer::render( &list, &mut pixels, width, height, ) .unwrap(); // 三类样本按同一轮配对保存,仅舍弃预热数据,不改变真实执行的相机操作。 if sample >= 3 { updates.push(update); draws.push(draw); cached.push(start.elapsed().as_secs_f64() * 1000.); } } println!( "PERF {name} dpi={dpi} update {} changed_draw {} cached_draw {}", summary(updates), summary(draws), summary(cached) ); // 额外打印派生工作量指标辅助解释耗时,不把这些查询本身算进上面的三类样本。 for stat in ["measured", "arranged", "snapshotVisited"] { println!( "PERFSTAT {name} {stat}={}", session .execute(&format!("ui.stats().{stat}"), "app.main") .unwrap() .value ); } } } } #[test] /// 源 measure 直接读取 mount.layoutVersion 并将其作为宽度。 /// 只使 paint 失效后仍必须重新测量;通过新版本宽度和零缓存命中,防止把真实 Mount 读取错误缓存。 fn actual_mount_version_reads_still_bypass_measurement_cache() { let (mut session, initial) = ReplSession::load( r#" class Versioned: RectBlock { function measure(self: Versioned,mount: Mount,constraints: Constraints): MeasureResult { return MeasureResult(mount.layoutVersion,20) } } rect=Versioned(80,20) page=Page() page.render(rect) "#, "app.main", 1, 241, ) .unwrap(); let next = session .execute("rect.invalidate(\"paint\")", "app.main") .unwrap() .document .unwrap(); assert!(next.frame.layout_version > initial.frame.layout_version); assert!(next.frame.commands.iter().any(|command|matches!(command,RenderCommand::RoundedRect{width,..} if *width==next.frame.layout_version as f32))); assert_eq!(source_measure_stat(&mut session, "sourceMeasureHits"), 0); assert!(source_measure_stat(&mut session, "sourceMeasureMisses") >= 2); } #[test] /// 加载布局协商示例,验证同一段落两个出现位置分别获得 280/360 的宽度。 /// 加宽第一个出现位置后高度和后继 y 减小,第二个仍保持 360,且全部 Mount ID 不变。 fn source_allocations_and_measurement_limits_settle_before_publication() { let (mut session, initial) = ReplSession::load_with_viewport( include_str!("../../../examples/layout-negotiation.endor"), "app.main", 1, 240, Some(crate::layout::Size { width: 850.0, height: 700.0, }), ) .unwrap(); let ids = initial .frame .mounts .iter() .map(|m| m.id) .collect::>(); let width0 = session .execute("paragraph.mounts().at(0).bounds().width", "app.main") .unwrap() .value; let width1 = session .execute("paragraph.mounts().at(1).bounds().width", "app.main") .unwrap() .value; assert_eq!(width0, "280"); assert_eq!(width1, "360"); let height = session .execute("paragraph.mounts().at(0).bounds().height", "app.main") .unwrap() .value .parse::() .unwrap(); let y = session .execute("tail.mounts().at(0).bounds().y", "app.main") .unwrap() .value .parse::() .unwrap(); assert!(height > 20.0); assert!(y >= height + 12.0); assert!(source_measure_stat(&mut session, "layoutPasses") >= 2); let changed = session .execute("wide.click()", "app.main") .unwrap() .document .unwrap(); assert_eq!( changed .frame .mounts .iter() .map(|m| m.id) .collect::>(), ids ); let wider = session .execute("paragraph.mounts().at(0).bounds().height", "app.main") .unwrap() .value .parse::() .unwrap(); let moved = session .execute("tail.mounts().at(0).bounds().y", "app.main") .unwrap() .value .parse::() .unwrap(); assert!(wider < height && moved < y); assert_eq!( session .execute("paragraph.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "560" ); assert_eq!( session .execute("paragraph.mounts().at(1).bounds().width", "app.main") .unwrap() .value, "360" ); } #[test] /// 源 arrange 把子项宽高不断交换,构造不收敛的布局状态。 /// 加载必须报告 cycle,不能发布某个偶然中间态或依靠固定次数静默停止。 fn alternating_source_allocations_are_rejected_as_a_cycle() { let source = r#" class Alternating: Column { function arrange(self: Alternating,mount: Mount,geometry: Bounds): Arrangement { result=Column.arrange(self,mount,geometry) result.children.at(0).width=geometry.height result.children.at(0).height=geometry.width return result } } page=Page() page.render(Alternating(0,0,RectBlock(120,60))) "#; let error = ReplSession::load(source, "app.main", 1, 1).err().unwrap(); assert!( error.to_string().contains("did not converge (cycle)"), "{error:#}" ); } #[test] /// 源 paint 只提供 wrapWidth,省略成对需要的 wrapHeight。 /// 检查命令解码明确拒绝不完整文字边界,而非生成测量/绘制不一致的帧。 fn source_text_paint_rejects_incomplete_wrap_bounds() { let source = r##" class Invalid: TextBlock { function paint(self: Invalid,mount: Mount,geometry: Bounds): DisplayList { command=PaintCommand() command.kind="text" command.x=0 command.y=0 command.text="invalid" command.size=1 command.color="#000000" command.wrapWidth=40 return DisplayList(ObjectList(command)) } } page=Page() page.render(Invalid("invalid")) "##; let error = ReplSession::load(source, "app.main", 1, 1).err().unwrap(); assert!(error.to_string().contains("wrapHeight"), "{error:#}"); } #[test] /// 分别对原生 TextBlock 和委托原生方法的源子类运行相同测试。 /// 共享文字在不同内边距下独立换行;视口变宽只更新几何、保留 Mount,直接测量和 setText 也应同步反映尺寸。 fn wrapped_text_tracks_each_occurrence_width_resize_and_sibling_geometry() { let text = "中文段落随着宽度变化而换行,后面的对象跟随段落高度移动。".repeat(8); for custom in [false, true] { let constructor = if custom { "Wrapped" } else { "TextBlock" }; let source = format!( r#" class Wrapped: TextBlock {{ function measure(self: Wrapped,mount: Mount,constraints: Constraints): MeasureResult {{return TextBlock.measure(self,mount,constraints)}} function paint(self: Wrapped,mount: Mount,geometry: Bounds): DisplayList {{return TextBlock.paint(self,mount,geometry)}} }} paragraph={constructor}("{text}") tail=TextBlock("tail") page=Page() page.render(Column(0,8,Column(0,8,paragraph,tail),Column(50,8,paragraph))) "# ); let (mut session, initial) = ReplSession::load_with_viewport( &source, "app.main", 1, 230, Some(crate::layout::Size { width: 240.0, height: 2000.0, }), ) .unwrap(); let ids: Vec<_> = initial.frame.mounts.iter().map(|m| m.id).collect(); let commands: Vec<_> = initial .frame .commands .iter() .filter_map(|command| match command { RenderCommand::Text { value, wrap_bounds: Some(bounds), .. } if value == &text => Some(*bounds), _ => None, }) .collect(); assert_eq!(commands.len(), 2); // 输入 viewport 已是页面可用区域,不再隐式扣侧栏。 // 第二个出现位置左右各有 50px 内边距,因此宽度比第一个少 100px。 assert_eq!(commands[0][0], 240.0); assert_eq!(commands[1][0], 140.0); assert!(commands[1][1] > commands[0][1]); let tail = initial .frame .commands .iter() .find_map(|command| match command { RenderCommand::Text { value, y, .. } if value == "tail" => Some(*y), _ => None, }) .unwrap(); assert!(tail >= commands[0][1] + 8.0); let resized = session .resize(Some(crate::layout::Size { width: 400.0, height: 2000.0, })) .unwrap() .unwrap(); assert_eq!( ids, resized .frame .mounts .iter() .map(|m| m.id) .collect::>() ); let widths: Vec<_> = resized .frame .commands .iter() .filter_map(|command| match command { RenderCommand::Text { value, wrap_bounds: Some(bounds), .. } if value == &text => Some(bounds[0]), _ => None, }) .collect(); assert_eq!(widths, [400.0, 300.0]); let heights: Vec<_> = resized .frame .commands .iter() .filter_map(|command| match command { RenderCommand::Text { value, wrap_bounds: Some(bounds), .. } if value == &text => Some(bounds[1]), _ => None, }) .collect(); assert!(heights[0] < commands[0][1]); let direct = session .execute( "paragraph.measure(paragraph.mounts().at(0),Constraints(0,0,80,2000)).height", "app.main", ) .unwrap() .value .parse::() .unwrap(); assert!(direct > heights[0]); session .execute("paragraph.setText(\"short\")", "app.main") .unwrap(); assert_eq!( session .execute("paragraph.mounts().count", "app.main") .unwrap() .value, "2" ); assert_eq!( session .execute("paragraph.mounts().at(0).bounds().height", "app.main") .unwrap() .value, "20" ); } } #[test] /// 加载回调签名示例,逐项尝试不匹配的事件/绑定/任务回调及参数个数。 /// 注册期错误不能使会话 fault;合法零参数与 Event 参数回调均可执行,最后检查底层方法实际 arity。 fn native_signatures_validate_registration_and_deliver_the_event_argument() { let (mut session, _) = ReplSession::load( include_str!("../../../examples/native-signatures.endor"), "app.main", 1, 220, ) .unwrap(); for invalid in [ r#"withEvent.on("click", ui.textOf)"#, r#"withEvent.on("click", Page)"#, r#"label.bind("text", received.set)"#, r#"ui.after(ui,"bad",60000,received.set)"#, "count.increment(1)", ] { assert!(session.execute(invalid, "app.main").is_err(), "{invalid}"); assert!( session.documents[&crate::window::MAIN_WINDOW] .frame .fault .is_none() ); } let document = session .execute("withEvent.click()", "app.main") .unwrap() .document .unwrap(); assert!( document.frame.commands.iter().any( |command| matches!(command, RenderCommand::Text { value, .. } if value == "click") ) ); assert_eq!( session .execute("received.value.kind", "app.main") .unwrap() .value, r#""click""# ); session.execute("withoutEvent.click()", "app.main").unwrap(); assert_eq!( session.execute("count.value", "app.main").unwrap().value, "1" ); assert!(session.poll_tasks().unwrap().is_none()); let globals = session.candidate.globals.unwrap(); let Value::Object(received) = session .candidate .vm .dict_get(globals, &Value::Text("received".into())) .unwrap() .unwrap() else { panic!("state") }; let Value::Object(set) = session.candidate.vm.get_attr(received, "set").unwrap() else { panic!("set") }; assert_eq!( session.candidate.vm.call_arity(set).unwrap(), Some(endor_core::CallArity::exact(1)) ); } #[test] /// 尝试错误字段赋值与构造,检查声明字段契约在原生分配副作用之前验证。 /// 已有值和窗口页面数量必须保持不变,随后合法点击仍能递增并发布文字。 fn checked_fields_reject_native_constructor_side_effects_and_preserve_live_values() { let (mut session, _) = ReplSession::load( include_str!("../../../examples/field-contracts.endor"), "app.main", 1, 210, ) .unwrap(); for invalid in [ r#"counter.value = "wrong""#, r#"CounterText("bad", "wrong")"#, "Model(42)", ] { let error = session.execute(invalid, "app.main").err().unwrap(); assert!(error.to_string().contains("field"), "{error:#}"); assert!( session.documents[&crate::window::MAIN_WINDOW] .frame .fault .is_none() ); } assert_eq!( session.execute("counter.value", "app.main").unwrap().value, "9" ); session .execute("class CheckedPage: Page { count: Number }", "app.main") .unwrap(); let pages = session .execute("ui.window().pages().count", "app.main") .unwrap() .value; assert!( session .execute(r#"CheckedPage("wrong")"#, "app.main") .is_err() ); assert_eq!( session .execute("ui.window().pages().count", "app.main") .unwrap() .value, pages ); let updated = session .execute("button.click()", "app.main") .unwrap() .document .unwrap(); assert!( updated .frame .commands .iter() .any(|command| matches!(command, RenderCommand::Text { value, .. } if value == "10")) ); assert_eq!( session.execute("counter.value", "app.main").unwrap().value, "10" ); } #[test] /// 把 Numeric 视觉引用替换为 Textual,旧 alias 随共享转发指向新对象。 /// 字段检查必须按新类型执行;合法字符串赋值通过,数字写入和返回错误类型的绑定均被拒绝。 fn checked_fields_follow_shared_block_forwarding_and_binding_writes() { let (mut session, _) = ReplSession::load( r#" class Numeric: TextBlock { value: Number } class Textual: TextBlock { value: String } block = Numeric("old", 9) alias = block page = Page() page.render(block) "#, "app.main", 1, 211, ) .unwrap(); session .execute(r#"block = Textual("new", "kept")"#, "app.main") .unwrap(); assert!(session.execute("alias.value = 42", "app.main").is_err()); assert_eq!( session.execute("alias.value", "app.main").unwrap().value, r#""kept""# ); session .execute(r#"alias.value = "updated""#, "app.main") .unwrap(); assert_eq!( session.execute("block.value", "app.main").unwrap().value, r#""updated""# ); assert!( session .execute("alias.bind(\"value\", ui.viewport)", "app.main") .is_err() ); } #[test] /// 在容器中间插入子项,检查新稳定槽、后继 y 变化及旧 Mount 身份保留。 /// 越界、负位置和自包含循环在修改前失败;移除新槽后旧出现位置仍有效。 fn positional_insert_preserves_existing_slots_and_mounts_and_rejects_invalid_graphs() { let source = r#"head=TextBlock("head") tail=TextBlock("tail") list=Column(24,8,head,tail) page=Page() page.render(list)"#; let (mut session, initial) = ReplSession::load(source, "app.main", 1, 200).unwrap(); session .execute("held=tail.mounts().at(0)", "app.main") .unwrap(); let id = session .execute("held.id", "app.main") .unwrap() .value .parse::() .unwrap(); let old = initial .frame .mounts .iter() .find(|mount| mount.id == id) .unwrap(); let inserted = session .execute("slot=list.insert(1,TextBlock(\"middle\"))", "app.main") .unwrap(); assert_eq!(inserted.value, "2"); let document = inserted.document.unwrap(); let new = document .frame .mounts .iter() .find(|mount| mount.id == id) .unwrap(); assert!(new.y > old.y); assert_eq!( session .execute("tail.mounts().at(0).id", "app.main") .unwrap() .value, id.to_string() ); for invalid in [ "list.insert(4,head)", "list.insert(0,list)", "list.insert(-1,head)", ] { assert!(session.execute(invalid, "app.main").is_err()); assert!(!session.is_faulted()); } assert_eq!( session.execute("held.mounted", "app.main").unwrap().value, "true" ); session.execute("list.remove(slot)", "app.main").unwrap(); assert_eq!( session .execute("tail.mounts().at(0).id", "app.main") .unwrap() .value, id.to_string() ); } #[test] /// 先同窗重排再跨窗移动,确认调用 Page 源覆盖且保留 Page 业务身份。 /// 跨窗目标帧版本不匹配必须拒绝;合法迁移后旧 Mount 失效,新窗口页面表指向原 Page。 fn tab_drop_preserves_page_identity_calls_source_methods_and_rejects_stale_targets() { let (mut session, initial) = ReplSession::load( include_str!("../../../examples/tab-placement.endor"), "app.main", 1, 201, ) .unwrap(); session.take_window_commands().unwrap(); let page = initial.frame.tabs[0].id; let input = crate::events::Input { window: 1, session: 201, layout_version: initial.frame.layout_version, mount: page, kind: "tab-drop".into(), point: None, press_point: None, delta: None, screen_position: None, tab_drop: Some(crate::events::TabDrop { window: 1, layout_version: initial.frame.layout_version, index: 3, }), }; session .execute("held=list.mounts().at(0)", "app.main") .unwrap(); let mount = session.execute("held.id", "app.main").unwrap().value; session.dispatch(&input).unwrap(); assert_eq!( session.execute("calls.value", "app.main").unwrap().value, "1" ); assert_eq!( session .execute("list.mounts().at(0).id", "app.main") .unwrap() .value, mount ); assert_eq!( session .execute("ui.window().pages().at(2)", "app.main") .unwrap() .value, session.execute("first", "app.main").unwrap().value ); let input = crate::events::Input { layout_version: session.documents[&1].frame.layout_version, tab_drop: Some(crate::events::TabDrop { window: 2, layout_version: session.documents[&2].frame.layout_version, index: 0, }), ..input }; let mut stale = input.clone(); stale.tab_drop.as_mut().unwrap().layout_version += 1; assert!(!session.accepts_tab_drop(&stale)); assert!(session.dispatch(&stale).is_err()); assert!(!session.is_faulted()); session.dispatch(&input).unwrap(); assert_eq!( session.execute("calls.value", "app.main").unwrap().value, "3" ); assert_eq!( session .execute("first.window().id()", "app.main") .unwrap() .value, "2" ); assert_eq!( session .execute("other.pages().at(0)", "app.main") .unwrap() .value, session.execute("first", "app.main").unwrap().value ); assert_eq!( session.execute("held.mounted", "app.main").unwrap().value, "false" ); } #[test] /// Page.moveToWindow 覆盖只返回 self,模拟源程序拒绝跨窗移动。 /// 拖放不能强行改变窗口归属;随后 detach 使用独立入口,并排出带负桌面坐标的原生命令。 fn drop_respects_declined_source_moves_and_detach_queues_signed_desktop_position() { let source = r#"class Declining: Page { calls: Object function moveToWindow(self: Declining, window: Window): Page { self.calls.increment() return self } } calls=ui.state(0) page=Declining(calls) page.render(TextBlock("source")) other=Window() target=Page() target.render(TextBlock("target")) target.open(other)"#; let (mut session, initial) = ReplSession::load(source, "app.main", 1, 202).unwrap(); session.take_window_commands().unwrap(); let mut input = crate::events::Input { window: 1, session: 202, layout_version: initial.frame.layout_version, mount: initial.frame.tabs[0].id, kind: "tab-drop".into(), point: None, press_point: None, delta: None, screen_position: None, tab_drop: Some(crate::events::TabDrop { window: 2, layout_version: initial.windows[&2].frame.layout_version, index: 0, }), }; session.dispatch(&input).unwrap(); assert_eq!( session.execute("calls.value", "app.main").unwrap().value, "1" ); assert_eq!( session .execute("page.window().id()", "app.main") .unwrap() .value, "1" ); assert_eq!( session .execute("other.pages().count", "app.main") .unwrap() .value, "1" ); input.kind = "tab-detach".into(); input.tab_drop = None; input.screen_position = Some([-400, 120]); input.layout_version = session.documents[&1].frame.layout_version; session.dispatch(&input).unwrap(); let commands = session.take_window_commands().unwrap(); assert!(commands.iter().any(|command| command.window == 3 && command.action == crate::window::Action::MoveTo { x: -400, y: 120 })); assert_eq!( session .execute("page.window().id()", "app.main") .unwrap() .value, "3" ); } /// 为异步文件测试写入唯一临时 UTF-8 文件,再把路径交给闭包。 /// 进程号加原子序号防止并发冲突,Cleanup 析构保证断言 panic 时也尝试删除文件。 fn with_file_task_input(contents: &str, run: impl FnOnce(&std::path::Path)) { // 只需唯一递增值,不依赖它同步其他内存,Relaxed 足以保证不同测试取到不同序号。 static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0); let id = NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed); let path = std::env::temp_dir().join(format!("tessera-text-task-{}-{id}.txt", std::process::id())); // 将文件删除绑定到栈生命周期,避免测试提前失败时留下临时文件。 struct Cleanup(std::path::PathBuf); impl Drop for Cleanup { // 清理失败不再次 panic,避免覆盖原测试故障或在异常展开时二次崩溃。 fn drop(&mut self) { let _ = std::fs::remove_file(&self.0); } } let _cleanup = Cleanup(path.clone()); std::fs::write(&path, contents).unwrap(); run(&path); } /// 生成 Loader 测试程序:readText 成功回调把 Task.result 写入未挂载的 target。 /// 路径先按 JSON 字符串转义再插入 Endor,tail 用于附加替换/取消等测试操作。 fn file_task_source(path: &std::path::Path, tail: &str) -> String { let path = serde_json::to_string(&path.to_string_lossy()).unwrap(); format!( "class Loader {{\n target: TextBlock\n task: Object\n function apply(self: Loader): Unit {{ self.target.text = self.task.result() }}\n}}\ntarget = TextBlock(\"waiting\")\nloader = Loader(target,ui.state(0))\npage = Page()\npage.render(TextBlock(\"target stays hidden\"))\nloader.task = ui.readText(loader,\"read\",{path},loader.apply)\n{tail}" ) } /// 直接从当前 VM globals 找到 loader.task,按托管类型的方法表调用 status。 /// 不通过 REPL execute 查询,避免状态观察自身引入一次输入、刷新或任务调度副作用。 fn file_task_state(session: &mut ReplSession) -> String { let globals = session.candidate.globals.unwrap(); let Value::Object(loader) = session .candidate .vm .dict_get(globals, &Value::Text("loader".into())) .unwrap() .unwrap() else { panic!("loader"); }; let Value::Object(task) = session.candidate.vm.get_attr(loader, "task").unwrap() else { panic!("Task"); }; let definition = session .candidate .vm .object_store() .type_of(task) .unwrap() .unwrap(); let method = session .candidate .vm .object_store() .lookup_method(definition, "status") .unwrap() .unwrap(); let Value::Text(status) = session .candidate .vm .call(method, &[Value::Object(task)]) .unwrap() else { panic!("status"); }; status } /// 最多轮询 1000 次,每轮推进任务并检查其是否离开 pending。 /// 短暂休眠让后台文件线程获得执行机会;取消/失败也算终态,超时则明确使测试失败。 fn complete_file_task(session: &mut ReplSession) { for _ in 0..1000 { session.poll_tasks().unwrap(); if file_task_state(session) != "pending" { return; } std::thread::sleep(std::time::Duration::from_millis(1)); } panic!("file task did not complete"); } #[test] /// 同一 owner/key 连续发起两个不同文件读取,第二个必须取消旧任务。 /// 推进完成后仅新 UTF-8 内容写入 target;target 仍无 Mount,说明业务更新不依赖可见性。 fn file_task_updates_hidden_object_and_replacement_drops_old_delivery() { with_file_task_input("old", |old| { with_file_task_input("new UTF-8 文本", |new| { let path = serde_json::to_string(&new.to_string_lossy()).unwrap(); let tail = format!( "old = loader.task\nloader.task = ui.readText(loader,\"read\",{path},loader.apply)" ); let (mut session, _) = ReplSession::load(&file_task_source(old, &tail), "app.main", 282, 1).unwrap(); complete_file_task(&mut session); assert_eq!(file_task_state(&mut session), "completed"); assert_eq!( session.execute("target.text", "app.main").unwrap().value, "\"new UTF-8 文本\"" ); assert_eq!( session.execute("old.status()", "app.main").unwrap().value, "\"cancelled\"" ); assert_eq!( session .execute("target.mounts().count", "app.main") .unwrap() .value, "0" ); }) }); } #[test] /// 分别覆盖显式取消和 provider 读取不存在文件失败。 /// 二者都不能运行成功回调;后者需保留错误文本但不使共享 VM fault,目标文字仍为 waiting。 fn cancelled_file_task_never_runs_callback_and_missing_file_keeps_vm_live() { with_file_task_input("ignored", |path| { let (mut cancelled, _) = ReplSession::load( &file_task_source(path, "loader.task.cancel()"), "app.main", 283, 1, ) .unwrap(); complete_file_task(&mut cancelled); assert_eq!(file_task_state(&mut cancelled), "cancelled"); assert_eq!( cancelled.execute("target.text", "app.main").unwrap().value, "\"waiting\"" ); let missing = path.with_extension("missing"); let (mut failed, _) = ReplSession::load(&file_task_source(&missing, ""), "app.main", 284, 1).unwrap(); complete_file_task(&mut failed); assert_eq!(file_task_state(&mut failed), "failed"); assert!(!failed.is_faulted()); assert_ne!( failed .execute("loader.task.error()", "app.main") .unwrap() .value, "\"\"" ); assert_eq!( failed.execute("target.text", "app.main").unwrap().value, "\"waiting\"" ); }); } #[test] /// 创建不带回调的 readText,完成后直接读取任务结果。 /// 确认 result 的托管保留不依赖成功回调,且 error 为空字符串。 fn callback_free_file_task_retains_result_after_completion() { with_file_task_input("callback free", |path| { let path = serde_json::to_string(&path.to_string_lossy()).unwrap(); let source = format!( "class Holder {{ task: Object }}\nloader = Holder(ui.state(0))\npage = Page()\npage.render(TextBlock(\"file\"))\nloader.task = ui.readText(ui,\"read\",{path})" ); let (mut session, _) = ReplSession::load(&source, "app.main", 285, 1).unwrap(); complete_file_task(&mut session); assert_eq!(file_task_state(&mut session), "completed"); assert_eq!( session .execute("loader.task.result()", "app.main") .unwrap() .value, "\"callback free\"" ); assert_eq!( session .execute("loader.task.error()", "app.main") .unwrap() .value, "\"\"" ); }); } #[test] /// 以隐藏 Block 为 owner,用相同 key 替换定时任务。 /// 旧任务立即取消,新回调仅在 poll 后写入 2;另一个被显式取消的任务不能再改变状态。 fn owned_tasks_replace_cancel_and_update_unmounted_objects() { let source = r#"class Action { state: Object value: Number function apply(self: Action): Unit { self.state.value = self.value } } state = ui.state(0) hidden = TextBlock("not mounted") first = Action(state, 1) latest = Action(state, 2) page = Page() page.render(ui.textOf(state,"value")) old = ui.after(hidden,"load",0,first.apply) next = ui.after(hidden,"load",0,latest.apply)"#; let (mut session, _) = ReplSession::load(source, "app.main", 1, 190).unwrap(); assert_eq!( session.execute("old.status()", "app.main").unwrap().value, "\"cancelled\"" ); assert_eq!( session.execute("state.value", "app.main").unwrap().value, "0" ); assert!(session.poll_tasks().unwrap().is_some()); assert_eq!( session.execute("state.value", "app.main").unwrap().value, "2" ); assert_eq!( session.execute("next.status()", "app.main").unwrap().value, "\"completed\"" ); session .execute( "cancelled=ui.after(ui,\"cancel\",0,first.apply)\ncancelled.cancel()", "app.main", ) .unwrap(); session.poll_tasks().unwrap(); assert_eq!( session.execute("state.value", "app.main").unwrap().value, "2" ); assert_eq!( session .execute("cancelled.active()", "app.main") .unwrap() .value, "false" ); } #[test] /// 并列创建 Page/Mount/Block/ui 作用域任务,再关闭并重开页面。 /// 页面与出现位置任务取消,业务对象和应用任务继续;跨窗迁移保留 Page 作用域但取消旧 Mount,关窗取消窗口任务。 fn tab_and_mount_tasks_cancel_while_block_and_app_owners_continue() { let source = r#"class Action { state: Object function apply(self: Action): Unit { self.state.increment() } } state=ui.state(0) action=Action(state) leaf=TextBlock("owner") page=Page() page.render(leaf)"#; let (mut session, _) = ReplSession::load(source, "app.main", 1, 191).unwrap(); session .execute( r#"held=leaf.mounts().at(0) pageTask=ui.after(page,"page",0,action.apply) mountTask=ui.after(held,"mount",0,action.apply) blockTask=ui.after(leaf,"block",0,action.apply) appTask=ui.after(ui,"app",0,action.apply) page.close() page.open()"#, "app.main", ) .unwrap(); for name in ["pageTask", "mountTask"] { assert_eq!( session .execute(&format!("{name}.status()"), "app.main") .unwrap() .value, "\"cancelled\"" ); } session.poll_tasks().unwrap(); assert_eq!( session.execute("state.value", "app.main").unwrap().value, "2" ); // 跨窗移动保留 Page 自身作用域;原出现位置会被替换,因此旧 Mount 的任务必须取消。 session .execute( r#"moving=ui.after(page,"move",0,action.apply) oldMount=leaf.mounts().at(0) oldMountTask=ui.after(oldMount,"move",0,action.apply) other=page.detachToWindow()"#, "app.main", ) .unwrap(); assert_eq!( session .execute("oldMountTask.status()", "app.main") .unwrap() .value, "\"cancelled\"" ); session.poll_tasks().unwrap(); assert_eq!( session.execute("state.value", "app.main").unwrap().value, "3" ); session .execute( "closing=ui.after(other,\"close\",0,action.apply)\nother.close()", "app.main", ) .unwrap(); session.poll_tasks().unwrap(); assert_eq!( session .execute("closing.status()", "app.main") .unwrap() .value, "\"cancelled\"" ); } #[test] /// 只返回任务令牌而不保留临时 owner,检查弱作用域允许 owner 回收并取消任务。 /// 随后第一个回调失败应停止共享执行域,后续递增不发生;通过 VM 直接读值验证状态仍为 0。 fn orphan_task_scope_is_collectable_and_callback_failure_stops_remaining_work() { let source = r#"class Action { state: Object function apply(self: Action): Unit { self.state.increment() } function fail(self: Action): Unit { ui.window().resize(0,600) } } function orphan(): Task { let owner=TextBlock("temporary") return ui.after(owner,"temporary",0,ui.window().focus) } state=ui.state(0) action=Action(state) page=Page() page.render(TextBlock("preserve")) token=orphan()"#; let (mut session, _) = ReplSession::load(source, "app.main", 1, 192).unwrap(); assert_eq!( session.execute("token.active()", "app.main").unwrap().value, "false" ); session.poll_tasks().unwrap(); assert_eq!( session.execute("token.status()", "app.main").unwrap().value, "\"cancelled\"" ); session.execute("broken=ui.after(ui,\"fail\",0,action.fail)\nlater=ui.after(ui,\"later\",0,action.apply)","app.main").unwrap(); assert!(session.poll_tasks().is_err()); assert!(session.is_faulted()); let globals = session.candidate.globals.unwrap(); let state = match session .candidate .vm .dict_get(globals, &Value::Text("state".into())) .unwrap() .unwrap() { Value::Object(state) => state, _ => panic!("state object"), }; assert_eq!( session.candidate.vm.get_attr(state, "value").unwrap(), Value::Number(0.into()) ); assert!(session.poll_tasks().unwrap().is_none()); assert!(session.execute("42", "app.main").is_err()); } #[test] /// 验证源函数、原生函数和绑定方法属于 Function,而类型构造器不属于 Function。 /// 错误参数在函数体副作用前拒绝,错误返回在返回契约检查时拒绝;重定义同名类也不能改变旧实例/方法身份。 fn source_annotations_classify_functions_and_reject_before_body() { let (mut session, _) = ReplSession::load( include_str!("../../../examples/function-types.endor"), "app.main", 1, 180, ) .unwrap(); for expression in [ "isInstance(identity,Function)", "isInstance(ui.rect,Function)", "isInstance(actions.read,Function)", ] { assert_eq!( session.execute(expression, "app.main").unwrap().value, "true" ); } assert_eq!( session .execute("isInstance(RectBlock,Function)", "app.main") .unwrap() .value, "false" ); session .execute( "function checked(value: Number): Number { state.increment() return value }", "app.main", ) .unwrap(); let error = session .execute("checked(\"wrong\")", "app.main") .err() .unwrap(); assert!( error.to_string().contains("parameter value expects Number"), "{error:#}" ); assert_eq!( session.execute("state.value", "app.main").unwrap().value, "0" ); assert_eq!( session.execute("checked(7)", "app.main").unwrap().value, "7" ); session .execute("function wrong(): Number { return \"wrong\" }", "app.main") .unwrap(); let error = session.execute("wrong()", "app.main").err().unwrap(); assert!( error.to_string().contains("return expects Number"), "{error:#}" ); assert!( session .execute("callNumber(RectBlock)", "app.main") .is_err() ); session .execute( "class Actions { function read(self: Actions): Number { return 9 } }", "app.main", ) .unwrap(); assert_eq!( session .execute("callNumber(savedFunction)", "app.main") .unwrap() .value, "1" ); assert_eq!( session .execute("isInstance(actions,Actions)", "app.main") .unwrap() .value, "false" ); session.execute("button.click()", "app.main").unwrap(); assert_eq!( session.execute("state.value", "app.main").unwrap().value, "2" ); } #[test] /// 先由子窗口按钮回调制造运行时故障,再从宿主回收该窗口。 /// Mount 和页面根必须脱离,onUnmount 的 marker 不可递增;已停止 VM 不能因清理重新执行源代码。 fn stopped_window_teardown_detaches_mounts_without_running_source_hooks() { let source = r#"class WatchedPage: Page { marker: Object function onUnmount(self: WatchedPage, mount: Mount): Unit { self.marker.increment() } } class Failure { function run(self: Failure, event: Event): Unit { ui.window().resize(0,600) } } marker=ui.state(0) mainPage=Page() mainPage.render(TextBlock("main")) other=Window() button=Button("fail") failure=Failure() connection=button.on("click",failure.run) page=WatchedPage(marker) page.render(button) page.open(other)"#; let (mut session, initial) = ReplSession::load(source, "app.main", 1, 140).unwrap(); session .execute("held=button.mounts().at(0)", "app.main") .unwrap(); let globals = session.candidate.globals.unwrap(); let lookup = |session: &ReplSession, name: &str| match session .candidate .vm .dict_get(globals, &Value::Text(name.into())) .unwrap() .unwrap() { Value::Object(object) => object, _ => panic!("object"), }; let held = lookup(&session, "held"); let window = lookup(&session, "other"); let marker = lookup(&session, "marker"); let mount = session .candidate .vm .payload::(held, "Mount") .unwrap() .geometry .id; assert!( session .dispatch(&crate::events::Input { window: 2, session: 140, layout_version: initial.windows[&2].frame.layout_version, mount, kind: "click".into(), point: None, delta: None, press_point: None, tab_drop: None, screen_position: None, }) .is_err() ); assert!(session.is_faulted()); session.retire_window(2).unwrap(); assert!(!session.accepts_window(2)); assert!( !session .candidate .vm .payload::(held, "Mount") .unwrap() .mounted ); assert!( crate::window::pages(session.candidate.vm.object_store(), window) .unwrap() .is_empty() ); assert_eq!( session.candidate.vm.get_attr(marker, "value").unwrap(), Value::Number(0.into()) ); assert!(session.execute("42", "app.main").is_err()); } #[test] /// 加载多窗口示例,确认窗口共享业务计数但使用不重叠的 Mount。 /// 迁移保留 Page 身份、替换旧 Mount;关闭并清除全局引用后 Window 可回收,保留旧叶 Mount 也不能留住窗口上下文。 fn native_windows_share_business_state_move_pages_and_release_closed_contexts() { let (mut session, initial) = ReplSession::load( include_str!("../../../examples/windows.endor"), "app.main", 1, 130, ) .unwrap(); assert_eq!(initial.windows.len(), 1); let main_ids: std::collections::BTreeSet<_> = initial.frame.mounts.iter().map(|mount| mount.id).collect(); assert!( initial.windows[&2] .frame .mounts .iter() .all(|mount| !main_ids.contains(&mount.id)) ); assert_eq!(initial.windows[&2].frame.session, initial.frame.session); let changed = session .execute("count.increment()", "app.main") .unwrap() .document .unwrap(); let has_one = |frame: &crate::document::Frame| { frame .commands .iter() .any(|command| matches!(command,RenderCommand::Text{value,..} if value=="1")) }; assert!(has_one(&changed.frame) && has_one(&changed.windows[&2].frame)); session .execute("oldRight = rightButton.mounts().at(0)", "app.main") .unwrap(); let page = session.execute("right", "app.main").unwrap().value; let moved = session .execute("right.moveToWindow(ui.window())", "app.main") .unwrap() .document .unwrap(); assert!(moved.windows[&2].frame.tabs.is_empty()); assert_eq!(session.execute("right", "app.main").unwrap().value, page); assert_eq!( session .execute("right.window().id()", "app.main") .unwrap() .value, "1" ); assert!(session.execute("oldRight.bounds()", "app.main").is_err()); let globals = session.candidate.globals.unwrap(); let Value::Object(window) = session .candidate .vm .dict_get(globals, &Value::Text("other".into())) .unwrap() .unwrap() else { panic!("Window"); }; let weak = session.candidate.vm.downgrade(window).unwrap(); let closed = session .execute("other.close()", "app.main") .unwrap() .document .unwrap(); assert!(closed.windows.is_empty()); assert!(session.execute("right.open(other)", "app.main").is_err()); session .candidate .vm .dict_delete(globals, &Value::Text("other".into())) .unwrap(); session.execute("0", "app.main").unwrap(); session.candidate.vm.collect_cycles(); assert!(session.candidate.vm.upgrade(weak).unwrap().is_none()); // 外部仍持有旧叶 Mount 时,关闭窗口的上下文也必须可释放;下一次 detach 创建新的资源编号。 let detached = session .execute("detached = right.detachToWindow()", "app.main") .unwrap() .document .unwrap(); assert!(detached.windows.contains_key(&3)); session.execute("detached.close()", "app.main").unwrap(); assert_eq!( session.execute("right.window()", "app.main").unwrap().value, "nil" ); assert_eq!( session.execute("count.value", "app.main").unwrap().value, "1" ); session .execute("right.open(ui.window())", "app.main") .unwrap(); assert_eq!(session.execute("right", "app.main").unwrap().value, page); } #[test] /// 一次输入先关闭子窗口,再用非法 resize 使后续语句失败。 /// 先前关闭副作用仍存在,下一次成功输入必须清除残留展示;Page 可重新打开到主窗口。 fn failed_input_after_window_close_cannot_leave_owned_mounts_in_closed_context() { let (mut session, _) = ReplSession::load( include_str!("../../../examples/windows.endor"), "app.main", 1, 131, ) .unwrap(); assert!( session .execute("other.close()\nui.window().resize(0,600)", "app.main") .is_err() ); assert!(!session.accepts_window(2)); let repaired = session.execute("right.window()", "app.main").unwrap(); assert_eq!(repaired.value, "nil"); assert!(repaired.document.unwrap().windows.is_empty()); assert_eq!( session .execute("right.mounts().count", "app.main") .unwrap() .value, "0" ); session .execute("right.open(ui.window())", "app.main") .unwrap(); assert_eq!( session .execute("right.window().id()", "app.main") .unwrap() .value, "1" ); } #[test] /// 依次通过事件激活页面、修改 title、关闭页面、清空及重开。 /// 检查标签反映真实 Page 方法,稳定业务 ID 与递增展示 ID 各自正确,旧版本事件被桥接层拒绝。 fn tab_projection_uses_page_methods_and_rejects_old_presentations() { let source = r#"first = Page() first.title = "First" first.render(TextBlock("one")) second = Page() second.title = "Second" second.render(TextBlock("two"))"#; let (mut session, initial) = ReplSession::load(source, "app.main", 120, 1).unwrap(); assert_eq!(initial.frame.tabs.len(), 2); assert_eq!(initial.frame.tabs[0].title, "First"); assert!(initial.frame.tabs[1].active); let input = crate::events::Input { window: crate::window::MAIN_WINDOW, session: initial.frame.session, layout_version: initial.frame.layout_version, mount: initial.frame.tabs[0].id, kind: "tab-activate".into(), point: None, delta: None, press_point: None, tab_drop: None, screen_position: None, }; let selected = session.dispatch(&input).unwrap().document.unwrap(); assert!(selected.frame.tabs[0].active); assert!(selected.frame.layout_version > initial.frame.layout_version); // 直接检查桥接层的版本拒绝:过期传输在进入源回调之前失败,不应被当成运行时故障。 assert!( session .bridge .dispatch(&mut session.candidate.vm, &input) .is_err() ); let renamed = session .execute(r#"second.title = "Renamed""#, "app.main") .unwrap() .document .unwrap(); assert_eq!(renamed.frame.tabs[1].title, "Renamed"); assert_eq!(renamed.frame.tabs[0].id, initial.frame.tabs[0].id); let closed = session .dispatch(&crate::events::Input { window: crate::window::MAIN_WINDOW, session: renamed.frame.session, layout_version: renamed.frame.layout_version, mount: renamed.frame.tabs[1].id, kind: "tab-close".into(), point: None, delta: None, press_point: None, tab_drop: None, screen_position: None, }) .unwrap() .document .unwrap(); assert_eq!(closed.frame.tabs.len(), 1); assert!(closed.frame.tabs[0].active); assert_eq!( session .execute("second.window()", "app.main") .unwrap() .value, "nil" ); let empty = session .execute("first.close()", "app.main") .unwrap() .document .unwrap(); assert!(empty.frame.tabs.is_empty()); assert!(empty.frame.layout_version > closed.frame.layout_version); let reopened = session .execute("second.open()", "app.main") .unwrap() .document .unwrap(); assert_eq!(reopened.frame.tabs.len(), 1); assert!(reopened.frame.tabs[0].id > initial.frame.tabs[1].id); } #[test] /// 同次成功输入的两次 resize 合并为最后尺寸,并保留 title/focus 命令。 /// 命令只消费一次;失败输入之前积累的 resize 也必须丢弃,不能送到原生窗口。 fn managed_window_requests_are_coalesced_and_failed_input_discards_pending_requests() { let mut session = ReplSession::new(111).unwrap(); session .execute( r#"window = ui.window() window.resize(900,600) window.resize(1000,700) window.setTitle("Endor") window.focus()"#, "app.main", ) .unwrap(); let requests = session.take_window_commands().unwrap(); assert_eq!(requests.len(), 3); assert!(matches!( requests[0].action, crate::window::Action::Resize { width: 1000.0, height: 700.0 } )); assert!(matches!(&requests[1].action,crate::window::Action::SetTitle(title) if title=="Endor")); assert!(session.take_window_commands().unwrap().is_empty()); assert!( session .execute("window.resize(1400,900)\nwindow.resize(0,600)", "app.main") .is_err() ); assert!(session.take_window_commands().unwrap().is_empty()); assert!(session.execute("window.resize(0,600)", "app.main").is_err()); assert!(session.take_window_commands().unwrap().is_empty()); } #[test] /// 检查 Window.pages 真实持有打开页面,close 解除归属,重新 open 追加到当前顺序末尾。 /// 页面窗口关系保持双向一致,向非 Window 对象打开则明确失败。 fn window_page_roots_follow_open_close_and_creation_order() { let source = r#"first = Page() second = Page() first.render(TextBlock("first")) second.render(TextBlock("second")) window = ui.window()"#; let (mut session, _) = ReplSession::load(source, "app.main", 112, 1).unwrap(); assert_eq!( session .execute("window.pages().count", "app.main") .unwrap() .value, "2" ); let first = session.execute("first.window()", "app.main").unwrap().value; assert_eq!( first, session .execute("second.window()", "app.main") .unwrap() .value ); session.execute("first.close()", "app.main").unwrap(); assert_eq!( session.execute("first.window()", "app.main").unwrap().value, "nil" ); assert_eq!( session .execute("window.pages().count", "app.main") .unwrap() .value, "1" ); session.execute("first.open(window)", "app.main").unwrap(); assert_eq!( session .execute("window.pages().count", "app.main") .unwrap() .value, "2" ); assert_eq!( session .execute("window.pages().at(0)", "app.main") .unwrap() .value, session.execute("second", "app.main").unwrap().value ); assert!(session.execute("first.open(Object())", "app.main").is_err()); } #[test] /// 为 Page 建立弱句柄,close 后删除唯一全局绑定并运行循环回收。 /// 弱升级应失败,证明窗口的页面顺序记录不会把已关闭页面意外作为强根保留。 fn closed_page_is_not_kept_alive_by_window_page_order() { let (mut session, _) = ReplSession::load( "page = Page()\npage.render(TextBlock(\"page\"))", "app.main", 113, 1, ) .unwrap(); let globals = session.candidate.globals.unwrap(); let Value::Object(page) = session .candidate .vm .dict_get(globals, &Value::Text("page".into())) .unwrap() .unwrap() else { panic!("Page") }; let weak = session.candidate.vm.downgrade(page).unwrap(); session.execute("page.close()", "app.main").unwrap(); session .candidate .vm .dict_delete(globals, &Value::Text("page".into())) .unwrap(); session.candidate.vm.collect_cycles(); assert!(session.candidate.vm.upgrade(weak).unwrap().is_none()); } #[test] /// 源 measure 内尝试 resize 原生窗口,加载应报告 read-only。 /// 窗口命令也属于副作用,不能因其延后执行而绕过布局只读保护。 fn rendering_cannot_enqueue_native_window_side_effects() { let source = r##"class BadRect: RectBlock { function measure(self: BadRect, mount: Mount, constraints: Constraints): MeasureResult { ui.window().resize(900,600) return MeasureResult(80,20) } } page = Page() page.render(BadRect(80,20,0,"#DDEEFF"))"##; let error = ReplSession::load(source, "app.main", 114, 1).err().unwrap(); assert!(error.to_string().contains("read-only")); } /// 直接调用 ui.stats 取得某个数字计数,读取后释放返回的 stats 托管对象。 /// 辅助函数避免经 REPL 查询统计带来额外输入/刷新,使缓存命中与测量次数的断言可比较。 fn source_measure_stat(session: &mut ReplSession, name: &str) -> i64 { let Value::Object(function) = session .candidate .vm .get_attr(session.bridge.ui, "stats") .unwrap() else { panic!("stats function") }; let Value::Object(stats) = session.candidate.vm.call(function, &[]).unwrap() else { panic!("stats") }; let Value::Number(value) = session.candidate.vm.get_attr(stats, name).unwrap() else { panic!("stat number") }; session.candidate.vm.release(stats).unwrap(); value.as_i64().unwrap() } /// 从 globals 中按名称找到业务 Block,再在给定完整文档中按 block_id 找对应 Mount。 /// 构造携带当前会话与该文档版本的 click,返回派发后发布的新文档,供后续动作沿新版本继续。 fn click_named(session: &mut ReplSession, document: &RenderDocument, name: &str) -> RenderDocument { let globals = session.candidate.globals.unwrap(); let Value::Object(block) = session .candidate .vm .dict_get(globals, &Value::Text(name.into())) .unwrap() .unwrap() else { panic!("Block") }; let mount = document .frame .mounts .iter() .find(|mount| mount.block_id == block.to_string()) .unwrap(); session .dispatch(&crate::events::Input { window: crate::window::MAIN_WINDOW, session: session.id, layout_version: document.frame.layout_version, mount: mount.id, kind: "click".into(), point: None, delta: None, press_point: None, tab_drop: None, screen_position: None, }) .unwrap() .document .unwrap() } #[test] /// 同一个源 paint 对象出现在两个窗口,先执行与显示无关的表达式。 /// 无关输入应不产生文档;修改 paint 实际读取的 tint 后,两个窗口都必须发布新颜色。 fn shared_intrinsic_desktop_does_not_repaint_other_windows_on_repl_input() { let (mut session, _) = ReplSession::load( r##" class Painted: RectBlock { tint: String function paint(self: Painted, mount: Mount, geometry: Bounds): DisplayList { drawing = RectBlock.paint(self,mount,geometry) drawing.commands.at(0).color = self.tint return drawing } } item = Painted(80,20,0,"#DDEEFF","#ED6A5A") page = Page() page.render(item) window2 = Window() page2 = Page() page2.render(item) page2.moveToWindow(window2) "##, "app.main", 901, 1, ) .unwrap(); assert!( session .execute("42", "app.main") .unwrap() .document .is_none() ); let changed = session .execute("item.tint = \"#3868D9\"", "app.main") .unwrap() .document .unwrap(); assert!(changed.frame.commands.iter().any(|command| matches!( command, RenderCommand::RoundedRect { color, .. } if color == "#3868D9" ))); assert!( changed.windows[&2] .frame .commands .iter() .any(|command| matches!( command, RenderCommand::RoundedRect { color, .. } if color == "#3868D9" )) ); } #[test] /// 加载缓存示例并用真实 click 分别改变颜色与尺寸。 /// 纯颜色更新复用全部测量,尺寸依赖变化只让受影响的结果失效;按布局 pass 数核对命中而非写死单次计数。 fn source_measure_cache_reuses_independent_results_and_invalidates_model_changes() { let (mut session, initial) = ReplSession::load_with_viewport( include_str!("../../../examples/layout-cache.endor"), "app.main", 101, 1, Some(crate::layout::Size { width: 800.0, height: 600.0, }), ) .unwrap(); assert_eq!(source_measure_stat(&mut session, "sourceMeasureMisses"), 2); let painted = click_named(&mut session, &initial, "blue"); assert!(painted.frame.commands.iter().any( |command| matches!(command,RenderCommand::RoundedRect {color,..} if color=="#526AC7") )); let passes = source_measure_stat(&mut session, "layoutPasses"); assert_eq!( source_measure_stat(&mut session, "sourceMeasureHits"), 2 * passes ); assert_eq!(source_measure_stat(&mut session, "measured"), 0); let resized = click_named(&mut session, &painted, "expand"); assert!( resized .frame .mounts .iter() .any(|mount| mount.width == 260.0 && mount.height == 60.0) ); let passes = source_measure_stat(&mut session, "layoutPasses"); assert_eq!( source_measure_stat(&mut session, "sourceMeasureHits"), 2 * passes - 1 ); assert_eq!(source_measure_stat(&mut session, "sourceMeasureMisses"), 1); } #[test] /// 新建尚未 render 的 Console VM,执行普通表达式和 resize。 /// 两者都不应产生发布文档,避免把 reset 后保留的画面替换成空白。 fn viewport_updates_in_a_fresh_console_do_not_replace_the_preserved_page() { let mut session = ReplSession::new_with_viewport( 104, Some(crate::layout::Size { width: 800.0, height: 600.0, }), ) .unwrap(); assert!( session .execute("42", "app.main") .unwrap() .document .is_none() ); assert!( session .resize(Some(crate::layout::Size { width: 360.0, height: 240.0 })) .unwrap() .is_none() ); let result = session.execute("ui.viewport().width", "app.main").unwrap(); assert_eq!(result.value, "360"); assert!(result.document.is_none()); } #[test] /// 源 measure 返回先前已创建的 MeasureResult,不在调用期间新建结果。 /// 直接改其 width 后刷新必须失效并更新相同 Mount,证明返回值解码读取也进入依赖;再次刷新保持稳定。 fn source_measure_cache_tracks_fields_of_an_existing_returned_result() { let source = r##"class HeldRect: RectBlock { result: MeasureResult function measure(self: HeldRect, mount: Mount, constraints: Constraints): MeasureResult { return self.result } } result = MeasureResult(80,20) rect = HeldRect(80,20,0,"#DDEEFF",result) page = Page() page.render(rect)"##; let (mut session, initial) = ReplSession::load(source, "app.main", 103, 1).unwrap(); let id = initial .frame .mounts .iter() .find(|mount| mount.width == 80.0) .unwrap() .id; let globals = session.candidate.globals.unwrap(); let Value::Object(result) = session .candidate .vm .dict_get(globals, &Value::Text("result".into())) .unwrap() .unwrap() else { panic!("result") }; session .candidate .vm .set_attr(result, "width", Value::Number(140.into())) .unwrap(); let next = session.refresh_document().unwrap().unwrap(); assert!( next.frame .mounts .iter() .any(|mount| mount.id == id && mount.width == 140.0) ); assert_eq!(source_measure_stat(&mut session, "sourceMeasureMisses"), 1); assert!(session.refresh_document().unwrap().is_none()); } #[test] /// 在有限窗口约束下加载缓存示例,再缩窄真实可用视口。 /// 原 Mount ID 不变,内容宽度按根 padding 改变,且输入计数仍为 0;重复尺寸不发布,NaN 尺寸失败但不停止 VM。 fn viewport_resize_changes_constraints_and_preserves_mount_identity_without_source_input() { let (mut session, initial) = ReplSession::load_with_viewport( include_str!("../../../examples/layout-cache.endor"), "app.main", 102, 1, Some(crate::layout::Size { width: 800.0, height: 600.0, }), ) .unwrap(); // viewport 已是实际页面可用区域,初始与 resize 后都只扣 Endor 根左右各 24px 的 padding。 assert!( initial .frame .mounts .iter() .any(|mount| mount.width == 752.0 && mount.height == 24.0) ); let ids: Vec<_> = initial.frame.mounts.iter().map(|mount| mount.id).collect(); let document = session .resize(Some(crate::layout::Size { width: 360.0, height: 240.0, })) .unwrap() .unwrap(); assert_eq!( ids, document .frame .mounts .iter() .map(|mount| mount.id) .collect::>() ); assert!( document .frame .mounts .iter() .any(|mount| mount.width == 312.0 && mount.height == 24.0) ); assert_eq!(session.inputs, 0); assert!( session .resize(Some(crate::layout::Size { width: 360.0, height: 240.0 })) .unwrap() .is_none() ); assert!( session .resize(Some(crate::layout::Size { width: f32::NAN, height: 240.0 })) .is_err() ); assert!(!session.is_faulted()); } const SOURCE_LAYOUT: &str = include_str!("../../../examples/source-layout.endor"); #[test] /// 检查首次 source measure/arrange 已可读取结构关系与子测量结果,产出预期位置。 /// 直接改 Metrics.width 后通过依赖刷新同一 Mount,随后无变化刷新不再发布。 fn source_layout_uses_initial_mount_links_child_measurements_and_model_dependencies() { let (mut session, initial) = ReplSession::load(SOURCE_LAYOUT, "app.main", 91, 1).unwrap(); let rect = initial .frame .mounts .iter() .find(|mount| mount.width == 200.0 && mount.height == 60.0) .unwrap(); assert_eq!((rect.x, rect.y), (44.0, 24.0)); let id = rect.id; assert!(initial.frame.commands.iter().any(|command| matches!(command,RenderCommand::Text { value,y,.. } if value.starts_with("尺寸来自") && *y == 100.0))); let globals = session.candidate.globals.unwrap(); let Value::Object(metrics) = session .candidate .vm .dict_get(globals, &Value::Text("metrics".into())) .unwrap() .unwrap() else { panic!("Metrics") }; session .candidate .vm .set_attr(metrics, "width", Value::Number(260.into())) .unwrap(); let next = session.refresh_document().unwrap().unwrap(); let rect = next .frame .mounts .iter() .find(|mount| mount.id == id) .unwrap(); assert_eq!((rect.x, rect.width), (44.0, 260.0)); assert!(session.refresh_document().unwrap().is_none()); } #[test] /// 把同一 rect 放入具有不同 Metrics 的两个父容器。 /// 发布宽度必须分别为 200/140,不能把共享 Block 的一份测量结果误用于两个出现位置。 fn shared_block_source_measurements_belong_to_each_occurrence() { let source = SOURCE_LAYOUT.replace( "page.render(root)", r#"otherMetrics = Metrics(140, 12) other = OffsetColumn(24, 16, rect, otherMetrics) page.render(Row(0, 0, root, other))"#, ); let (mut session, initial) = ReplSession::load(&source, "app.main", 92, 1).unwrap(); let globals = session.candidate.globals.unwrap(); let Value::Object(rect) = session .candidate .vm .dict_get(globals, &Value::Text("rect".into())) .unwrap() .unwrap() else { panic!("Rect") }; let widths: Vec<_> = initial .frame .mounts .iter() .filter(|mount| mount.block_id == rect.to_string()) .map(|mount| mount.width) .collect(); assert_eq!(widths, vec![200.0, 140.0]); assert!(session.refresh_document().unwrap().is_none()); } #[test] /// measure 读取宽度 80,onMount 随后把该依赖写成 140。 /// 首次发布必须已经重测为 140,不能把回调前的旧几何暴露出去,且后续刷新应稳定。 fn layout_dependencies_changed_by_mount_hook_are_measured_again_before_publication() { let source = r##"class Metrics { width: Number } class InitialRect: RectBlock { metrics: Metrics function measure(self: InitialRect, mount: Mount, constraints: Constraints): MeasureResult { return MeasureResult(self.metrics.width, 20) } function onMount(self: InitialRect, mount: Mount): Unit { self.metrics.width = 140 } } metrics = Metrics(80) rect = InitialRect(80,20,0,"#DDEEFF",metrics) page = Page() page.render(rect)"##; let (mut session, document) = ReplSession::load(source, "app.main", 93, 1).unwrap(); assert!( document .frame .mounts .iter() .any(|mount| mount.width == 140.0 && mount.height == 20.0) ); assert!(session.refresh_document().unwrap().is_none()); } #[test] /// 逐项修改示例,覆盖测量期提前读 bounds、只读范围业务写入、错误返回类型和伪造 child slot。 /// 每个非法程序都要在发布前给出对应诊断,不让不完整或不属于当前容器的排列通过。 fn source_layout_rejects_premature_geometry_writes_wrong_types_and_foreign_slots() { for (before, after, message) in [ ( "return MeasureResult(parent.block.metrics.width, 60)", "return mount.bounds()", "geometry is unavailable during measurement", ), ( "return MeasureResult(parent.block.metrics.width, 60)", "parent.block.metrics.width = 260\nreturn MeasureResult(260,60)", "read-only", ), ( "return MeasureResult(parent.block.metrics.width, 60)", "return Point(0,0)", "measure return expects MeasureResult", ), ( "positions.children.at(0).x = self.metrics.left", "positions.children.at(0).slot = 999999", "foreign child slot", ), ] { let source = SOURCE_LAYOUT.replace(before, after); let error = ReplSession::load(&source, "app.main", 94, 1).err().unwrap(); assert!(error.to_string().contains(message), "{error}"); } } #[test] /// 表驱动检查圆形内点击、圆外但底层可点、按下释放命中不同形状,以及页面外点击。 /// 实际提交仍指向圆 Mount,worker 必须重新按源 hitTest 与 press_point 复核并选择合法目标。 fn source_hit_filters_shape_falls_back_and_requires_matching_press_release() { for (press, release, expected_hits, expected_background) in [ ([64.0, 64.0], [64.0, 64.0], "1", "0"), ([144.0, 64.0], [144.0, 64.0], "0", "1"), ([64.0, 64.0], [144.0, 64.0], "0", "0"), ([9999.0, 9999.0], [9999.0, 9999.0], "0", "0"), ] { let (mut session, initial) = ReplSession::load( include_str!("../../../examples/source-hit.endor"), "app.main", 81, 1, ) .unwrap(); let circle = initial .frame .mounts .iter() .find(|mount| mount.interactive && mount.width == 160.0) .unwrap(); session .dispatch(&crate::events::Input { window: crate::window::MAIN_WINDOW, session: initial.frame.session, layout_version: initial.frame.layout_version, mount: circle.id, kind: "click".into(), point: Some(release), delta: None, press_point: Some(press), tab_drop: None, screen_position: None, }) .unwrap(); assert_eq!( session.execute("hits.value", "app.main").unwrap().value, expected_hits ); assert_eq!( session .execute("background.value", "app.main") .unwrap() .value, expected_background ); } } #[test] /// 把 hitTest 改为返回 Number 或试图递增业务计数。 /// 派发应报告 Bool 契约/只读错误并停止运行时,但业务写入与 click 回调均未发生,hits 保持 0。 fn source_hit_rejects_wrong_result_and_business_writes_before_callbacks() { for (body, message) in [ ("return 1", "hitTest return expects Bool"), ( "self.hits.increment()\nreturn point.inCircle(40, 40, 40)", "read-only", ), ] { let source = include_str!("../../../examples/source-hit.endor") .replace("return point.inCircle(40, 40, 40)", body); let (mut session, initial) = ReplSession::load(&source, "app.main", 82, 1).unwrap(); let circle = initial .frame .mounts .iter() .find(|mount| mount.interactive && mount.width == 160.0) .unwrap(); let error = session .dispatch(&crate::events::Input { window: crate::window::MAIN_WINDOW, session: initial.frame.session, layout_version: initial.frame.layout_version, mount: circle.id, kind: "click".into(), point: Some([64.0, 64.0]), delta: None, press_point: Some([64.0, 64.0]), tab_drop: None, screen_position: None, }) .err() .unwrap(); assert!(error.to_string().contains(message), "{error}"); assert!(session.is_faulted()); let globals = session.candidate.globals.unwrap(); let Value::Object(hits) = session .candidate .vm .dict_get(globals, &Value::Text("hits".into())) .unwrap() .unwrap() else { panic!("state") }; assert_eq!( session.candidate.vm.get_attr(hits, "value").unwrap(), Value::Number(0.into()) ); } } #[test] /// 普通 RectBlock 通过 click 订阅变为可交互;断开令牌后新文档应移除所有交互标记。 /// 检验命中资格依赖实际监听器状态,不只由构造类型决定。 fn ordinary_block_subscription_updates_interactivity_after_disconnect() { let source = r##"hits = ui.state(0) rect = RectBlock(80, 40, 0, "#DDEEFF") token = rect.on("click", hits.increment) page = Page() page.render(rect)"##; let (mut session, initial) = ReplSession::load(source, "app.main", 83, 1).unwrap(); assert!(initial.frame.mounts.iter().any(|mount| mount.interactive)); let result = session.execute("token.disconnect()", "app.main").unwrap(); assert!( result .document .unwrap() .frame .mounts .iter() .all(|mount| !mount.interactive) ); } /// 生成可调规模的源 paint 压力程序:copies 控制共享对象出现次数,locals 控制单次 paint 指令量。 /// onMount 计数检测取消/恢复是否重复生命周期,tint 让各出现位置绘制结果可统一断言。 fn resumable_paint_source(copies: usize, locals: usize) -> String { let children = std::iter::repeat_n("item", copies) .collect::>() .join(", "); let locals = "probe = 2\n".repeat(locals); format!( "class Painted: RectBlock {{\n tint: String\n mounted: Object\n function onMount(self: Painted, mount: Mount): Unit {{ self.mounted.increment() }}\n function paint(self: Painted, mount: Mount, geometry: Bounds): DisplayList {{\n{locals}drawing = RectBlock.paint(self,mount,geometry)\ndrawing.commands.at(0).color = self.tint\nreturn drawing\n}}\n}}\nmounted = ui.state(0)\nitem = Painted(2,20,0,\"#DDEEFF\",\"#ED6A5A\",mounted)\npage = Page()\npage.render(Row(0,0,{children}))" ) } #[test] /// 分别加载含源布局/源绘制的示例并主动 reclaim 临时辅助对象。 /// 随后无业务变化刷新必须为 None,版本不变,证明缓存未把短命 helper 当作业务失效依赖。 fn collecting_lazy_helpers_does_not_invalidate_stable_layout_or_paint() { for source in [ include_str!("../../../examples/flex-constraints.endor"), include_str!("../../../examples/source-paint.endor"), ] { let (mut session, initial) = ReplSession::load(source, "app.main", 281, 1).unwrap(); session .bridge .reclaim(&mut session.candidate.vm, &mut session.candidate.roots) .unwrap(); assert!(session.refresh_document().unwrap().is_none()); assert_eq!( session.documents[&crate::window::MAIN_WINDOW] .frame .layout_version, initial.frame.layout_version ); } } #[test] /// 用 160/640 个出现位置强制布局和绘制让出一次执行。 /// 首次 Pending 时托管对象增长必须小于固定阈值,不能预建整树 Bounds/collector;显式取消后续体和只读范围都应关闭。 fn layout_and_paint_prepare_keep_only_current_occurrence_managed_helpers() { for copies in [160, 640] { let (mut session, initial) = ReplSession::load(&resumable_paint_source(copies, 0), "app.main", 280, 1).unwrap(); let before = session.candidate.vm.object_count(); let progress = session .bridge .begin_paint_frame( &mut session.candidate.vm, initial.ui_root.clone(), initial.frame, ) .unwrap(); let crate::source_paint::Progress::Pending(work) = progress else { panic!("paint must yield"); }; // 每片只保留当前出现位置的辅助对象/结果;不能在首次让出前为所有位置预建 Bounds 和 collector。 assert!(session.candidate.vm.object_count() < before + 256); session .bridge .cancel_paint_frame(&mut session.candidate.vm, crate::window::MAIN_WINDOW, *work) .unwrap(); assert!(!session.candidate.vm.has_suspended_call()); session .bridge .set_viewport( &mut session.candidate.vm, Some(crate::layout::Size { width: 900.0, height: 650.0, }), ) .unwrap(); let root = session .bridge .prepare_frame(&mut session.candidate.vm) .unwrap() .unwrap(); let before = session.candidate.vm.object_count(); let progress = session .bridge .begin_layout_frame(&mut session.candidate.vm, root) .unwrap(); let crate::ui_bridge::LayoutProgress::Pending(work) = progress else { panic!("layout must yield"); }; assert!(session.candidate.vm.object_count() < before + 256); session .bridge .cancel_layout_frame(&mut session.candidate.vm, *work) .unwrap(); assert!(!session.candidate.vm.has_suspended_call()); assert!(!session.candidate.vm.object_store().is_read_only()); } } #[test] /// 修改共享 tint 后逐片推进到 paint 挂起,检查旧完整文档仍可见。 /// 换视口取消未发布绘制并重算,最终 80 条命令全为新色,onMount 仍恰好 80 次,取消与切片统计可观察。 fn pending_paint_retargets_without_replaying_completed_mount_hooks() { let (mut session, initial) = ReplSession::load(&resumable_paint_source(80, 0), "app.main", 278, 1).unwrap(); let viewports = std::collections::BTreeMap::new(); session .execute_incremental("item.tint = \"#526AC7\"", "app.main", &viewports) .unwrap(); for _ in 0..100 { session .resize_windows_incremental(&viewports, false) .unwrap(); if session .refresh .as_ref() .is_some_and(|work| work.paint.is_some()) { break; } } assert!( session .refresh .as_ref() .is_some_and(|work| work.paint.is_some()) ); assert!(session.candidate.vm.has_suspended_call()); assert_eq!( session.documents[&crate::window::MAIN_WINDOW] .frame .layout_version, initial.frame.layout_version ); assert!(session.documents[&crate::window::MAIN_WINDOW].frame.commands.iter().all(|command| matches!(command, RenderCommand::RoundedRect { color, .. } if color == "#ED6A5A"))); let latest = std::collections::BTreeMap::from([( crate::window::MAIN_WINDOW, crate::layout::Size { width: 900.0, height: 650.0, }, )]); session.resize_windows_incremental(&latest, false).unwrap(); assert!(!session.candidate.vm.has_suspended_call()); let settled = session.resize_windows(&latest).unwrap().unwrap(); assert_eq!(settled.frame.commands.len(), 80); assert!(settled.frame.commands.iter().all( |command| matches!(command, RenderCommand::RoundedRect { color, .. } if color == "#526AC7") )); assert_eq!( session.execute("mounted.value", "app.main").unwrap().value, "80" ); assert_eq!(source_measure_stat(&mut session, "paintCancels"), 1); assert!(source_measure_stat(&mut session, "paintSlices") > 1); } #[test] /// 利用长 paint 先产生暂停,再在解码时遇到非法颜色。 /// 必须同时验证曾挂起及最终失败;故障关闭 VM 续体/只读范围,保留旧文档版本和原始绘制颜色。 fn paint_error_after_pause_closes_read_only_scope_and_preserves_last_picture() { let (mut session, initial) = ReplSession::load(&resumable_paint_source(1, 300), "app.main", 279, 1).unwrap(); let viewports = std::collections::BTreeMap::new(); session .execute_incremental("item.tint = \"invalid-color\"", "app.main", &viewports) .unwrap(); let mut paused = false; let mut failed = false; for _ in 0..100 { match session.resize_windows_incremental(&viewports, false) { Ok(_) => { paused |= session .refresh .as_ref() .is_some_and(|work| work.paint.is_some()) } Err(_) => { failed = true; break; } } } assert!(paused && failed); assert!(session.is_faulted()); assert!(!session.candidate.vm.has_suspended_call()); assert!(!session.candidate.vm.object_store().is_read_only()); assert_eq!( session.documents[&crate::window::MAIN_WINDOW] .frame .layout_version, initial.frame.layout_version ); assert!(session.documents[&crate::window::MAIN_WINDOW].frame.commands.iter().all(|command| matches!(command, RenderCommand::RoundedRect { color, .. } if color == "#ED6A5A"))); } #[test] /// paint 局部变量先引用旧 ObjectList,再重新绑定到新 DisplayList。 /// 允许局部引用重绑不等于允许修改旧业务对象;绘制成功后 previous 仍应为空。 fn source_paint_can_rebind_old_plain_reference_to_new_result_without_mutating_it() { let source = r##"class ReboundRect: RectBlock { previous: ObjectList function paint(self: ReboundRect, mount: Mount, geometry: Bounds): DisplayList { drawing = self.previous drawing = RectBlock.paint(self, mount, geometry) return drawing } } previous = ObjectList() rect = ReboundRect(80, 40, 0, "#DDEEFF", previous) page = Page() page.render(rect)"##; let (mut session, document) = ReplSession::load(source, "app.main", 75, 1).unwrap(); assert_eq!(document.frame.commands.len(), 1); assert_eq!( session.execute("previous.count", "app.main").unwrap().value, "0" ); } #[test] /// 源 paint 修改原生基类返回的命令颜色,检查共享对象各出现位置均使用覆盖结果。 /// 直接写堆上的 tint 而不执行 REPL,只靠 paint 的字段依赖就应触发重绘并在下一轮稳定。 fn source_paint_overrides_native_commands_and_reacts_to_heap_field_writes() { let (mut session, initial) = ReplSession::load( include_str!("../../../examples/source-paint.endor"), "app.main", 71, 1, ) .unwrap(); initial.validate().unwrap(); assert_eq!(initial.frame.commands.iter().filter(|command| matches!(command, RenderCommand::RoundedRect { color, .. } if color == "#ED6A5A")).count(), 2); assert!( initial.frame.commands.iter().any( |command| matches!(command, RenderCommand::Text { color, .. } if color == "#FFFFFF") ) ); let globals = session.candidate.globals.unwrap(); let Value::Object(rect) = session .candidate .vm .dict_get(globals, &Value::Text("rect".into())) .unwrap() .unwrap() else { panic!("Block") }; // 不经 Console、不写全局绑定、不改焦点,只改变 paint 读过的属性,单独验证该读依赖足以使帧失效。 session .candidate .vm .set_attr(rect, "tint", Value::Text("#526AC7".into())) .unwrap(); let updated = session.refresh_document().unwrap().unwrap(); assert_eq!(updated.frame.commands.iter().filter(|command| matches!(command, RenderCommand::RoundedRect { color, .. } if color == "#526AC7")).count(), 2); assert!(session.refresh_document().unwrap().is_none()); } #[test] /// paint 尝试写 self.tint,必须在写入前被只读保护拒绝并令会话 fault。 /// 原业务颜色不变,错误展开后宿主可正常直接写属性;另测非法颜色命令的发布拒绝。 fn source_paint_rejects_business_mutation_before_it_happens_and_restores_scope() { let source = r##"class BadPaint: RectBlock { tint: String function paint(self: BadPaint, mount: Mount, geometry: Bounds): DisplayList { self.tint = "#000000" return RectBlock.paint(self, mount, geometry) } } rect = BadPaint(100, 40, 0, "#DDEEFF", "#FF0000") page = Page() page.render(rect)"##; let mut session = ReplSession::new(72).unwrap(); assert!( session .execute(source, "app.main") .err() .unwrap() .to_string() .contains("read-only") ); assert!(session.is_faulted()); let globals = session.candidate.globals.unwrap(); let Value::Object(rect) = session .candidate .vm .dict_get(globals, &Value::Text("rect".into())) .unwrap() .unwrap() else { panic!("Block") }; assert_eq!( session.candidate.vm.get_attr(rect, "tint").unwrap(), Value::Text("#FF0000".into()) ); session .candidate .vm .set_attr(rect, "tint", Value::Text("#526AC7".into())) .unwrap(); let bad_color = include_str!("../../../examples/source-paint.endor").replace("#ED6A5A", "invalid color"); assert!(ReplSession::load(&bad_color, "app.main", 73, 1).is_err()); } #[test] /// 生成 1100 个共享 rect 出现位置,使 Mount 变更通知超过单批容量。 /// 首次仍需完整产出 1100 条命令,随后无变更刷新为 None,避免通知溢出造成永久重绘。 fn source_paint_is_stable_when_mount_notifications_overflow_the_change_batch() { let fixture = include_str!("../../../examples/source-paint.endor"); let mut source = fixture[..fixture.find("root = Column").unwrap()].to_owned(); source.push_str("root = Column(0, 0"); for _ in 0..1100 { source.push_str(", rect"); } source.push_str(")\npage = Page()\npage.render(root)"); let (mut session, document) = ReplSession::load(&source, "app.main", 74, 1).unwrap(); assert_eq!(document.frame.commands.len(), 1100); assert!(session.refresh_document().unwrap().is_none()); } #[test] /// 检查可选原生构造参数、可变子项和源子类字段在同一构造中的独立分段。 /// 错误类型在分配前拒绝,Block 数量不增;合法回调有效,并逐一验证已公开 UI 方法的 native signature。 fn constructor_options_and_subclass_fields_have_independent_contracts() { let (mut session, document) = ReplSession::load( include_str!("../../../examples/constructor-contracts.endor"), "app.main", 166, 1, ) .unwrap(); document.validate().unwrap(); for (expression, expected) in [ ("rect.width", "180"), ("rect.radius", "0"), ("rect.tag", "\"省略 radius/color 后的字段\""), ("root.tag", "\"可变子项之后的字段\""), ("event.kind", "\"click\""), ("items.count", "2"), ("ui.isInstance(items.at(0), TaggedRect)", "true"), ] { assert_eq!( session.execute(expression, "app.main").unwrap().value, expected, "{expression}" ); } let blocks = session .execute("ui.stats().blocks", "app.main") .unwrap() .value; for (expression, expected) in [ ("TaggedRect(\"bad\", 60, \"tag\")", "expects Number"), ("TaggedColumn(0, 0, 7, \"tag\")", "expects Block"), ("ui.rect(1, 2, \"bad\")", "expects Number"), ("ui.text(7)", "expects String"), ("TaggedEvent(7, \"tag\")", "expects String"), ("ui.isSubtype(7, Block)", "expects Type"), ] { let error = session .execute(expression, "app.main") .err() .expect("invalid typed constructor/API"); assert!( error.to_string().contains(expected), "{expression}: {error:#}" ); } assert_eq!( session .execute("ui.stats().blocks", "app.main") .unwrap() .value, blocks ); session.execute("button.click()", "app.main").unwrap(); assert_eq!( session.execute("rect.color", "app.main").unwrap().value, "\"#237A45\"" ); for name in [ "open", "present", "text", "rect", "spacer", "row", "column", "button", "page", "state", "textOf", "stats", "viewport", "window", "isInstance", "isSubtype", "implement", "implements", "supports", "after", ] { let Value::Object(function) = session .candidate .vm .get_attr(session.bridge.ui, name) .unwrap() else { panic!("native Function") }; let signature = session .candidate .vm .object_store() .native_signature(function) .unwrap() .expect("published UI signature"); signature .validate(session.candidate.vm.object_store()) .unwrap(); } } #[test] /// 加载满足参数逆变/返回协变的视觉方法覆盖,验证测量和点击都按动态类型执行。 /// 再分别缩窄参数、放宽返回类型,检查类定义被对应 override 诊断拒绝。 fn source_overrides_accept_wider_inputs_and_more_specific_results() { let source = include_str!("../../../examples/method-contracts.endor"); let (mut session, document) = ReplSession::load(source, "app.main", 164, 1).unwrap(); document.validate().unwrap(); assert_eq!( session .execute("rect.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "180" ); session.execute("button.click()", "app.main").unwrap(); assert_eq!( session .execute("rect.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "260" ); assert_eq!( session.execute("count.value", "app.main").unwrap().value, "1" ); for (source, reason) in [ ( source.replace("mount: Object", "mount: Point"), "override narrows a parameter type", ), ( source.replace("): Sized {", "): Object {"), "override widens the return type", ), ] { let error = ReplSession::load(&source, "app.main", 165, 1) .err() .expect("invalid override"); assert!(error.to_string().contains(reason), "{error:#}"); } } #[test] /// 把 Mount/Bounds 的名义类型、事件 Bool|String 选项及可空 Page.window/open 参数串联执行。 /// 合法空值和 union 分支互通,Number 选项则必须以 Bool | String 契约诊断拒绝。 fn nullable_page_methods_union_event_options_and_nominal_mount_bounds_compose() { let (mut session, _) = ReplSession::load( include_str!("../../../examples/visual-protocols.endor"), "app.main", 163, 1, ) .unwrap(); for (expression, expected) in [ ("context = rect.mounts().at(0)", None), ("ui.isInstance(context.bounds(), Bounds)", Some("true")), ("Point(0, 0).inside(context.bounds())", Some("false")), ( "listener = root.on(\"click\", page.close, Point(0, 0).inCircle(0, 0, 1))", None, ), ("listener.isConnected()", Some("true")), ("listener.disconnect()", Some("nil")), ("listener.isConnected()", Some("false")), ("page.close()", Some("nil")), ("page.window()", Some("nil")), ("page.open(page.window())", None), ("ui.isInstance(page.window(), Window)", Some("true")), ] { let result = session.execute(expression, "app.main").unwrap(); if let Some(expected) = expected { assert_eq!(result.value, expected, "{expression}"); } } let error = session .execute("root.on(\"click\", page.close, 7)", "app.main") .err() .expect("invalid union input"); assert!(error.to_string().contains("Bool | String"), "{error:#}"); } #[test] /// 向 measure/paint、几何方法、resize 和 setColor 传递错误名义类型。 /// 检查每项错误点名所需类型,业务颜色保持不变,随后合法 Constraints 测量仍返回受限宽度。 fn native_contracts_reject_wrong_types_before_geometry_or_window_effects() { let (mut session, _) = ReplSession::load( include_str!("../../../examples/visual-protocols.endor"), "app.main", 162, 1, ) .unwrap(); session .execute("context = rect.mounts().at(0)", "app.main") .unwrap(); for (expression, expected) in [ ("rect.measure(context, Point(0, 0))", "expects Constraints"), ( "rect.measure(Point(0, 0), Constraints(0, 0, 120, 80))", "expects Mount", ), ("rect.paint(context, Point(0, 0))", "expects Bounds"), ( "Point(0, 0).inside(Constraints(0, 0, 120, 80))", "expects Bounds", ), ("Point(0, 0).inCircle(0, 0, \"bad\")", "expects Number"), ("ui.window().resize(\"bad\", 700)", "expects Number"), ("rect.setColor(7)", "expects String"), ] { let error = session .execute(expression, "app.main") .err() .expect("invalid native call"); assert!( error.to_string().contains(expected), "{expression}: {error:#}" ); } assert_eq!( session.execute("results.color", "app.main").unwrap().value, "\"#DDEEFF\"" ); assert_eq!( session .execute( "rect.measure(context, Constraints(0, 0, 120, 80)).width", "app.main" ) .unwrap() .value, "120" ); } #[test] /// 执行示例内直接调用的原生视觉协议,比较托管 MeasureResult/Arrangement/DisplayList 与真实发布命令。 /// 局部命中允许点内/点外判断,但非法约束、错属 Mount 和已卸载上下文不得用于绘制。 fn native_visual_methods_use_managed_values_and_match_real_geometry() { let (mut session, initial) = ReplSession::load( include_str!("../../../examples/visual-protocols.endor"), "app.main", 61, 1, ) .unwrap(); initial.validate().unwrap(); for (expression, expected) in [ ("results.width", "120"), ("results.height", "60"), ("results.childX", "44"), ("results.childY", "54"), ("results.color", "\"#DDEEFF\""), ] { assert_eq!( session.execute(expression, "app.main").unwrap().value, expected ); } assert!(initial.frame.commands.iter().any(|command| matches!(command, RenderCommand::RoundedRect { width: 200.0, height: 60.0, color, .. } if color == "#DDEEFF"))); session .execute("context = rect.mounts().at(0)", "app.main") .unwrap(); assert_eq!( session .execute("rect.hitTest(context, Point(1, 1))", "app.main") .unwrap() .value, "true" ); assert_eq!( session .execute("rect.hitTest(context, Point(-1, 1))", "app.main") .unwrap() .value, "false" ); assert!( session .execute( "rect.measure(context, Constraints(200, 0, 100, 100))", "app.main" ) .is_err() ); assert!( session .execute("root.paint(context, Bounds(0, 0, 10, 10))", "app.main") .is_err() ); session.execute("page.close()", "app.main").unwrap(); assert!( session .execute("rect.paint(context, Bounds(0, 0, 10, 10))", "app.main") .is_err() ); } #[test] /// 先 invalidate paint 再 invalidate layout,对比 measured 为 0 和 1。 /// 两者都可发布但不替换 Mount;无关查询不发布,未知失效类别明确报错。 fn explicit_invalidation_publishes_once_preserves_mount_and_remeasures_only_when_requested() { let (mut session, _) = ReplSession::load( include_str!("../../../examples/visual-protocols.endor"), "app.main", 62, 1, ) .unwrap(); session .execute("context = rect.mounts().at(0)", "app.main") .unwrap(); let original = session.execute("context", "app.main").unwrap().value; let update = session .execute("rect.invalidate(\"paint\")", "app.main") .unwrap() .document .unwrap(); update.validate().unwrap(); assert_eq!( session .execute("ui.stats().measured", "app.main") .unwrap() .value, "0" ); assert!( session .execute("rect.invalidate(\"layout\")", "app.main") .unwrap() .document .is_some() ); assert_eq!( session .execute("ui.stats().measured", "app.main") .unwrap() .value, "1" ); assert_eq!( session .execute("rect.mounts().at(0)", "app.main") .unwrap() .value, original ); assert!( session .execute("results.width", "app.main") .unwrap() .document .is_none() ); assert!( session .execute("rect.invalidate(\"unknown\")", "app.main") .is_err() ); } #[test] /// 加载共享子项生命周期示例,通过日志计数检查每个出现位置各自挂载。 /// 普通颜色更新不重复 onMount;关闭时子先父后卸载,保存的旧 Mount 永久失效,重开创建新出现位置。 fn mount_hooks_run_per_occurrence_settle_and_unmount_before_parent() { let (mut session, initial) = ReplSession::load( include_str!("../../../examples/mount-lifecycle.endor"), "app.main", 51, 1, ) .unwrap(); initial.validate().unwrap(); for (expression, expected) in [ ("log.mounted.value", "2"), ("log.parentMounted", "1"), ("log.childMounted", "3"), ] { assert_eq!( session.execute(expression, "app.main").unwrap().value, expected ); } session .execute( "saved = child.mounts().at(0)\nchild.setColor(\"#237A45\")", "app.main", ) .unwrap(); assert_eq!( session .execute("log.mounted.value", "app.main") .unwrap() .value, "2" ); let closed = session .execute("page.close()", "app.main") .unwrap() .document .unwrap(); assert!(closed.frame.mounts.is_empty()); assert_eq!( session .execute("log.unmounted.value", "app.main") .unwrap() .value, "2" ); assert_eq!( session .execute("log.childUnmounted", "app.main") .unwrap() .value, "5" ); assert_eq!( session .execute("log.parentUnmounted", "app.main") .unwrap() .value, "6" ); assert_eq!( session.execute("saved.mounted", "app.main").unwrap().value, "false" ); assert!(session.execute("saved.bounds()", "app.main").is_err()); session.execute("page.open()", "app.main").unwrap(); assert_eq!( session .execute("log.mounted.value", "app.main") .unwrap() .value, "4" ); assert_eq!( session.execute("saved.mounted", "app.main").unwrap().value, "false" ); } #[test] /// 让两个页面使用同一业务根,然后切换活动页面。 /// 每次切换都卸载旧上下文并挂载新上下文;共享 Block 不能让旧 Mount 或 page() 指向继续复用。 fn page_switch_replaces_mount_context_even_for_shared_root() { let (mut session, _) = ReplSession::load( include_str!("../../../examples/mount-lifecycle.endor"), "app.main", 52, 1, ) .unwrap(); session .execute( "saved = child.mounts().at(0)\nsecond = Page()\nsecond.render(root)", "app.main", ) .unwrap(); assert_eq!( session .execute("log.mounted.value", "app.main") .unwrap() .value, "4" ); assert_eq!( session .execute("log.unmounted.value", "app.main") .unwrap() .value, "2" ); assert_eq!( session.execute("saved.mounted", "app.main").unwrap().value, "false" ); assert_eq!( session .execute("child.mounts().at(0).page()", "app.main") .unwrap() .value, session.execute("second", "app.main").unwrap().value ); session.execute("page.activate()", "app.main").unwrap(); assert_eq!( session .execute("log.mounted.value", "app.main") .unwrap() .value, "6" ); } #[test] /// onMount 向容器 append 新文字,最终文档应包含该结构变化,验证回调后继续收敛。 /// 另一个 onMount 传入错误 setText 参数,错误应停止共享运行时而非忽略生命周期失败。 fn lifecycle_hook_can_edit_container_without_session_lock_and_failure_stops_domain() { let source = r#"class GrowingColumn: Column { function onMount(self: GrowingColumn, mount: Mount): Unit { self.append(TextBlock("from hook")) } } root = GrowingColumn(0, 0) page = Page() page.render(root)"#; let (_, document) = ReplSession::load(source, "app.main", 53, 1).unwrap(); assert!(document.frame.commands.iter().any( |command| matches!(command, RenderCommand::Text { value, .. } if value == "from hook") )); let mut session = ReplSession::new(54).unwrap(); let source = r#"class BrokenText: TextBlock { function onMount(self: BrokenText, mount: Mount): Unit { self.setText(1) } } page = Page() page.render(BrokenText("x"))"#; assert!(session.execute(source, "app.main").is_err()); assert!(session.is_faulted()); } /// 在标准事件示例后附加 extra 语句,创建独立会话和初始完整文档。 /// 各路由测试只需描述额外监听器,即可共享相同父子树、计数器与默认事件配置。 fn event_session(extra: &str) -> (ReplSession, RenderDocument) { let source = format!( "{}\n{}", include_str!("../../../examples/events.endor"), extra ); ReplSession::load(&source, "app.main", 41, 1).unwrap() } /// 按全局 button 的业务身份找给定文档中的可交互 Mount,模拟原生 click。 /// 事件使用该文档的会话与布局版本,返回派发后的完整文档,避免用过期目标绕过真实输入检查。 fn click_document(session: &mut ReplSession, document: &RenderDocument) -> RenderDocument { let globals = session.candidate.globals.unwrap(); let Value::Object(button) = session .candidate .vm .dict_get(globals, &Value::Text("button".into())) .unwrap() .unwrap() else { panic!("Button") }; let mount = document .frame .mounts .iter() .find(|mount| mount.interactive && mount.block_id == button.to_string()) .unwrap(); session .dispatch(&crate::events::Input { window: crate::window::MAIN_WINDOW, session: document.frame.session, layout_version: document.frame.layout_version, mount: mount.id, kind: "click".into(), point: None, delta: None, press_point: None, tab_drop: None, screen_position: None, }) .unwrap() .document .unwrap() } #[test] /// 通过原生输入路径触发一次 click,检查捕获、目标方法、目标监听器、冒泡依次记为 1/2/3/4。 /// 派发结束后的模型保留最后阶段信息,订阅令牌仍连接。 fn managed_event_route_orders_capture_method_listeners_and_bubble() { let (mut session, initial) = event_session(""); click_document(&mut session, &initial).validate().unwrap(); for (field, expected) in [ ("captureStep", "1"), ("methodStep", "2"), ("targetStep", "3"), ("bubbleStep", "4"), ] { assert_eq!( session .execute(&format!("model.{field}"), "app.main") .unwrap() .value, expected ); } assert_eq!( session.execute("model.phase", "app.main").unwrap().value, "\"bubble\"" ); assert_eq!( session .execute("target.isConnected()", "app.main") .unwrap() .value, "true" ); } #[test] /// 第一场景在捕获中断开尚未调用的目标监听器,必须跳过它但继续冒泡。 /// 第二场景在目标捕获中 stopPropagation,当前目标组仍执行,祖先冒泡被阻止。 fn disconnect_during_capture_skips_pending_listener_and_stop_preserves_current_group() { let (mut session, initial) = event_session( "function cancel(event: Event): Unit { target.disconnect() }\nconnection = root.on(\"click\", cancel, \"capture\")", ); click_document(&mut session, &initial); assert_eq!( session .execute("model.targetStep", "app.main") .unwrap() .value, "0" ); assert_eq!( session .execute("model.bubbleStep", "app.main") .unwrap() .value, "3" ); assert_eq!( session .execute("target.isConnected()", "app.main") .unwrap() .value, "false" ); let (mut session, initial) = event_session( "function stop(event: Event): Unit { event.stopPropagation() }\nconnection = button.on(\"click\", stop, \"capture\")", ); click_document(&mut session, &initial); assert_eq!( session .execute("model.targetStep", "app.main") .unwrap() .value, "3" ); assert_eq!( session .execute("model.bubbleStep", "app.main") .unwrap() .value, "0" ); } #[test] /// 目标捕获使用 stopImmediatePropagation,应连目标默认方法也跳过。 /// 代码派发 custom 事件可返回同一带 preventDefault 标记的 Event,结束后 phase 为 none,并允许再次派发。 fn immediate_stop_skips_target_method_and_code_dispatch_returns_cancelled_event() { let (mut session, initial) = event_session( "function stop(event: Event): Unit { event.stopImmediatePropagation() }\nconnection = button.on(\"click\", stop, \"capture\")", ); click_document(&mut session, &initial); assert_eq!( session .execute("model.count.value", "app.main") .unwrap() .value, "1" ); let (mut session, _) = event_session( "function prevent(event: Event): Unit { event.preventDefault() }\nconnection = button.on(\"custom\", prevent)\nresult = button.dispatch(Event(\"custom\"))", ); assert_eq!( session .execute("result.isDefaultPrevented()", "app.main") .unwrap() .value, "true" ); assert_eq!( session.execute("result.phase", "app.main").unwrap().value, "\"none\"" ); // 已完成派发的 Event 可以重用;前次派发的活跃守卫必须已经解除。 session .execute("button.dispatch(result)", "app.main") .unwrap(); } #[test] /// 回调失败后断开故障监听器,再派发同一 Event,验证活跃派发守卫已释放。 /// 另外保留订阅 token 却删除隐藏目标,回收后目标弱升级失败且 token 断开,证明它不强持有目标。 fn event_failure_releases_dispatch_guard_and_token_does_not_retain_target() { let (mut session, _) = event_session(""); session.execute("function fail(event: Event): Unit { page.render(1) }\nfailing = button.on(\"failure\", fail)\nfailedEvent = Event(\"failure\")", "app.main").unwrap(); assert!( session .execute("button.dispatch(failedEvent)", "app.main") .is_err() ); session .execute( "failing.disconnect()\nbutton.dispatch(failedEvent)", "app.main", ) .unwrap(); session .execute( "orphan = Button(\"unmounted\")\ntoken = orphan.on(\"click\", model.target)", "app.main", ) .unwrap(); let globals = session.candidate.globals.unwrap(); let Value::Object(orphan) = session .candidate .vm .dict_get(globals, &Value::Text("orphan".into())) .unwrap() .unwrap() else { panic!("Block expected") }; let weak = session.candidate.vm.downgrade(orphan).unwrap(); session .candidate .vm .dict_delete(globals, &Value::Text("orphan".into())) .unwrap(); session .bridge .reclaim(&mut session.candidate.vm, &mut session.candidate.roots) .unwrap(); assert!(session.candidate.vm.upgrade(weak).unwrap().is_none()); assert_eq!( session .execute("token.isConnected()", "app.main") .unwrap() .value, "false" ); } #[test] /// 加载原生视觉子类,把旧 label 引用保存到 alias 后替换为新的源实例。 /// 共享转发应让 alias 读写新字段、更新多个绘制位置,同时旧属性存储的弱句柄可回收。 fn source_native_subclasses_share_live_fields_and_release_replaced_storage() { let (mut session, initial) = ReplSession::load( include_str!("../../../examples/native-subclasses.endor"), "app.main", 31, 1, ) .unwrap(); initial.validate().unwrap(); assert_eq!( session .execute("isInstance(label, TextBlock)", "app.main") .unwrap() .value, "true" ); assert_eq!( session .execute("isInstance(page, Page)", "app.main") .unwrap() .value, "true" ); session.execute("alias = label", "app.main").unwrap(); let globals = session.candidate.globals.unwrap(); let Value::Object(label) = session .candidate .vm .dict_get(globals, &Value::Text("label".into())) .unwrap() .unwrap() else { panic!("Block expected") }; let path = session .candidate .vm .object_store() .attribute_path(label) .unwrap(); let previous = session .candidate .vm .downgrade(*path.last().unwrap()) .unwrap(); let updated = session .execute( r##"label = CustomStatus("replacement", 2, "#242422", "#237A45", "new field")"##, "app.main", ) .unwrap() .document .unwrap(); assert!(updated.frame.commands.iter().any( |command| matches!(command, RenderCommand::Text { value, .. } if value == "new field") )); session .bridge .reclaim(&mut session.candidate.vm, &mut session.candidate.roots) .unwrap(); assert!(session.candidate.vm.upgrade(previous).unwrap().is_none()); assert_eq!( session.execute("alias.message", "app.main").unwrap().value, "\"new field\"" ); let updated = session .execute("button.click()", "app.main") .unwrap() .document .unwrap(); assert_eq!(updated.frame.commands.iter().filter(|command| matches!(command, RenderCommand::Text { value, .. } if value == "new field")).count(), 3); let updated = session .execute("alias.message = \"changed field\"", "app.main") .unwrap() .document .unwrap(); assert!(updated.frame.commands.iter().any( |command| matches!(command, RenderCommand::Text { value, .. } if value == "changed field") )); } #[test] /// 完整源码加载后执行 Console 类型查询,再用原生 click 调用原程序中的源回调。 /// 两个共享文字都应变为 10 且 VM 健康,覆盖混合入口中源 ID/编译单元身份不冲突的行为。 fn loaded_program_console_and_native_events_share_unique_source_ids() { let (mut session, initial) = ReplSession::load( include_str!("../../../examples/managed-types.endor"), "app.main", 1, 1, ) .unwrap(); initial.validate().unwrap(); assert_eq!( session .execute("isInstance(page, Block)", "app.main") .unwrap() .value, "true" ); let mount = initial .frame .mounts .iter() .find(|mount| mount.interactive) .unwrap(); let event = crate::events::Input { window: crate::window::MAIN_WINDOW, session: 1, layout_version: initial.frame.layout_version, mount: mount.id, kind: "click".into(), point: None, delta: None, press_point: None, tab_drop: None, screen_position: None, }; let updated = session.dispatch(&event).unwrap().document.unwrap(); updated.validate().unwrap(); assert_eq!( updated .frame .commands .iter() .filter(|command| matches!(command, RenderCommand::Text { value, .. } if value == "10" )) .count(), 2 ); assert!(!session.is_faulted()); } #[test] /// 向被裁剪的子项中心发送 click,虽在其原始矩形内也不得触发计数。 /// 随后滚动同一 ScrollBlock 的一个出现位置、scrollIntoView 并扩大容器,分别检查独立偏移、可见性及范围回落到零。 fn scroll_occurrences_are_independent_and_clipped_pointer_input_is_ignored() { let (mut session, initial) = ReplSession::load( include_str!("../../../examples/scroll.endor"), "app.main", 1, 240, ) .unwrap(); let globals = session.candidate.globals.unwrap(); let Value::Object(middle) = session .candidate .vm .dict_get(globals, &Value::Text("middle".into())) .unwrap() .unwrap() else { panic!("expected Block"); }; let target = initial .frame .mounts .iter() .find(|m| m.block_id == middle.to_string()) .unwrap(); let point = [ target.x + target.width / 2.0, target.y + target.height / 2.0, ]; assert!(!target.contains(crate::geometry::Point::new(point[0], point[1]))); session .dispatch(&crate::events::Input { window: 1, session: 240, layout_version: initial.frame.layout_version, mount: target.id, kind: "click".into(), point: Some(point), press_point: Some(point), tab_drop: None, screen_position: None, delta: None, }) .unwrap(); assert_eq!( session.execute("count.value", "app.main").unwrap().value, "0" ); session.execute("saved = scroller.mounts().at(0)\nsaved.scrollTo(0,100)\nsaved.scrollBy(0,20)\nsaved.scrollBy(0,30)","app.main").unwrap(); assert_eq!( session .execute("saved.scrollPosition().y", "app.main") .unwrap() .value, "150" ); assert_eq!( session .execute("scroller.mounts().at(1).scrollPosition().y", "app.main") .unwrap() .value, "0" ); session .execute("last.mounts().at(0).scrollIntoView()", "app.main") .unwrap(); let Value::Object(last) = session .candidate .vm .dict_get(globals, &Value::Text("last".into())) .unwrap() .unwrap() else { panic!("expected Block"); }; let frame = &session.documents[&crate::window::MAIN_WINDOW].frame; let target = frame .mounts .iter() .find(|m| m.block_id == last.to_string()) .unwrap(); assert!(target.contains(crate::geometry::Point::new( target.x + target.width / 2.0, target.y + target.height / 2.0 ))); assert_eq!(frame.command_clips.len(), frame.commands.len()); session .execute("scroller.height = 1000", "app.main") .unwrap(); assert_eq!( session .execute("saved.scrollPosition().y", "app.main") .unwrap() .value, "0" ); assert_eq!( session .execute("saved.scrollPosition().maxY", "app.main") .unwrap() .value, "0" ); } #[test] /// 为已有 Mount 建立长延时任务,再开始会挂起的 resize 布局并替换视口目标。 /// 取消应恢复旧几何/挂载身份、清除临时 layout,最终重新收敛且原任务仍 pending,避免把放弃的准备当成卸载。 fn new_viewport_cancels_pending_layout_and_restores_saved_mount_context() { let children = std::iter::repeat_n("item", 40) .collect::>() .join(", "); let source = format!( "class Wide: Row {{\n function measure(self: Wide, mount: Mount, constraints: Constraints): MeasureResult {{ return MeasureResult(340, 60) }}\n}}\nitem = RectBlock(2, 20)\npage = Page()\npage.render(Wide(0, 0, {children}))" ); let (mut session, _) = ReplSession::load(&source, "app.main", 272, 1).unwrap(); session.execute("saved = item.mounts().at(0)\nreceived = ui.state(0)\ntoken = ui.after(saved, \"keep\", 60000, received.increment)", "app.main").unwrap(); let globals = session.candidate.globals.unwrap(); let Value::Object(saved) = session .candidate .vm .dict_get(globals, &Value::Text("saved".into())) .unwrap() .unwrap() else { panic!("saved Mount"); }; let first = std::collections::BTreeMap::from([( crate::window::MAIN_WINDOW, crate::layout::Size { width: 800.0, height: 600.0, }, )]); for _ in 0..20 { session.resize_windows_incremental(&first, false).unwrap(); if session.candidate.vm.has_suspended_call() { break; } } assert!(session.candidate.vm.has_suspended_call()); let latest = std::collections::BTreeMap::from([( crate::window::MAIN_WINDOW, crate::layout::Size { width: 900.0, height: 650.0, }, )]); assert!( session .resize_windows_incremental(&latest, false) .unwrap() .is_none() ); assert!(!session.candidate.vm.has_suspended_call()); let mount = session .candidate .vm .payload::(saved, "Mount") .unwrap(); assert!(mount.mounted); assert!(mount.layout.is_none()); assert_eq!(mount.geometry.width, 2.0); assert!(session.resize_windows(&latest).unwrap().is_some()); assert!(!session.is_faulted()); assert_eq!( session.execute("token.status()", "app.main").unwrap().value, "\"pending\"" ); assert_eq!(source_measure_stat(&mut session, "layoutCancels"), 1); } #[test] /// 增量加载含 80 个出现位置的新候选,在初始布局尚未发布时替换视口目标。 /// 候选文档在完成前始终为空;重新收敛后构建计数仍为 1、挂载计数恰好 80,证明取消只重做布局。 fn candidate_initial_layout_retargets_without_reexecuting_program_or_hooks() { let children = std::iter::repeat_n("item", 80) .collect::>() .join(", "); let source = format!( "class Watched: RectBlock {{\n count: Object\n function onMount(self: Watched, mount: Mount): Unit {{ self.count.increment() }}\n}}\nbuilt = ui.state(0)\nbuilt.increment()\nmounted = ui.state(0)\nitem = Watched(2,20,mounted)\npage = Page()\npage.render(Row(0,0,{children}))" ); let (mut candidate, document) = ReplSession::load_incremental(&source, "app.main", 277, 1, None).unwrap(); assert!(document.is_none()); assert!(candidate.has_pending_refresh()); assert!(candidate.documents.is_empty()); let initial = std::collections::BTreeMap::new(); for _ in 0..20 { candidate .resize_windows_incremental(&initial, false) .unwrap(); if candidate.candidate.vm.has_suspended_call() { break; } } assert!(candidate.candidate.vm.has_suspended_call()); assert!(candidate.documents.is_empty()); let latest = std::collections::BTreeMap::from([( crate::window::MAIN_WINDOW, crate::layout::Size { width: 900.0, height: 650.0, }, )]); candidate .resize_windows_incremental(&latest, false) .unwrap(); assert!(!candidate.candidate.vm.has_suspended_call()); let settled = candidate.resize_windows(&latest).unwrap().unwrap(); assert_eq!(settled.frame.mounts.last().unwrap().x, 158.0); assert_eq!( candidate.execute("built.value", "app.main").unwrap().value, "1" ); assert_eq!( candidate .execute("mounted.value", "app.main") .unwrap() .value, "80" ); assert_eq!(source_measure_stat(&mut candidate, "layoutCancels"), 1); } #[test] /// 一次输入递增计数、改宽度并返回值,源执行结束后布局继续 Pending。 /// 此时禁止新 mutation/命令投影,保留旧文档;换视口后最终几何更新,但返回值和递增都只发生一次。 fn incremental_input_retains_value_and_never_replays_source_while_retargeting() { let children = std::iter::repeat_n("item", 80) .collect::>() .join(", "); let source = format!( "count = ui.state(0)\nitem = RectBlock(2,20)\npage = Page()\npage.render(Row(0,0,{children}))" ); let (mut session, initial) = ReplSession::load(&source, "app.main", 275, 1).unwrap(); let first = std::collections::BTreeMap::new(); let result = session .execute_incremental( "count.increment()\nitem.width = 3\ncount.value", "app.main", &first, ) .unwrap(); assert_eq!(result.value, "1"); assert!(result.document.is_none()); assert!(session.has_pending_refresh()); assert!(session.take_window_commands().is_err()); assert!(session.execute("count.increment()", "app.main").is_err()); for _ in 0..20 { session.resize_windows_incremental(&first, false).unwrap(); if session.candidate.vm.has_suspended_call() { break; } } assert!(session.candidate.vm.has_suspended_call()); assert_eq!( session.documents[&crate::window::MAIN_WINDOW] .frame .layout_version, initial.frame.layout_version ); let latest = std::collections::BTreeMap::from([( crate::window::MAIN_WINDOW, crate::layout::Size { width: 900.0, height: 650.0, }, )]); session.resize_windows_incremental(&latest, false).unwrap(); let settled = session.resize_windows(&latest).unwrap().unwrap(); assert_eq!(settled.frame.mounts.last().unwrap().x, 237.0); assert_eq!(result.value, "1"); assert_eq!( session.execute("count.value", "app.main").unwrap().value, "1" ); assert_eq!(source_measure_stat(&mut session, "layoutCancels"), 1); } #[test] /// 点击回调先改变业务计数,再通过多次增量刷新完成大树布局。 /// 挂起期间旧文档版本不变,最终计数为 1 且 refreshYields 大于零,避免分片时重放 click。 fn incremental_event_runs_callback_once_before_publishing_its_layout() { let children = std::iter::repeat_n("item", 80) .collect::>() .join(", "); let source = format!( "count = ui.state(0)\nitem = RectBlock(2,20)\nbutton = Button(\"increment\")\nbutton.onClick(count.increment)\npage = Page()\npage.render(Column(0,0,button,ui.textOf(count,\"value\"),Row(0,0,{children})))" ); let (mut session, initial) = ReplSession::load(&source, "app.main", 276, 1).unwrap(); let mount = initial .frame .mounts .iter() .find(|mount| mount.interactive) .unwrap(); let input = crate::events::Input { window: crate::window::MAIN_WINDOW, session: session.id, layout_version: initial.frame.layout_version, mount: mount.id, kind: "click".into(), point: None, press_point: None, delta: None, tab_drop: None, screen_position: None, }; let viewports = std::collections::BTreeMap::new(); let result = session.dispatch_incremental(&input, &viewports).unwrap(); assert!(result.document.is_none()); assert!(session.has_pending_refresh()); assert_eq!( session.documents[&crate::window::MAIN_WINDOW] .frame .layout_version, initial.frame.layout_version ); let mut complete = false; for _ in 0..1000 { if session .resize_windows_incremental(&viewports, false) .unwrap() .is_some() { complete = true; break; } } assert!(complete); assert!(!session.has_pending_refresh()); assert_eq!( session.execute("count.value", "app.main").unwrap().value, "1" ); assert!(source_measure_stat(&mut session, "refreshYields") > 0); } #[test] /// 只用原生布局的大树也应进入可恢复路径。 /// Pending 期间保留旧帧,换视口取消后重算仍产出最后子项 x=158/width=2,并记录切片与取消次数。 fn large_intrinsic_layout_yields_and_retargets_without_geometry_loss() { let children = std::iter::repeat_n("item", 80) .collect::>() .join(", "); let source = format!( "item = RectBlock(2,20)\nrow = Row(0,0,{children})\npage = Page()\npage.render(row)" ); let (mut session, initial) = ReplSession::load(&source, "app.main", 273, 1).unwrap(); let old_version = initial.frame.layout_version; assert_eq!(initial.frame.mounts.last().unwrap().x, 158.0); let first = std::collections::BTreeMap::from([( crate::window::MAIN_WINDOW, crate::layout::Size { width: 800.0, height: 600.0, }, )]); for _ in 0..20 { session.resize_windows_incremental(&first, false).unwrap(); if session.candidate.vm.has_suspended_call() { break; } } assert!(session.candidate.vm.has_suspended_call()); assert_eq!( session.documents[&crate::window::MAIN_WINDOW] .frame .layout_version, old_version ); let latest = std::collections::BTreeMap::from([( crate::window::MAIN_WINDOW, crate::layout::Size { width: 900.0, height: 650.0, }, )]); session.resize_windows_incremental(&latest, false).unwrap(); assert!(!session.candidate.vm.has_suspended_call()); let settled = session.resize_windows(&latest).unwrap().unwrap(); assert_eq!(settled.frame.mounts.last().unwrap().x, 158.0); assert_eq!(settled.frame.mounts.last().unwrap().width, 2.0); assert_eq!(source_measure_stat(&mut session, "layoutCancels"), 1); assert!(source_measure_stat(&mut session, "layoutSlices") > 1); } #[test] /// 两个立即就绪任务都递增同一状态,首次 poll 只交付第一个并启动刷新。 /// 刷新未完成时重复 poll 不交付第二个;第一帧完成后再 poll 才发布第二次递增。 fn idle_tasks_wait_for_prior_callback_refresh_before_next_delivery() { let (mut session, initial) = ReplSession::load( "state = ui.state(0)\npage = Page()\npage.render(ui.textOf(state,\"value\"))\na = ui.after(ui,\"a\",0,state.increment)\nb = ui.after(ui,\"b\",0,state.increment)", "app.main", 274, 1, ).unwrap(); let old_version = initial.frame.layout_version; let viewports = std::collections::BTreeMap::new(); assert!( session .poll_tasks_incremental(&viewports) .unwrap() .is_none() ); assert!(session.has_pending_refresh()); assert!( session .poll_tasks_incremental(&viewports) .unwrap() .is_none() ); assert_eq!( session.documents[&crate::window::MAIN_WINDOW] .frame .layout_version, old_version ); let first = session.resize_windows(&viewports).unwrap().unwrap(); assert!(first.frame.layout_version > old_version); assert_eq!( session.execute("state.value", "app.main").unwrap().value, "1" ); assert_eq!( session.execute("a.status()", "app.main").unwrap().value, "\"completed\"" ); assert_eq!( session.execute("b.status()", "app.main").unwrap().value, "\"pending\"" ); session.poll_tasks_incremental(&viewports).unwrap(); assert!(session.has_pending_refresh()); session.resize_windows(&viewports).unwrap(); assert_eq!( session.execute("state.value", "app.main").unwrap().value, "2" ); assert_eq!( session.execute("b.status()", "app.main").unwrap().value, "\"completed\"" ); } #[test] /// 启动增量 resize 后尝试普通 mutation,应拒绝但不使 VM fault。 /// 逐次推进时每个未完成返回都保持旧文档版本,只有整体完成才一次发布新版本并清除 pending。 fn incremental_viewport_refresh_retains_published_documents_until_complete() { let (mut session, _) = ReplSession::load( include_str!("../../../examples/flex-constraints.endor"), "app.main", 271, 1, ) .unwrap(); let old_version = session.documents[&crate::window::MAIN_WINDOW] .frame .layout_version; let viewports = std::collections::BTreeMap::from([( crate::window::MAIN_WINDOW, crate::layout::Size { width: 800.0, height: 600.0, }, )]); assert!( session .resize_windows_incremental(&viewports, false) .unwrap() .is_none() ); assert!(session.has_pending_refresh()); assert!(session.execute("blocked = 1", "app.main").is_err()); assert!(!session.is_faulted()); let mut completed = false; for _ in 0..1000 { if let Some(document) = session .resize_windows_incremental(&viewports, false) .unwrap() { assert!(document.frame.layout_version > old_version); assert!(!session.has_pending_refresh()); completed = true; break; } assert_eq!( session.documents[&crate::window::MAIN_WINDOW] .frame .layout_version, old_version ); } assert!(completed); assert!(source_measure_stat(&mut session, "refreshYields") > 0); } #[test] /// 绕过会话同步包装,直接调用桥接 begin_layout_frame 观察首个 Pending。 /// 循环把工作所有权传回 resume,最终 Complete 才断言完整几何,且 VM 不再残留挂起调用。 fn bridge_layout_can_return_pending_before_committing_a_complete_frame() { let children = std::iter::repeat_n("item", 40) .collect::>() .join(", "); let source = format!( "class Wide: Row {{\n function measure(self: Wide, mount: Mount, constraints: Constraints): MeasureResult {{ return MeasureResult(340, 60) }}\n}}\nitem = RectBlock(2, 20)\npage = Page()\npage.render(Wide(0, 0, {children}))" ); let (mut session, _) = ReplSession::load(&source, "app.main", 270, 1).unwrap(); session .bridge .set_viewport( &mut session.candidate.vm, Some(crate::layout::Size { width: 500.0, height: 300.0, }), ) .unwrap(); let root = session .bridge .prepare_frame(&mut session.candidate.vm) .unwrap() .unwrap(); let mut progress = session .bridge .begin_layout_frame(&mut session.candidate.vm, root) .unwrap(); assert!(matches!( progress, crate::ui_bridge::LayoutProgress::Pending(_) )); assert!(session.candidate.vm.has_suspended_call()); loop { match progress { crate::ui_bridge::LayoutProgress::Pending(pending) => { progress = session .bridge .resume_layout_frame(&mut session.candidate.vm, *pending) .unwrap(); } crate::ui_bridge::LayoutProgress::Complete(frame) => { assert_eq!(frame.mounts.last().unwrap().x, 78.0); assert!(!session.candidate.vm.has_suspended_call()); break; } } } } #[test] /// 同一 item 在 Row 中重复 40 次,布局需跨多个 VM 切片。 /// 完整帧不能丢失出现位置,第 40 个的 x=78 且 Mount 数量覆盖容器与全部子项。 fn layout_slices_preserve_all_shared_occurrences() { let children = std::iter::repeat_n("item", 40) .collect::>() .join(", "); let source = format!( "class Wide: Row {{\n function measure(self: Wide, mount: Mount, constraints: Constraints): MeasureResult {{ return MeasureResult(340, 60) }}\n}}\nitem = RectBlock(2, 20)\npage = Page()\npage.render(Wide(0, 0, {children}))" ); let (mut session, initial) = ReplSession::load(&source, "app.main", 269, 1).unwrap(); initial.validate().unwrap(); assert!(initial.frame.mounts.len() >= 41); assert!(source_measure_stat(&mut session, "layoutSlices") > 1); assert_eq!( session .execute("item.mounts().at(39).bounds().x", "app.main") .unwrap() .value, "78" ); } #[test] /// 有限 Row 把带换行文字的 flex Column 缩窄,文字自然高度必须重新测量,不能沿用早期宽约束下的一行高度。 /// 将文字改短后高度回到 20,确认新求解不把先前分配冻结为永久尺寸。 fn nested_flex_refreshes_natural_height_when_cross_width_changes() { let (mut session, initial) = ReplSession::load( r#" class Narrow: Row { function measure(self: Narrow, mount: Mount, constraints: Constraints): MeasureResult { return MeasureResult(240, 400) } } paragraph = TextBlock("Changing the parent's width must refresh the natural height of this wrapping paragraph. The first wide measurement must not freeze a single line of text. Changing the parent's width must refresh the natural height of this wrapping paragraph.") paragraph.flexShrink = 1 column = Column(0, 0, paragraph) column.flex = 1 page = Page() page.render(Narrow(10, 0, column)) "#, "app.main", 268, 1, ) .unwrap(); initial.validate().unwrap(); let height: f32 = session .execute("paragraph.mounts().at(0).bounds().height", "app.main") .unwrap() .value .parse() .unwrap(); assert!(height > 20.0); session .execute("paragraph.setText(\"short\")", "app.main") .unwrap(); assert_eq!( session .execute("paragraph.mounts().at(0).bounds().height", "app.main") .unwrap() .value, "20" ); } #[test] /// 给两个 flex 子项显式 basis、不同增长权重和最大宽度,检查达到上限后剩余空间再分配。 /// 随后切换为收缩并让首项触及最小值,再恢复 auto basis,验证每次新求解都重新计算自然尺寸。 fn bounded_flex_redistributes_growth_and_scaled_shrink() { let (mut session, initial) = ReplSession::load( r#" class Wide: Row { function measure(self: Wide, mount: Mount, constraints: Constraints): MeasureResult { return MeasureResult(340, 60) } } first = RectBlock(20, 20) second = RectBlock(40, 20) fixed = RectBlock(60, 20) first.flex = 1 second.flex = 3 first.flexBasis = 100 second.flexBasis = 100 first.flexMax = 105 row = Wide(10, 10, first, second, fixed) page = Page() page.render(row) "#, "app.main", 267, 1, ) .unwrap(); initial.validate().unwrap(); let width = |session: &mut ReplSession, name| { session .execute(&format!("{name}.mounts().at(0).bounds().width"), "app.main") .unwrap() .value }; assert_eq!(width(&mut session, "first"), "105"); assert_eq!(width(&mut session, "second"), "135"); session.execute( "first.flex = 0\nsecond.flex = 0\nfirst.flexMax = 300\nfirst.flexMin = 150\nfirst.flexBasis = 200\nsecond.flexBasis = 200\nfirst.flexShrink = 1\nsecond.flexShrink = 1", "app.main", ).unwrap(); assert_eq!(width(&mut session, "first"), "150"); assert_eq!(width(&mut session, "second"), "90"); assert_eq!(width(&mut session, "fixed"), "60"); session.execute( "first.flexMin = 0\nfirst.flexMax = 1000000\nfirst.flexBasis = \"auto\"\nsecond.flexBasis = \"auto\"", "app.main", ).unwrap(); assert_eq!(width(&mut session, "first"), "20"); assert_eq!(width(&mut session, "second"), "40"); } #[test] /// 同一段文字分别出现在两个 Row;首个 Row 的可伸缩兄弟权重改变会挤窄文字。 /// 只第一个出现位置的换行高度增加,第二个保持原高度,证明约束与自然尺寸缓存按 Mount 隔离。 fn native_flex_reflows_shared_text_per_occurrence() { let (mut session, initial) = ReplSession::load( r#" paragraph = TextBlock("Shared text has one object identity and separate layout constraints in each occurrence. Changing the sibling weight reflows only the affected occurrence.") paragraph.flex = 1 filler = RectBlock(20, 20) filler.flex = 1 first = Row(10, 10, paragraph, filler) second = Row(10, 10, paragraph, RectBlock(300, 20)) page = Page() page.render(Column(10, 10, first, second)) "#, "app.main", 266, 1, ) .unwrap(); initial.validate().unwrap(); let height = |session: &mut ReplSession, index| -> f32 { session .execute( &format!("paragraph.mounts().at({index}).bounds().height"), "app.main", ) .unwrap() .value .parse() .unwrap() }; let before = height(&mut session, 0); let other = height(&mut session, 1); assert!(before > other); session.execute("filler.flex = 3", "app.main").unwrap(); assert!(height(&mut session, 0) > before); assert_eq!(height(&mut session, 1), other); } #[test] /// 有限宽度 Row 先扣 padding、gap 与固定子项,再把 240 剩余宽度按 1:2 分配。 /// 修改权重为 3:1 后同一出现位置实时改为 180/60,验证分配结果反过来约束子测量。 fn weighted_flex_remeasures_children_and_updates_live_weights() { let (mut session, initial) = ReplSession::load(r#" class Wide: Row { function measure(self: Wide, mount: Mount, constraints: Constraints): MeasureResult { return MeasureResult(340, 40) } } first = RectBlock(20, 20) fixed = RectBlock(60, 20) last = RectBlock(40, 20) first.flex = 1 last.flex = 2 row = Wide(10, 10, first, fixed, last) page = Page() page.render(row) "#, "app.main", 265, 1).unwrap(); initial.validate().unwrap(); assert_eq!( session .execute("first.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "80" ); assert_eq!( session .execute("last.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "160" ); session .execute("first.flex = 3\nlast.flex = 1", "app.main") .unwrap(); assert_eq!( session .execute("first.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "180" ); assert_eq!( session .execute("last.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "60" ); } #[test] /// 表驱动切换 start/center/end/space-between,逐项比较两个子项的 x。 /// 子项宽度始终为自然宽度,mainAlign 只分配剩余间隙,不应被误当成 flex 拉伸。 fn main_alignment_updates_live_geometry_without_changing_sizes() { let (mut session, initial) = ReplSession::load(r#" class Wide: Row { function measure(self: Wide, mount: Mount, constraints: Constraints): MeasureResult { return MeasureResult(300, 60) } } first = RectBlock(20, 20) second = RectBlock(40, 40) row = Wide(10, 10, first, second) page = Page() page.render(row) "#, "app.main", 264, 1).unwrap(); initial.validate().unwrap(); for (mode, first, second) in [ ("start", "10", "40"), ("center", "115", "145"), ("end", "220", "250"), ("space-between", "10", "250"), ] { session .execute(&format!("row.mainAlign = \"{mode}\""), "app.main") .unwrap(); assert_eq!( session .execute("first.mounts().at(0).bounds().x", "app.main") .unwrap() .value, first ); assert_eq!( session .execute("second.mounts().at(0).bounds().x", "app.main") .unwrap() .value, second ); assert_eq!( session .execute("first.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "20" ); } } #[test] /// 同一 RectBlock 分别放在 Row 和 Column,以两个父容器的 crossAlign 得到独立坐标。 /// alignSelf 显式值覆盖各父策略,恢复 auto 后再次继承,且修改一个父容器不影响另一个出现位置。 fn cross_alignment_is_live_and_specific_to_each_parent_occurrence() { let (mut session, initial) = ReplSession::load(r#" class Tall: Row { function measure(self: Tall, mount: Mount, constraints: Constraints): MeasureResult { return MeasureResult(200, 100) } } class Wide: Column { function measure(self: Wide, mount: Mount, constraints: Constraints): MeasureResult { return MeasureResult(200, 100) } } shared = RectBlock(20, 20) row = Tall(10, 0, shared) column = Wide(10, 0, shared) row.crossAlign = "center" column.crossAlign = "end" page = Page() page.render(Column(0, 0, row, column)) "#, "app.main", 294, 1).unwrap(); initial.validate().unwrap(); for (expression, expected) in [ ("shared.mounts().at(0).bounds().x", "10"), ("shared.mounts().at(0).bounds().y", "40"), ("shared.mounts().at(1).bounds().x", "170"), ("shared.mounts().at(1).bounds().y", "110"), ] { assert_eq!( session.execute(expression, "app.main").unwrap().value, expected ); } session .execute("shared.alignSelf = \"start\"", "app.main") .unwrap(); assert_eq!( session .execute("shared.mounts().at(0).bounds().y", "app.main") .unwrap() .value, "10" ); assert_eq!( session .execute("shared.mounts().at(1).bounds().x", "app.main") .unwrap() .value, "10" ); session .execute( "shared.alignSelf = \"auto\"\nrow.crossAlign = \"end\"", "app.main", ) .unwrap(); assert_eq!( session .execute("shared.mounts().at(0).bounds().y", "app.main") .unwrap() .value, "70" ); assert_eq!( session .execute("shared.mounts().at(1).bounds().x", "app.main") .unwrap() .value, "170" ); } #[test] /// 源 arrange 主动把第一个子项 y 改为 7,后续原生 crossAlign 不能覆盖源给定位置。 /// 另一子项比父交叉轴更宽时按起点溢出,center 不应产生负起点。 fn cross_alignment_preserves_source_placements_and_starts_overflow() { let (mut session, initial) = ReplSession::load(r#" class Placed: Row { function arrange(self: Placed, mount: Mount, geometry: Bounds): Arrangement { result = Row.arrange(self, mount, geometry) result.children.at(0).y = 7 return result } } class Small: Column { function measure(self: Small, mount: Mount, constraints: Constraints): MeasureResult { return MeasureResult(10, 30) } } first = RectBlock(20, 20) second = RectBlock(40, 20) placed = Placed(0, 0, first) placed.crossAlign = "end" small = Small(0, 0, second) small.crossAlign = "center" page = Page() page.render(Column(0, 0, placed, small)) "#, "app.main", 295, 1).unwrap(); initial.validate().unwrap(); assert_eq!( session .execute("first.mounts().at(0).bounds().y", "app.main") .unwrap() .value, "7" ); assert_eq!( session .execute("second.mounts().at(0).bounds().x", "app.main") .unwrap() .value, "0" ); } #[test] /// 带不对称 margin 的共享子项分别参与有限 flex Row 和自然尺寸 Row。 /// 检查定位、交叉轴居中、剩余宽度与容器固有尺寸;增加右 margin 同时挤窄 flex 兄弟并扩大自然父宽度。 fn margins_participate_in_intrinsic_size_alignment_and_flex_allocation() { let (mut session, initial) = ReplSession::load(r#" class Wide: Row { function measure(self: Wide, mount: Mount, constraints: Constraints): MeasureResult { return MeasureResult(200, 100) } } first = RectBlock(20, 20) first.marginLeft = 3 first.marginRight = 7 first.marginTop = 5 first.marginBottom = 15 second = RectBlock(20, 20) second.flex = 1 row = Wide(10, 10, first, second) row.crossAlign = "center" intrinsic = Row(10, 10, first, RectBlock(30, 30)) page = Page() page.render(Column(0, 0, row, intrinsic)) "#, "app.main", 296, 1).unwrap(); initial.validate().unwrap(); for (expression, expected) in [ ("first.mounts().at(0).bounds().x", "13"), ("first.mounts().at(0).bounds().y", "35"), ("second.mounts().at(0).bounds().x", "50"), ("second.mounts().at(0).bounds().width", "140"), ("intrinsic.mounts().at(0).bounds().width", "90"), ("intrinsic.mounts().at(0).bounds().height", "60"), ] { assert_eq!( session.execute(expression, "app.main").unwrap().value, expected, "{expression}" ); } session .execute("first.marginRight = 17", "app.main") .unwrap(); assert_eq!( session .execute("second.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "130" ); assert_eq!( session .execute("intrinsic.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "100" ); } #[test] /// 在固定尺寸 Overlay 内嵌带边框/不对称 padding 的 Column,子项还有 margin。 /// 比较三层绝对坐标与边框绘制命令,再动态改变 min/max,验证对齐与内容偏移使用同一盒模型。 fn nested_overlay_uses_border_boxes_and_asymmetric_content_insets() { let (mut session, initial) = ReplSession::load( r##" child = RectBlock(20, 10) child.marginLeft = 5 child.marginTop = 4 column = Column(0, 0, child) column.boxWidth = 200 column.boxHeight = 120 column.paddingLeft = 11 column.paddingTop = 7 column.borderLeft = 3 column.borderTop = 2 column.borderColor = "#FF0000" overlay = Overlay(10, 0, column) overlay.boxWidth = 300 overlay.boxHeight = 200 overlay.mainAlign = "center" overlay.crossAlign = "end" page = Page() page.render(overlay) "##, "app.main", 297, 1, ) .unwrap(); initial.validate().unwrap(); for (expression, expected) in [ ("overlay.mounts().at(0).bounds().width", "300"), ("column.mounts().at(0).bounds().x", "50"), ("column.mounts().at(0).bounds().y", "70"), ("column.mounts().at(0).bounds().width", "200"), ("child.mounts().at(0).bounds().x", "69"), ("child.mounts().at(0).bounds().y", "83"), ] { assert_eq!( session.execute(expression, "app.main").unwrap().value, expected, "{expression}" ); } assert!(initial.frame.commands.iter().any(|command| matches!(command, RenderCommand::RoundedRect { x, y, width, height, color, .. } if *x == 50.0 && *y == 70.0 && *width == 3.0 && *height == 120.0 && color == "#FF0000"))); session .execute("column.maxWidth = 160\ncolumn.minHeight = 140", "app.main") .unwrap(); assert_eq!( session .execute("column.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "160" ); assert_eq!( session .execute("column.mounts().at(0).bounds().height", "app.main") .unwrap() .value, "140" ); } #[test] /// 文字 boxWidth=fill 在有限父宽中获得整个边框盒,真正换行宽度再扣左右 padding。 /// 另构造无界 Column 主轴上的 fill 高度,应明确拒绝无法定义的有限分配。 fn fill_wraps_text_inside_finite_column_and_rejects_unbounded_axis() { let (mut session, initial) = ReplSession::load(r#" text = TextBlock("Text wrapping follows the finite border box rather than the original unbounded column width.") text.boxWidth = "fill" text.paddingLeft = 8 text.paddingRight = 12 column = Column(0, 0, text) column.boxWidth = 160 page = Page() page.render(column) "#, "app.main", 298, 1).unwrap(); initial.validate().unwrap(); assert_eq!( session .execute("text.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "160" ); assert!(initial.frame.commands.iter().any(|command| matches!(command, RenderCommand::Text { x, wrap_bounds: Some([width, _]), .. } if *x == 8.0 && *width == 140.0))); let error = ReplSession::load( r#" rect = RectBlock(10, 10) rect.boxHeight = "fill" page = Page() page.render(Column(0, 0, rect)) "#, "app.main", 299, 1, ) .err() .expect("unbounded fill must fail"); assert!( format!("{error:#}").contains("fill requires a finite parent allocation"), "{error:#}" ); } #[test] /// 让子按钮超出带左边框且 overflow=clip 的固定 Row。 /// 子 Mount 保留原几何,但 clip 仅覆盖父内容区域;命中在原按钮矩形内也应因裁剪而失败。 fn clipping_a_box_limits_descendant_paint_and_hit_geometry() { let (_, initial) = ReplSession::load(r#" class Overflow: RectBlock { function measure(self: Overflow, mount: Mount, constraints: Constraints): MeasureResult { return MeasureResult(100, 20) } } child = Button("outside") child.boxWidth = 100 row = Row(0, 0, Overflow(100, 20), child) row.boxWidth = 60 row.boxHeight = 40 row.borderLeft = 2 row.overflow = "clip" page = Page() page.render(row) "#, "app.main", 300, 1).unwrap(); initial.validate().unwrap(); let child = initial .frame .mounts .iter() .find(|mount| mount.interactive) .unwrap(); assert_eq!(child.clip, Some([2.0, 0.0, 58.0, 40.0])); assert!(child.x >= 100.0); assert!( initial .frame .hit_test(crate::geometry::Point::new(child.x + 1.0, child.y + 1.0)) .is_none() ); } #[test] /// 两个 fill 子项分享扣去 margin/gap/固定项后的主轴空间,其中一项触及 maxWidth 后重新分配。 /// 交叉轴 stretch 仍受 maxHeight 和 alignSelf 限制;增大父宽后首项吸收新增空间。 fn main_axis_fill_shares_remaining_space_and_stretch_respects_box_limits() { let (mut session, initial) = ReplSession::load( r#" first = RectBlock(10, 10) first.boxWidth = "fill" first.marginLeft = 5 first.maxHeight = 30 second = RectBlock(10, 10) second.boxWidth = "fill" second.maxWidth = 50 fixed = RectBlock(40, 20) fixed.alignSelf = "center" row = Row(10, 5, first, second, fixed) row.boxWidth = 240 row.boxHeight = 80 row.crossAlign = "stretch" page = Page() page.render(row) "#, "app.main", 301, 1, ) .unwrap(); initial.validate().unwrap(); for (expression, expected) in [ ("first.mounts().at(0).bounds().width", "115"), ("second.mounts().at(0).bounds().width", "50"), ("first.mounts().at(0).bounds().height", "30"), ("second.mounts().at(0).bounds().height", "60"), ("fixed.mounts().at(0).bounds().y", "30"), ] { assert_eq!( session.execute(expression, "app.main").unwrap().value, expected, "{expression}" ); } session.execute("row.boxWidth = 280", "app.main").unwrap(); assert_eq!( session .execute("first.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "155" ); } #[test] /// 通过真实 VM 加载盒布局示例并验证完整文档。 /// 共享文字有两个 Mount,父盒宽度不同产生不同分配,防止示例只在说明文档中成立。 fn box_layout_example_runs_through_the_real_source_pipeline() { let (mut session, initial) = ReplSession::load( include_str!("../../../examples/box-layout.endor"), "app.main", 302, 1, ) .unwrap(); initial.validate().unwrap(); assert_eq!( session .execute("shared.mounts().count", "app.main") .unwrap() .value, "2" ); let left = session .execute("shared.mounts().at(0).bounds().width", "app.main") .unwrap() .value .parse::() .unwrap(); let right = session .execute("shared.mounts().at(1).bounds().width", "app.main") .unwrap() .value .parse::() .unwrap(); assert!(left > right); } #[test] /// 固定 Overlay 按内容高度拉伸子项,再受 margin/maxHeight 限制得到 50。 /// 改为显式 boxHeight 后使用 15,证明显式尺寸优先于 stretch,覆盖层不按线性子项重排。 fn overlay_stretch_allocates_each_occurrence_without_reflowing_its_siblings() { let (mut session, initial) = ReplSession::load( r#" child = RectBlock(20, 10) child.marginTop = 3 child.maxHeight = 50 overlay = Overlay(5, 0, child, RectBlock(10, 10)) overlay.boxWidth = 100 overlay.boxHeight = 80 overlay.crossAlign = "stretch" page = Page() page.render(overlay) "#, "app.main", 303, 1, ) .unwrap(); initial.validate().unwrap(); assert_eq!( session .execute("child.mounts().at(0).bounds().height", "app.main") .unwrap() .value, "50" ); assert_eq!( session .execute("child.mounts().at(0).bounds().y", "app.main") .unwrap() .value, "8" ); session.execute("child.boxHeight = 15", "app.main").unwrap(); assert_eq!( session .execute("child.mounts().at(0).bounds().height", "app.main") .unwrap() .value, "15" ); } #[test] /// 两个有限视口共享同一 Scene2D,默认相机独立,出现位置各有变换和裁剪。 /// 点击先经变换命中;只改首个相机不测量业务对象,显式共享 camera 后两边才同步缩放。 fn two_canvas_viewports_share_a_scene_with_independent_explicit_cameras() { let (mut session, initial) = ReplSession::load( r#" hits = ui.state(0) button = Button("shared") button.onClick(hits.increment) button.x = 40 button.y = 20 scene = Scene2D(button) first = CanvasViewport(200, 100, scene) second = CanvasViewport(200, 100, scene) first.camera.x = 20 first.camera.zoom = 2 page = Page() page.render(Row(0, 20, first, second)) "#, "app.main", 304, 1, ) .unwrap(); initial.validate().unwrap(); assert_eq!( session .execute("button.mounts().count", "app.main") .unwrap() .value, "2" ); let buttons: Vec<_> = initial .frame .mounts .iter() .filter(|mount| mount.interactive) .collect(); assert_eq!(buttons.len(), 2); assert_eq!(buttons[0].view.unwrap().zoom, 2.0); assert!(buttons[1].view.is_none()); assert_eq!(buttons[0].clip, Some([0.0, 0.0, 200.0, 100.0])); assert_eq!(buttons[1].clip, Some([220.0, 0.0, 200.0, 100.0])); let first_id = buttons[0].id; let point = [45.0, 45.0]; assert_eq!( initial .frame .hit_test(crate::geometry::Point::new(point[0], point[1])) .unwrap() .id, first_id ); session .dispatch(&crate::events::Input { window: crate::window::MAIN_WINDOW, session: initial.frame.session, layout_version: initial.frame.layout_version, mount: first_id, kind: "click".into(), point: Some(point), press_point: Some(point), delta: None, tab_drop: None, screen_position: None, }) .unwrap(); assert_eq!( session.execute("hits.value", "app.main").unwrap().value, "1" ); let changed = session .execute("first.camera.x = -40\nfirst.camera.zoom = 1", "app.main") .unwrap() .document .unwrap(); changed.validate().unwrap(); let buttons: Vec<_> = changed .frame .mounts .iter() .filter(|mount| mount.interactive) .collect(); assert_eq!(buttons[0].id, first_id); assert_eq!(buttons[0].view.unwrap().x, 40.0); assert!(buttons[1].view.is_none()); assert_eq!(source_measure_stat(&mut session, "measured"), 0); let shared = session .execute( "second.camera = first.camera\nfirst.camera.zoom = 2", "app.main", ) .unwrap() .document .unwrap(); shared.validate().unwrap(); assert!( shared .frame .mounts .iter() .filter(|mount| mount.interactive) .all(|mount| mount.view.is_some_and(|view| view.zoom == 2.0)) ); } #[test] /// 嵌套二维相机的缩放相乘、平移复合,检查最终变换和相交裁剪。 /// 手势只驱动内层相机,外层不动;最后软件绘制采样确认固定 HUD 与变换后内容均位于预期像素。 fn nested_canvas_projects_pixels_and_hits_while_overlay_ui_stays_fixed() { let (mut session, initial) = ReplSession::load( r##" button = Button("nested") button.boxWidth = 20 button.boxHeight = 20 button.x = 10 button.y = 10 inner = CanvasViewport(80, 60, Scene2D(button)) inner.camera.zoom = 0.5 inner.x = 20 inner.y = 20 outer = CanvasViewport(200, 200, Scene2D(inner)) outer.camera.zoom = 2 hud = RectBlock(10, 10, 0, "#0000FF") page = Page() page.render(Overlay(0, 0, outer, hud)) "##, "app.main", 305, 1, ) .unwrap(); initial.validate().unwrap(); let button = initial .frame .mounts .iter() .find(|mount| mount.interactive) .unwrap(); assert_eq!( button.view.unwrap(), crate::viewport::Transform { zoom: 1.0, x: 20.0, y: 20.0 } ); assert_eq!(button.clip, Some([40.0, 40.0, 160.0, 120.0])); let point = crate::geometry::Point::new(55.0, 55.0); assert_eq!(initial.frame.hit_test(point).unwrap().id, button.id); let inner_id = initial.frame.camera_at(point).unwrap().id; let input = crate::events::Input { window: 1, session: initial.frame.session, layout_version: initial.frame.layout_version, mount: inner_id, kind: "viewport-pan".into(), delta: Some([10.0, 0.0]), point: None, press_point: None, tab_drop: None, screen_position: None, }; session.dispatch(&input).unwrap(); assert_eq!( session.execute("inner.camera.x", "app.main").unwrap().value, "10" ); assert_eq!( session.execute("outer.camera.x", "app.main").unwrap().value, "0" ); let document = session .execute("hud.invalidate(\"paint\")", "app.main") .unwrap() .document .unwrap(); let mut pixels = vec![0; 200 * 200]; crate::software_renderer::SoftwareRenderer::render( &document.display_list(1.0).unwrap(), &mut pixels, 200, 200, ) .unwrap(); assert_eq!(pixels[5 * 200 + 5], 0x0000FF); assert_ne!(pixels[55 * 200 + 45], pixels[190 * 200 + 190]); } #[test] /// 在负世界 x 处放红矩形,经相机平移和二倍缩放映射到有限视口。 /// 实际像素需显示固定蓝色覆盖层、可见红块和视口外背景,检验命令投影与裁剪最终进入光栅化。 fn canvas_world_paint_is_zoomed_and_clipped_in_the_software_renderer() { let (_, initial) = ReplSession::load( r##" rect = RectBlock(20, 20, 0, "#FF0000") rect.x = -10 rect.y = 10 view = CanvasViewport(50, 50, Scene2D(rect)) view.camera.x = -10 view.camera.zoom = 2 page = Page() page.render(Overlay(0, 0, view, RectBlock(10, 10, 0, "#0000FF"))) "##, "app.main", 306, 1, ) .unwrap(); initial.validate().unwrap(); let mut pixels = vec![0; 80 * 80]; crate::software_renderer::SoftwareRenderer::render( &initial.display_list(1.0).unwrap(), &mut pixels, 80, 80, ) .unwrap(); assert_eq!(pixels[5 * 80 + 5], 0x0000FF); assert_eq!(pixels[25 * 80 + 5], 0xFF0000); assert_eq!(pixels[55 * 80 + 5], pixels[79 * 80 + 79]); assert_eq!(pixels[25 * 80 + 45], pixels[79 * 80 + 79]); } #[test] /// 加载场景视口示例并确认共享按钮出现两次。 /// 再实际构造 ScrollView,检查它保持 ScrollBlock 名义类型兼容,而非只在文本说明中存在的别名。 fn scene_viewport_example_and_scroll_view_alias_run_as_real_source() { let (mut session, initial) = ReplSession::load( include_str!("../../../examples/scene-viewports.endor"), "app.main", 307, 1, ) .unwrap(); initial.validate().unwrap(); assert_eq!( session .execute("increment.mounts().count", "app.main") .unwrap() .value, "2" ); session .execute( "testScroll = ScrollView(100, 60, Row(0, 0, TextBlock(\"scroll\")))", "app.main", ) .unwrap(); assert_eq!( session .execute("ui.isInstance(testScroll, ScrollBlock)", "app.main") .unwrap() .value, "true" ); } #[test] /// 场景内容在负坐标,按当前 Mount 的有限尺寸 fitView。 /// 比较相机 zoom/pan 与矩形投影后的 48px 留白,验证适配的是场景边界而非业务对象原始正坐标假设。 fn fit_view_uses_finite_scene_bounds_and_this_mounts_size() { let (mut session, initial) = ReplSession::load( r#" rect = RectBlock(100, 50) rect.x = -100 rect.y = -25 view = CanvasViewport(296, 196, Scene2D(rect)) page = Page() page.render(view) "#, "app.main", 308, 1, ) .unwrap(); initial.validate().unwrap(); let document = session .execute("view.mounts().at(0).fitView()", "app.main") .unwrap() .document .unwrap(); document.validate().unwrap(); for (expression, expected) in [ ("view.camera.zoom", "2"), ("view.camera.x", "-124"), ("view.camera.y", "-49"), ] { assert_eq!( session.execute(expression, "app.main").unwrap().value, expected ); } let rect = document .frame .mounts .iter() .find(|mount| mount.width == 100.0 && mount.height == 50.0) .unwrap(); let screen = rect .view .unwrap() .point(crate::geometry::Point::new(rect.x, rect.y)); assert_eq!(screen, crate::geometry::Point::new(48.0, 48.0)); } #[test] /// 同一场景用透视和正交相机各显示一次,前景蓝盒应遮住后景红盒。 /// 比较拾取距离、交点和实际中心像素;移动前景并只修改透视相机后,两视图露出后景且相机 z 保持独立。 fn real_scene3d_renders_depth_with_independent_perspective_and_orthographic_cameras() { let (mut session, initial) = ReplSession::load( r##" back = Box3D(2, 2, 2, "#FF0000") front = Box3D(1, 1, 1, "#0000FF") front.z = 1.5 scene = Scene3D(front, back) scene.ambient = 1 perspective = Viewport3D(120, 100, scene) orthographic = Viewport3D(120, 100, scene) orthographic.camera = OrthographicCamera() orthographic.camera.height = 4 page = Page() page.render(Row(0, 10, perspective, orthographic)) "##, "app.main", 309, 1, ) .unwrap(); initial.validate().unwrap(); let commands: Vec<_> = initial .frame .commands .iter() .filter_map(|command| { if let RenderCommand::Scene3D { view, .. } = command { Some(view) } else { None } }) .collect(); assert_eq!(commands.len(), 2); let hit = commands[0].pick(0.5, 0.5, 1.2).unwrap(); assert!((hit.distance - 3.0).abs() < 1e-5); assert_eq!(hit.point, crate::scene3d::math::Vec3::new(0., 0., 2.)); assert!(matches!( commands[1].camera.projection, crate::scene3d::math::Projection::Orthographic { height: 4.0 } )); let mut pixels = vec![0; 250 * 100]; crate::software_renderer::SoftwareRenderer::render( &initial.display_list(1.).unwrap(), &mut pixels, 250, 100, ) .unwrap(); assert_eq!(pixels[50 * 250 + 60], 0x0000FF); assert_eq!(pixels[50 * 250 + 190], 0x0000FF); let updated = session .execute("front.x=10\nperspective.camera.z=8", "app.main") .unwrap() .document .unwrap(); updated.validate().unwrap(); let cameras: Vec<_> = updated .frame .commands .iter() .filter_map(|command| { if let RenderCommand::Scene3D { view, .. } = command { Some(view.camera.position.z) } else { None } }) .collect(); assert_eq!(cameras, vec![8., 5.]); crate::software_renderer::SoftwareRenderer::render( &updated.display_list(1.).unwrap(), &mut pixels, 250, 100, ) .unwrap(); assert_eq!(pixels[50 * 250 + 60], 0xFF0000); assert_eq!(pixels[50 * 250 + 190], 0xFF0000); } #[test] /// 先通过 Mount.pick3D 查询中心交点与真实 mesh 材质,再从原生输入派发同位置 click。 /// 回调写 event.hit.mesh.color 后业务对象及最终像素都变绿,证明拾取结果保留正确托管业务身份。 fn ray_pick_returns_managed_mesh_and_native_pointer_event_updates_its_material() { let (mut session, initial) = ReplSession::load( r##" class Actions { function select(self: Actions, event: Event): Unit { event.hit.mesh.color = "#00FF00" } } mesh = Box3D(2,2,2,"#FF0000") scene = Scene3D(mesh) scene.ambient = 1 view = Viewport3D(100,100,scene) actions = Actions() view.onClick(actions.select) page = Page() page.render(view) "##, "app.main", 310, 1, ) .unwrap(); initial.validate().unwrap(); assert_eq!( session .execute("view.mounts().at(0).pick3D(50,50).point.z", "app.main") .unwrap() .value, "1" ); assert_eq!( session .execute("view.mounts().at(0).pick3D(50,50).mesh.color", "app.main") .unwrap() .value, "\"#FF0000\"" ); let frame = session .execute("view.invalidate(\"paint\")", "app.main") .unwrap() .document .unwrap() .frame; let mount = frame .mounts .iter() .find(|mount| mount.scene3d_viewport) .unwrap(); let updated = session .dispatch(&crate::events::Input { window: 1, session: frame.session, layout_version: frame.layout_version, mount: mount.id, kind: "click".into(), point: Some([50., 50.]), press_point: Some([50., 50.]), delta: None, tab_drop: None, screen_position: None, }) .unwrap() .document .unwrap(); assert_eq!( session.execute("mesh.color", "app.main").unwrap().value, "\"#00FF00\"" ); let mut pixels = vec![0; 100 * 100]; crate::software_renderer::SoftwareRenderer::render( &updated.display_list(1.).unwrap(), &mut pixels, 100, 100, ) .unwrap(); assert_eq!(pixels[50 * 100 + 50], 0x00FF00); } #[test] /// 运行内置三维示例及其旋转动作,再替换为源构造的自定义三角网格。 /// 另检查 Group3D 自循环和越界三角索引的明确错误,非法场景不能进入发布。 fn scene3d_example_custom_geometry_and_cycle_diagnostics_use_real_source() { let (mut session, document) = ReplSession::load( include_str!("../../../examples/scene3d.endor"), "app.main", 311, 1, ) .unwrap(); document.validate().unwrap(); session.execute("actions.rotate()", "app.main").unwrap(); assert_eq!( session.execute("cube.rotationY", "app.main").unwrap().value, "40" ); session.execute(r##" geometry=Geometry3D(ObjectList(Vec3(-1,-1,0),Vec3(1,-1,0),Vec3(0,1,0)),ObjectList(Triangle3D(0,1,2))) custom=Mesh3D(geometry,"#112233") scene.children=ObjectList(custom) "##,"app.main").unwrap().document.unwrap().validate().unwrap(); let error = ReplSession::load( r##" group=Group3D() scene=Scene3D(group) group.children=ObjectList(group) page=Page() page.render(Viewport3D(100,100,scene)) "##, "app.main", 312, 1, ) .err() .unwrap(); assert!( format!("{error:#}").contains("cyclic 3D scene graph"), "{error:#}" ); let error = ReplSession::load( r##" geometry=Geometry3D(ObjectList(Vec3(0,0,0)),ObjectList(Triangle3D(0,1,2))) "##, "app.main", 313, 1, ) .err() .unwrap(); assert!( format!("{error:#}").contains("invalid Geometry3D buffers"), "{error:#}" ); } #[test] /// 旋转 Panel3D 的 UI 以独立 100x100 分辨率布局,检查 toView/toLocal、射线命中和纹理像素。 /// 点击及源 paint 字段修改保持响应;加入前景实体后同一点只命中外层三维视口,UI 不可穿透遮挡。 fn world_ui_panel_renders_live_endor_and_ray_hits_respect_mesh_occlusion() { let (mut session, initial) = ReplSession::load( r##" class Tile: Button { tint: String function paint(self: Tile, mount: Mount, geometry: Bounds): DisplayList { fill=PaintCommand() fill.kind="roundedRect" fill.x=geometry.x fill.y=geometry.y fill.width=geometry.width fill.height=geometry.height fill.radius=0 fill.color=self.tint return DisplayList(ObjectList(fill)) } } count=ui.state(0) button=Tile("world UI","#FF0000") button.onClick(count.increment) panel=Panel3D(2,2,button) panel.uiWidth=100 panel.uiHeight=100 panel.rotationY=25 scene=Scene3D(panel) scene.ambient=1 view=Viewport3D(200,200,scene) page=Page() page.render(view) "##, "app.main", 314, 1, ) .unwrap(); initial.validate().unwrap(); let button = initial .frame .mounts .iter() .find(|mount| mount.interactive && mount.panel.is_some()) .unwrap(); assert_eq!((button.width, button.height), (100., 100.)); let point = button .panel .as_ref() .unwrap() .project_point(crate::geometry::Point::new(50., 50.)) .unwrap(); assert!((point.x - 100.).abs() < 0.001 && (point.y - 100.).abs() < 0.001); assert_eq!(initial.frame.hit_test(point).unwrap().id, button.id); assert_eq!( session .execute("button.mounts().at(0).toView(50,50).x", "app.main") .unwrap() .value, "100" ); let local = session .execute("button.mounts().at(0).toLocal(100,100).x", "app.main") .unwrap() .value .parse::() .unwrap(); assert!((local - 50.).abs() < 0.001); let mut pixels = vec![0; 200 * 200]; crate::software_renderer::SoftwareRenderer::render( &initial.display_list(1.).unwrap(), &mut pixels, 200, 200, ) .unwrap(); assert_eq!(pixels[100 * 200 + 100], 0xFF0000); let latest = session .execute("button.invalidate(\"paint\")", "app.main") .unwrap() .document .unwrap(); let input = crate::events::Input { window: 1, session: latest.frame.session, layout_version: latest.frame.layout_version, mount: button.id, kind: "click".into(), point: Some([point.x, point.y]), press_point: Some([point.x, point.y]), delta: None, tab_drop: None, screen_position: None, }; session.dispatch(&input).unwrap(); assert_eq!( session.execute("count.value", "app.main").unwrap().value, "1" ); let updated = session .execute("button.tint=\"#00FF00\"", "app.main") .unwrap() .document .unwrap(); updated.validate().unwrap(); crate::software_renderer::SoftwareRenderer::render( &updated.display_list(1.).unwrap(), &mut pixels, 200, 200, ) .unwrap(); assert_eq!(pixels[100 * 200 + 100], 0x00FF00); let blocked = session .execute( r##" blocker=Box3D(1.2,1.2,1.2,"#0000FF") blocker.z=1.5 scene.children=ObjectList(panel,blocker) "##, "app.main", ) .unwrap() .document .unwrap(); blocked.validate().unwrap(); let button = blocked .frame .mounts .iter() .find(|mount| mount.panel.is_some() && mount.interactive) .unwrap(); assert!(!button.contains(point)); assert!(blocked.frame.hit_test(point).unwrap().scene3d_viewport); crate::software_renderer::SoftwareRenderer::render( &blocked.display_list(1.).unwrap(), &mut pixels, 200, 200, ) .unwrap(); assert_eq!(pixels[100 * 200 + 100], 0x0000FF); } #[test] /// 把可交互的内层 Viewport3D 作为旋转世界面板的 UI 内容。 /// 中心点 camera_at/hit_test 必须找到内层视口,click 的 hit.mesh 更新内层立方体并通过两层表面呈现绿像素。 fn nested_world_ui_can_embed_another_3d_viewport_and_preserve_ray_dispatch() { let (mut session, initial) = ReplSession::load( r##" class Actions { function select(self: Actions,event: Event): Unit { event.hit.mesh.color="#00FF00" } } cube=Box3D(2,2,2,"#0000FF") inner_scene=Scene3D(cube) inner_scene.ambient=1 inner=Viewport3D(100,100,inner_scene) actions=Actions() inner.onClick(actions.select) panel=Panel3D(2,2,inner) panel.uiWidth=100 panel.uiHeight=100 panel.rotationY=20 outer=Viewport3D(200,200,Scene3D(panel)) page=Page() page.render(outer) "##, "app.main", 315, 1, ) .unwrap(); initial.validate().unwrap(); let inner = initial .frame .mounts .iter() .find(|mount| mount.scene3d_viewport && mount.panel.is_some()) .unwrap(); let point = crate::geometry::Point::new(100., 100.); assert_eq!(initial.frame.camera_at(point).unwrap().id, inner.id); assert_eq!(initial.frame.hit_test(point).unwrap().id, inner.id); let mut pixels = vec![0; 200 * 200]; crate::software_renderer::SoftwareRenderer::render( &initial.display_list(1.).unwrap(), &mut pixels, 200, 200, ) .unwrap(); assert_eq!(pixels[100 * 200 + 100], 0x0000FF); let updated = session .dispatch(&crate::events::Input { window: 1, session: initial.frame.session, layout_version: initial.frame.layout_version, mount: inner.id, kind: "click".into(), point: Some([100., 100.]), press_point: Some([100., 100.]), delta: None, tab_drop: None, screen_position: None, }) .unwrap() .document .unwrap(); updated.validate().unwrap(); crate::software_renderer::SoftwareRenderer::render( &updated.display_list(1.).unwrap(), &mut pixels, 200, 200, ) .unwrap(); assert_eq!(pixels[100 * 200 + 100], 0x00FF00); } #[test] /// 先让 Panel.content 指回包含自身的视口,检查跨 UI/场景组合循环。 /// 再构造九层合法无环嵌套,检查超过八层表面预算的诊断;两种边界分别验证,避免把深度错误混同循环。 fn world_ui_cycles_and_surface_nesting_are_rejected_before_publication() { let error = ReplSession::load( r##" panel=Panel3D(2,2,Button("cycle")) view=Viewport3D(200,200,Scene3D(panel)) panel.content=view page=Page() page.render(view) "##, "app.main", 316, 1, ) .err() .unwrap(); assert!( format!("{error:#}").contains("cyclic Block composition"), "{error:#}" ); let mut source = String::from("seed=Button(\"deep\")\n"); for index in 0..9 { let child = if index == 0 { "seed".to_string() } else { format!("view{}", index - 1) }; source.push_str(&format!("panel{index}=Panel3D(2,2,{child})\npanel{index}.uiWidth=100\npanel{index}.uiHeight=100\nview{index}=Viewport3D(100,100,Scene3D(panel{index}))\n")); } source.push_str("page=Page()\npage.render(view8)\n"); let error = ReplSession::load(&source, "app.main", 317, 1) .err() .unwrap(); assert!( format!("{error:#}").contains("3D UI viewport nesting exceeds 8"), "{error:#}" ); } #[test] /// 同一按钮被两个世界面板共享,两个面板指定不同 UI 分辨率。 /// 两个 Mount 的宽高分别服从各自纹理,投影中心位置及命中 ID 也独立,最终整帧仍可软件绘制。 fn one_ui_object_has_independent_mounts_and_texture_sizes_in_two_world_panels() { let (mut session, initial) = ReplSession::load( r##" shared=Button("shared UI") left=Panel3D(2,2,shared) left.x=-1.2 left.uiWidth=100 left.uiHeight=80 right=Panel3D(2,2,shared) right.x=1.2 right.uiWidth=200 right.uiHeight=120 view=Viewport3D(400,240,Scene3D(left,right)) view.camera.z=6 page=Page() page.render(view) "##, "app.main", 318, 1, ) .unwrap(); initial.validate().unwrap(); assert_eq!( session .execute("shared.mounts().count", "app.main") .unwrap() .value, "2" ); assert_eq!( session .execute("shared.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "100" ); assert_eq!( session .execute("shared.mounts().at(1).bounds().width", "app.main") .unwrap() .value, "200" ); assert_eq!( session .execute("shared.mounts().at(0).bounds().height", "app.main") .unwrap() .value, "80" ); assert_eq!( session .execute("shared.mounts().at(1).bounds().height", "app.main") .unwrap() .value, "120" ); let mounts: Vec<_> = initial .frame .mounts .iter() .filter(|mount| mount.panel.is_some() && mount.interactive) .collect(); let first = mounts[0] .panel .as_ref() .unwrap() .project_point(crate::geometry::Point::new(50., 40.)) .unwrap(); let second = mounts[1] .panel .as_ref() .unwrap() .project_point(crate::geometry::Point::new(100., 60.)) .unwrap(); assert!(first.x < second.x); assert_eq!(initial.frame.hit_test(first).unwrap().id, mounts[0].id); assert_eq!(initial.frame.hit_test(second).unwrap().id, mounts[1].id); let mut pixels = vec![0; 400 * 240]; crate::software_renderer::SoftwareRenderer::render( &initial.display_list(1.).unwrap(), &mut pixels, 400, 240, ) .unwrap(); } #[test] /// 以实际有限窗口约束加载世界 UI 示例,重复相同视口/任务轮询应保持空闲。 /// 检查面板内二维视口确实存在,执行 turn/fit/reset 并比较业务相机值,最后尝试完整光栅化。 fn world_ui_example_runs_with_window_constraints_and_programmable_actions() { let (mut session, document) = ReplSession::load_with_viewport( include_str!("../../../examples/world-ui.endor"), "app.main", 319, 1, Some(crate::layout::Size { width: 1024., height: 800., }), ) .unwrap(); document.validate().unwrap(); let viewports = std::collections::BTreeMap::from([( crate::window::MAIN_WINDOW, crate::layout::Size { width: 1024., height: 800., }, )]); for _ in 0..3 { assert!( session .resize_windows_incremental(&viewports, true) .unwrap() .is_none(), "unchanged viewport must stay idle" ); assert!( session .poll_tasks_incremental(&viewports) .unwrap() .is_none() ); } assert!( document .frame .mounts .iter() .any(|mount| mount.panel.is_some() && mount.canvas_viewport) ); session .execute("actions.turn()\nactions.fit()\nactions.reset()", "app.main") .unwrap() .document .unwrap() .validate() .unwrap(); assert_eq!( session .execute("panel.rotationY", "app.main") .unwrap() .value, "30" ); assert_eq!( session.execute("view.camera.z", "app.main").unwrap().value, "7" ); let mut pixels = vec![0; 1024 * 800]; crate::software_renderer::SoftwareRenderer::render( &document.display_list(1.).unwrap(), &mut pixels, 1024, 800, ) .unwrap(); } #[test] /// 同一段落进入纵向/横向滚动容器,禁止轴的最大范围与偏移必须为 0。 /// 允许轴保留请求偏移,文字约束按滚动轴不同而独立换行;改策略后原横向偏移应立即清零。 fn scroll_axes_wrap_shared_text_and_clamp_only_the_enabled_offsets() { let (mut session, initial) = ReplSession::load( include_str!("../../../examples/scroll-axis.endor"), "app.main", 260, 1, ) .unwrap(); initial.validate().unwrap(); for expression in [ "vertical.mounts().at(0).scrollPosition().maxX", "horizontal.mounts().at(0).scrollPosition().maxY", ] { assert_eq!(session.execute(expression, "app.main").unwrap().value, "0"); } session .execute( "vertical.mounts().at(0).scrollTo(100, 60)\nhorizontal.mounts().at(0).scrollTo(60, 100)", "app.main", ) .unwrap(); for (expression, expected) in [ ("vertical.mounts().at(0).scrollPosition().x", "0"), ("vertical.mounts().at(0).scrollPosition().y", "60"), ("horizontal.mounts().at(0).scrollPosition().x", "60"), ("horizontal.mounts().at(0).scrollPosition().y", "0"), ] { assert_eq!( session.execute(expression, "app.main").unwrap().value, expected ); } let vertical_width: f32 = session .execute("paragraph.mounts().at(0).bounds().width", "app.main") .unwrap() .value .parse() .unwrap(); let horizontal_width: f32 = session .execute("paragraph.mounts().at(1).bounds().width", "app.main") .unwrap() .value .parse() .unwrap(); assert!(vertical_width <= 244.0); assert!(horizontal_width > vertical_width); session .execute("horizontal.axis = \"vertical\"", "app.main") .unwrap(); assert_eq!( session .execute("horizontal.mounts().at(0).scrollPosition().x", "app.main") .unwrap() .value, "0" ); } #[test] /// 未指定 axis 的 ScrollBlock 默认为 both。 /// 把已挂载容器策略写为 diagonal 必须给出允许集合诊断,不能默认为某个方向。 fn scroll_axis_defaults_to_both_and_rejects_unknown_policy() { let mut session = ReplSession::new(262).unwrap(); session .execute( "scroller = ScrollBlock(20, 10, TextBlock(\"default\"))", "app.main", ) .unwrap(); assert_eq!( session.execute("scroller.axis", "app.main").unwrap().value, "\"both\"" ); let error = ReplSession::load( r#" scroller = ScrollBlock(20, 10, TextBlock("bad")) scroller.axis = "diagonal" page = Page() page.render(scroller) "#, "app.main", 263, 1, ) .err() .expect("invalid axis"); assert!( error .to_string() .contains("ScrollBlock.axis expects both, vertical or horizontal"), "{error:#}" ); } #[test] /// 源 arrange 把构造宽度 300 的纵向 scroller 改分配为 120。 /// 文字实际宽度需扣两侧 padding 得到至多 100,横向滚动范围为零,不能继续按构造参数测量。 fn scroll_axis_uses_source_allocated_viewport_instead_of_constructor_width() { let source = r#" class Allocator: Column { function arrange(self: Allocator, mount: Mount, geometry: Bounds): Arrangement { result = Column.arrange(self, mount, geometry) result.children.at(0).width = 120 return result } } text = TextBlock("This text must wrap inside the allocated viewport, not the original constructor width. This text must wrap inside the allocated viewport.") scroller = ScrollBlock(300, 80, text) scroller.padding = 10 scroller.axis = "vertical" page = Page() page.render(Allocator(0, 0, scroller)) "#; let (mut session, initial) = ReplSession::load(source, "app.main", 261, 1).unwrap(); initial.validate().unwrap(); assert_eq!( session .execute("scroller.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "120" ); let width: f32 = session .execute("text.mounts().at(0).bounds().width", "app.main") .unwrap() .value .parse() .unwrap(); assert!(width <= 100.0); assert_eq!( session .execute("scroller.mounts().at(0).scrollPosition().maxX", "app.main") .unwrap() .value, "0" ); } #[test] /// 嵌套两个 ScrollBlock,并让其中部分内容使用源 paint。 /// 对末尾按钮 scrollIntoView 要联动内外偏移 128/148;绘制 clip 与新命中几何必须使用同一滚动投影。 fn nested_scroll_into_view_and_source_paint_share_clipped_geometry() { let mut session = ReplSession::new(241).unwrap(); let result = session .execute( r#" class Painted: RectBlock { function paint(self: Painted, mount: Mount, geometry: Bounds): DisplayList { return RectBlock.paint(self,mount,geometry) } } last = Button("last") inner = ScrollBlock(160,100,Column(0,8,Painted(200,180),last)) outer = ScrollBlock(180,140,Column(0,8,RectBlock(180,180),inner)) page = Page() page.render(outer) "#, "app.main", ) .unwrap() .document .unwrap(); assert!(result.frame.command_clips.iter().any(Option::is_some)); session .execute("last.mounts().at(0).scrollIntoView()", "app.main") .unwrap(); assert_eq!( session .execute("inner.mounts().at(0).scrollPosition().y", "app.main") .unwrap() .value, "128" ); assert_eq!( session .execute("outer.mounts().at(0).scrollPosition().y", "app.main") .unwrap() .value, "148" ); assert_eq!( session .execute("last.mounts().at(0).hitTest(10,110)", "app.main") .unwrap() .value, "true" ); } #[test] /// 直接调用 Button.click 得到名义 Event,dispatch 显式事件后返回值应与输入为同一托管对象。 /// 通过底层 globals 值比较身份,避免仅比较 repr 造成不同对象也通过。 fn click_and_dispatch_return_the_actual_delivered_event() { let mut session = ReplSession::new(237).unwrap(); session .execute( r#"button = Button("event") clicked = button.click() dispatched = Event("click") returned = button.dispatch(dispatched)"#, "app.main", ) .unwrap(); assert_eq!( session .execute("ui.isInstance(clicked, Event)", "app.main") .unwrap() .value, "true" ); assert_eq!( session.execute("clicked.kind", "app.main").unwrap().value, "\"click\"" ); let globals = session.candidate.globals.unwrap(); assert_eq!( session .candidate .vm .dict_get(globals, &Value::Text("returned".into())) .unwrap(), session .candidate .vm .dict_get(globals, &Value::Text("dispatched".into())) .unwrap() ); } #[derive(Debug)] /// 测试用原生转发器:保留公开签名,要求 VM 继续调用 target,用于模拟相同函数身份下实现变化。 struct VisualRedirect { target: ObjectRef, signature: endor_core::CallSignature, } impl endor_core::NativeCallable for VisualRedirect { /// 返回原方法签名副本,使转发器仍参与同一参数/返回/副作用契约验证。 fn signature(&self) -> Option { Some(self.signature.clone()) } /// 不直接递归执行 target;返回 Invoke 请求,由 VM 在其正常调用栈/预算中处理参数和结果。 fn invoke( &self, _: &mut endor_core::NativeContext<'_>, arguments: &[Value], ) -> std::result::Result { Ok(endor_core::NativeResult::Invoke { function: self.target, arguments: arguments.to_vec(), }) } } #[test] /// 从同一 desktop 的第二窗口查到 Block.measure,检查原生快速路径认的是方法与注册表组合。 /// 同函数换成 paint 名称或外来 types 表都不能被认作 intrinsic,避免只凭对象形状或方法名跳过源执行。 fn native_visual_identity_accepts_shared_window_registries_only() { let mut session = ReplSession::new(238).unwrap(); session.execute("second = Window()", "app.main").unwrap(); let globals = session.candidate.globals.unwrap(); let Value::Object(window) = session .candidate .vm .dict_get(globals, &Value::Text("second".into())) .unwrap() .unwrap() else { panic!("window") }; let vm = &mut session.candidate.vm; let desktop = vm .payload::(window, "Window") .unwrap() .desktop; let block = crate::ui_bridge::desktop_type(vm.object_store(), "Block", desktop).unwrap(); let function = vm .object_store() .lookup_method(block, "measure") .unwrap() .unwrap(); assert!( crate::native_visual::is_intrinsic(vm.object_store(), function, "measure", desktop) .unwrap() ); assert!( !crate::native_visual::is_intrinsic(vm.object_store(), function, "paint", desktop).unwrap() ); let foreign = vm.new_object().unwrap(); let registry = vm.new_dict().unwrap(); vm.set_attr(foreign, "types", Value::Object(registry)) .unwrap(); assert!( !crate::native_visual::is_intrinsic(vm.object_store(), function, "measure", foreign) .unwrap() ); vm.release(foreign).unwrap(); vm.release(registry).unwrap(); } #[test] /// 替换 Block.measure 为源方法后既有实例应按新方法得到宽度 140。 /// 再保持原 paint 对象身份、只替换 native payload 为转发器,刷新也必须识别实现改变并产生空命令。 fn replacing_base_visual_methods_changes_layout_and_same_identity_paint() { let (mut session, _) = ReplSession::load(r#" class Hooks { function measure(self: Object, mount: Mount, constraints: Constraints): MeasureResult { return MeasureResult(140, 70) } function paint(self: Object, mount: Mount, geometry: Bounds): DisplayList { return DisplayList(ObjectList()) } } base = Block rect = RectBlock(20, 10) page = Page() page.render(rect) "#, "app.main", 235, 1).unwrap(); let globals = session.candidate.globals.unwrap(); let get = |name: &str| match session .candidate .vm .dict_get(globals, &Value::Text(name.into())) .unwrap() .unwrap() { Value::Object(value) => value, _ => panic!("object"), }; let base = get("base"); let hooks = get("Hooks"); let Value::Object(measure) = session.candidate.vm.get_attr(hooks, "measure").unwrap() else { panic!("measure") }; let Value::Object(paint) = session.candidate.vm.get_attr(hooks, "paint").unwrap() else { panic!("paint") }; session .candidate .vm .define_method(base, "measure", measure) .unwrap(); session.refresh_document().unwrap().unwrap(); assert_eq!( session .execute("rect.mounts().at(0).bounds().width", "app.main") .unwrap() .value, "140" ); let original = session .candidate .vm .object_store() .lookup_method(base, "paint") .unwrap() .unwrap(); let signature = session .candidate .vm .object_store() .native_signature(original) .unwrap() .unwrap(); session .candidate .vm .replace_payload( original, endor_core::ContextNativeFunction::new( "redirect paint", VisualRedirect { target: paint, signature, }, vec![paint], ), ) .unwrap(); let updated = session.refresh_document().unwrap().unwrap(); assert!(updated.frame.commands.is_empty()); } #[test] /// 保持 Block.onEvent 的函数句柄不变,替换为有副作用的转发 payload。 /// 通过 VM changes 使 RenderCache 失效后 rect 从不交互变为交互,protocol_key 也应变化,证明缓存追踪实现版本。 fn same_identity_event_payload_changes_invalidate_interactivity_cache() { let mut session = ReplSession::new(236).unwrap(); session .execute( r#" class Hooks { function onEvent(self: Object, event: Event): Unit {} } base = Block rect = RectBlock(20, 10) "#, "app.main", ) .unwrap(); let globals = session.candidate.globals.unwrap(); let get = |name: &str| match session .candidate .vm .dict_get(globals, &Value::Text(name.into())) .unwrap() .unwrap() { Value::Object(value) => value, _ => panic!("object"), }; let base = get("base"); let hooks = get("Hooks"); let rect = get("rect"); let Value::Object(target) = session.candidate.vm.get_attr(hooks, "onEvent").unwrap() else { panic!("onEvent") }; let vm = &mut session.candidate.vm; let function = vm .object_store() .lookup_method(base, "onEvent") .unwrap() .unwrap(); let mut signature = vm .object_store() .native_signature(function) .unwrap() .unwrap(); signature.effect = endor_core::CallEffect::Mutating; let mut cache = crate::snapshot::RenderCache::default(); let initial = cache.snapshot(vm.object_store(), rect).unwrap(); assert!(!initial.interactive); vm.take_changes(); vm.replace_payload( function, endor_core::ContextNativeFunction::new( "redirect event", VisualRedirect { target, signature }, vec![target], ), ) .unwrap(); cache.invalidate(vm.take_changes()); let updated = cache.snapshot(vm.object_store(), rect).unwrap(); assert!(updated.interactive); assert_ne!(initial.protocol_key, updated.protocol_key); assert_eq!( session .execute("ui.implements(base, EventTarget)", "app.main") .unwrap() .value, "true" ); } #[test] /// 查询简单、转发、递归、动态回调和有副作用函数的静态 call_effect。 /// 绑定方法可借助接收者识别只读性,未绑定方法保守未知;重绑被调用全局函数后结果应失效,marker 始终为 0 证明查询未执行源码。 fn source_effect_queries_use_compiled_instructions_without_running_functions() { let mut session = ReplSession::new(234).unwrap(); session .execute( r#" function simple(value: Number): Number { return value } function forward(value: Number): Number { return simple(value) } function unknown(callback: Function): Object { return callback() } function recursive(value: Number): Number { return recursive(value) } marker = ui.state(0) function impure(value: Number): Number { marker.increment() return value } original = simple class ReadOnlyModel { function helper(self: ReadOnlyModel, value: Number): Number { return value } function check(self: ReadOnlyModel, value: Number): Number { return self.helper(value) } } model = ReadOnlyModel() "#, "app.main", ) .unwrap(); let globals = session.candidate.globals.unwrap(); for (name, expected) in [ ("simple", Some(endor_core::CallEffect::ReadOnly)), ("forward", Some(endor_core::CallEffect::ReadOnly)), ("recursive", Some(endor_core::CallEffect::ReadOnly)), ("unknown", None), ("impure", None), ] { let Value::Object(function) = session .candidate .vm .dict_get(globals, &Value::Text(name.into())) .unwrap() .unwrap() else { panic!("function") }; assert_eq!( session .candidate .vm .object_store() .call_effect(function) .unwrap(), expected ); } let Value::Object(model) = session .candidate .vm .dict_get(globals, &Value::Text("model".into())) .unwrap() .unwrap() else { panic!("model") }; let Value::Object(bound) = session.candidate.vm.bind_attr(model, "check").unwrap() else { panic!("bound") }; assert_eq!( session .candidate .vm .object_store() .call_effect(bound) .unwrap(), Some(endor_core::CallEffect::ReadOnly) ); session.candidate.vm.release(bound).unwrap(); let Value::Object(unbound) = session.candidate.vm.get_attr(model, "check").unwrap() else { panic!("method") }; assert_eq!(session.candidate.vm.call_effect(unbound).unwrap(), None); let Value::Object(forward) = session .candidate .vm .dict_get(globals, &Value::Text("forward".into())) .unwrap() .unwrap() else { panic!("forward") }; session.execute("simple = impure", "app.main").unwrap(); assert_eq!(session.candidate.vm.call_effect(forward).unwrap(), None); session.execute("simple = original", "app.main").unwrap(); assert_eq!( session.candidate.vm.call_effect(forward).unwrap(), Some(endor_core::CallEffect::ReadOnly) ); assert_eq!( session.execute("marker.value", "app.main").unwrap().value, "0" ); } #[test] /// 语言层拒绝用普通实例字段遮蔽有契约的 paint/measure/onEvent。 /// 底层绕过语言写入存储模拟方法阴影,缓存需失效至祖先并报 TraitViolation;删除阴影后可再次生成合法快照。 fn typed_method_shadows_invalidate_cached_ancestors_and_can_be_removed() { let mut session = ReplSession::new(233).unwrap(); session .execute( "rect = RectBlock(40, 20)\nroot = Column(0, 0, rect)", "app.main", ) .unwrap(); let globals = session.candidate.globals.unwrap(); let lookup = |name: &str| match session .candidate .vm .dict_get(globals, &Value::Text(name.into())) .unwrap() .unwrap() { Value::Object(value) => value, _ => panic!("object"), }; let rect = lookup("rect"); let root = lookup("root"); for name in ["paint", "measure", "onEvent"] { let error = session .execute(&format!("rect.{name} = 1"), "app.main") .err() .expect("typed method cannot be shadowed"); assert!( error.to_string().contains("instance attribute shadows"), "{error:#}" ); } let vm = &mut session.candidate.vm; let storage = *vm .object_store() .attribute_path(rect) .unwrap() .last() .unwrap(); let mut cache = crate::snapshot::RenderCache::default(); cache.snapshot(vm.object_store(), root).unwrap(); vm.take_changes(); cache.snapshot(vm.object_store(), root).unwrap(); assert_eq!(cache.visited, 0); vm.set_attr(storage, "paint", Value::Nil).unwrap(); cache.invalidate(vm.take_changes()); assert!(matches!( cache.snapshot(vm.object_store(), root), Err(endor_core::VmError::TraitViolation { .. }) )); vm.del_attr(storage, "paint").unwrap(); cache.invalidate(vm.take_changes()); cache.snapshot(vm.object_store(), root).unwrap(); assert!(cache.visited > 0); } #[test] /// 为参数/返回契约不兼容的 present 方法声明 Presentable,注册必须失败且方法体 marker 不执行。 /// 参数更宽、返回更具体的合法方法可注册,并实际产出 TextBlock,运行时保持健康。 fn presentable_type_contracts_reject_before_registration_or_body_effects() { let mut session = ReplSession::new(232).unwrap(); session.execute("marker = ui.state(0)", "app.main").unwrap(); for (name, method) in [ ( "WrongParameter", "function present(self: WrongParameter, window: Point): Block { marker.increment() return TextBlock(\"bad\") }", ), ( "WrongResult", "function present(self: WrongResult, window: Window): Number { marker.increment() return 7 }", ), ] { let input = format!("class {name} {{ {method} }}\nui.implement({name}, Presentable)"); let error = session .execute(&input, "app.main") .err() .expect("incompatible typed capability"); assert!( error .to_string() .contains("trait Presentable method present"), "{error:#}" ); assert_eq!( session .execute(&format!("ui.implements({name}, Presentable)"), "app.main") .unwrap() .value, "false" ); assert_eq!( session.execute("marker.value", "app.main").unwrap().value, "0" ); } session.execute(r#" class Good { function present(self: Good, window: Object): TextBlock { return TextBlock("typed") } } ui.implement(Good, Presentable) view = ui.present(Good()) "#, "app.main").unwrap(); assert_eq!( session .execute("ui.isInstance(view, TextBlock)", "app.main") .unwrap() .value, "true" ); assert!(!session.is_faulted()); } #[test] /// 加载显式 Presentable 示例,检查视图的 source 字段仍指原 Product 对象。 /// 改变 product.name 可响应式更新显示;另验证错误 Visual 覆盖在定义时拒绝,不破坏现有会话。 fn presentable_dispatch_preserves_source_identity_and_reactive_display() { let (mut session, initial) = ReplSession::load( include_str!("../../../examples/presentable.endor"), "app.main", 1, 230, ) .unwrap(); assert!(initial.frame.commands.iter().any(|command| matches!(command,RenderCommand::Text { value, .. } if value == "普通对象的显式展示能力"))); let globals = session.candidate.globals.unwrap(); let Value::Object(product) = session .candidate .vm .dict_get(globals, &Value::Text("product".into())) .unwrap() .unwrap() else { panic!("expected Product"); }; let Value::Object(view) = session .candidate .vm .dict_get(globals, &Value::Text("view".into())) .unwrap() .unwrap() else { panic!("expected Block"); }; assert_eq!( session.candidate.vm.get_attr(view, "source").unwrap(), Value::Object(product) ); assert_eq!( session .execute("ui.supports(product,Presentable)", "app.main") .unwrap() .value, "true" ); let changed = session .execute("product.name = \"updated\"", "app.main") .unwrap() .document .unwrap(); assert!( changed.frame.commands.iter().any( |command| matches!(command,RenderCommand::Text { value, .. } if value == "updated") ) ); assert!(session.execute("class Bad: RectBlock { function paint(self: Bad): DisplayList { return DisplayList(ObjectList()) } }","app.main").err().unwrap().to_string().contains("trait Visual method paint")); assert!(!session.is_faulted()); } #[test] /// 仅有同名且签名匹配的 present 方法不自动声明能力,ui.present 走回退且 marker 不增。 /// 显式 implement 后 ui.open 才执行自定义方法;缺失实现的注册错误不改变已发布文档。 fn matching_present_method_does_not_implicitly_declare_presentable() { let mut session = ReplSession::new(231).unwrap(); session .execute( r#" class Data { marker: Object function present(self: Data, window: Window): Block { self.marker.increment() return TextBlock("custom") } } marker = ui.state(0) data = Data(marker) fallback = ui.present(data) "#, "app.main", ) .unwrap(); assert_eq!( session.execute("marker.value", "app.main").unwrap().value, "0" ); assert_eq!( session .execute("ui.supports(data,Presentable)", "app.main") .unwrap() .value, "false" ); session .execute( "ui.implement(Data,Presentable)\ncustom = ui.open(data)", "app.main", ) .unwrap(); assert_eq!( session.execute("marker.value", "app.main").unwrap().value, "1" ); let before = session.documents.clone(); assert!( session .execute( "class Missing {}\nui.implement(Missing,Presentable)", "app.main" ) .is_err() ); assert_eq!( session.documents[&crate::window::MAIN_WINDOW] .frame .layout_version, before[&crate::window::MAIN_WINDOW].frame.layout_version ); } #[test] /// 隐藏 rect 的 width 绑定先随模型更新,挂载到两个窗口后同一业务值更新两个窗口几何。 /// 断开令牌后模型变化不再传递,直接写目标属性仍正常发布。 fn managed_property_bindings_update_hidden_objects_and_shared_window_geometry() { let mut session = ReplSession::new(220).unwrap(); session .execute( r##" class Model { width: Number function read(self: Model): Number { return self.width } } model = Model(80) rect = RectBlock(1,20,0,"#DDEEFF") token = rect.bind("width",model.read) "##, "app.main", ) .unwrap(); assert_eq!( session.execute("rect.width", "app.main").unwrap().value, "80" ); session.execute("model.width = 140", "app.main").unwrap(); assert_eq!( session.execute("rect.width", "app.main").unwrap().value, "140" ); session.execute("first = Page()\nfirst.render(rect)\nother = Window()\nsecond = Page()\nsecond.open(other)\nsecond.render(rect)", "app.main").unwrap(); let updated = session .execute("model.width = 260", "app.main") .unwrap() .document .unwrap(); for frame in std::iter::once(&updated.frame) .chain(updated.windows.values().map(|document| &document.frame)) { assert!(frame.mounts.iter().any(|mount| mount.width == 260.0)); } session .execute("token.disconnect()\nmodel.width = 360", "app.main") .unwrap(); assert_eq!( session.execute("rect.width", "app.main").unwrap().value, "260" ); let direct = session .execute("rect.width = 180", "app.main") .unwrap() .document .unwrap(); assert!(direct.frame.mounts.iter().any(|mount| mount.width == 180.0)); } #[test] /// 同一目标两个属性各绑定一个返回新 Record 的计算。 /// 二者都应稳定为 value=7,不能因对象输出写入更新目标版本而相互触发无穷重算。 fn multiple_object_outputs_on_one_target_do_not_invalidate_each_other() { let mut session = ReplSession::new(222).unwrap(); session .execute( r##" class Record { value: Number } function makeRecord(): Object { return Record(7) } rect = RectBlock(1,20) rect.first = Record(0) rect.second = Record(0) first = rect.bind("first",makeRecord) second = rect.bind("second",makeRecord) "##, "app.main", ) .unwrap(); assert_eq!( session .execute("rect.first.value", "app.main") .unwrap() .value, "7" ); assert_eq!( session .execute("rect.second.value", "app.main") .unwrap() .value, "7" ); assert!(!session.is_faulted()); } #[test] /// 可见和隐藏 rect 都绑定到读取全局 size 的函数,用 bindingEvaluations 比较精确失效。 /// 无关 REPL 结果不重算,size 改变只各算一次;直接破坏一个输出仅重算该绑定并恢复正确值。 fn property_bindings_use_precise_names_and_repair_direct_output_changes() { let (mut session, _) = ReplSession::load( r#" size = 80 function readWidth(): Number { return size } rect = RectBlock(1,20) hidden = RectBlock(1,20) rect.bind("width",readWidth) hidden.bind("width",readWidth) page = Page() page.render(rect) "#, "app.main", 903, 1, ) .unwrap(); let count = |session: &mut ReplSession| { session .execute("ui.stats().bindingEvaluations", "app.main") .unwrap() .value .parse::() .unwrap() }; let baseline = count(&mut session); assert_eq!(baseline, 2); assert!( session .execute("42", "app.main") .unwrap() .document .is_none() ); assert_eq!(count(&mut session), baseline); session.execute("size = 120", "app.main").unwrap(); assert_eq!(count(&mut session), baseline + 2); assert_eq!( session.execute("hidden.width", "app.main").unwrap().value, "120" ); session.execute("rect.width = 200", "app.main").unwrap(); assert_eq!(count(&mut session), baseline + 3); assert_eq!( session.execute("rect.width", "app.main").unwrap().value, "120" ); assert_eq!(count(&mut session), baseline + 3); } #[test] /// 加载 GC 示例后建立 Page/Block/等待协程之间的循环,先确认任务真的停在 await。 /// 关闭页面后任务仍可独立存活;释放业务引用后对象数回基线、弱 Page/Block 失效,证明渲染缓存未额外持根。 fn source_render_caches_do_not_root_a_page_block_waiting_frame_cycle() { let (mut session, _) = ReplSession::load( include_str!("../../../examples/gc-lifecycle.endor"), "app.main", 902, 1, ) .unwrap(); let baseline = session .execute("ui.stats().objects", "app.main") .unwrap() .value; session.execute("mountCycle()", "app.main").unwrap(); session.poll_tasks().unwrap(); assert_eq!( session.execute("phase.value", "app.main").unwrap().value, "1" ); assert_eq!( session .execute("pending.value.status()", "app.main") .unwrap() .value, "\"running\"" ); let globals = session.candidate.globals.unwrap(); let Value::Object(holder) = session .candidate .vm .dict_get(globals, &Value::Text("holder".into())) .unwrap() .unwrap() else { panic!("holder") }; let Value::Object(page) = session.candidate.vm.get_attr(holder, "value").unwrap() else { panic!("page") }; let rect = crate::block::resolve(session.candidate.vm.object_store(), page) .unwrap() .1 .children[0] .block; let page_weak = session.candidate.vm.object_store().downgrade(page).unwrap(); let rect_weak = session.candidate.vm.object_store().downgrade(rect).unwrap(); session.execute("holder.value.close()", "app.main").unwrap(); assert_eq!( session .execute("pending.value.status()", "app.main") .unwrap() .value, "\"running\"" ); session.execute("releaseCycle()", "app.main").unwrap(); assert_eq!( session .execute("ui.stats().objects", "app.main") .unwrap() .value, baseline ); assert!(session.candidate.vm.upgrade(page_weak).unwrap().is_none()); assert!(session.candidate.vm.upgrade(rect_weak).unwrap().is_none()); } #[test] /// 仅保留绑定 token,删除隐藏目标并回收,目标弱句柄应失效且 token 断开。 /// 另用会写模型的计算函数创建绑定,写入前只读保护失败并停止 VM,原 width 仍为 80。 fn binding_tokens_do_not_retain_hidden_targets_and_compute_is_read_only() { let mut session = ReplSession::new(221).unwrap(); session .execute( r##" class Model { width: Number function read(self: Model): Number { return self.width } function bad(self: Model): Number { self.width = 999 return self.width } } model = Model(80) rect = RectBlock(1,20,0,"#DDEEFF") token = rect.bind("width",model.read) "##, "app.main", ) .unwrap(); let globals = session.candidate.globals.unwrap(); let Value::Object(target) = session .candidate .vm .dict_get(globals, &Value::Text("rect".into())) .unwrap() .unwrap() else { panic!("expected Block"); }; let weak = session .candidate .vm .object_store() .downgrade(target) .unwrap(); session .candidate .vm .dict_delete(globals, &Value::Text("rect".into())) .unwrap(); session.candidate.vm.collect_cycles(); assert!(session.candidate.vm.upgrade(weak).unwrap().is_none()); assert_eq!( session .execute("token.isConnected()", "app.main") .unwrap() .value, "false" ); assert!( session .execute( "other = RectBlock(1,20)\nbadToken = other.bind(\"width\",model.bad)", "app.main" ) .is_err() ); assert!(session.is_faulted()); let Value::Object(model) = session .candidate .vm .dict_get(globals, &Value::Text("model".into())) .unwrap() .unwrap() else { panic!("expected model"); }; assert_eq!( session.candidate.vm.get_attr(model, "width").unwrap(), Value::Number(80.into()) ); } #[test] /// 两个 textOf 绑定读取同一 counter,按钮调用源辅助函数再执行原生 increment。 /// 点击后两条文字命令都必须更新为 10,覆盖跨源回调与原生写入的依赖传播。 fn native_method_callbacks_update_two_explicit_bindings() { let mut session = ReplSession::new(21).unwrap(); session.execute("counter = ui.state(9)\nfirst = ui.textOf(counter, \"value\")\nsecond = ui.textOf(counter, \"value\")\nbutton = ui.button(\"increment\")\nfunction increment(): Unit { counter.increment() }\nbutton.onClick(increment)\npage = ui.page()\npage.render(ui.row(0, 8, first, second, button))", "app.main").unwrap(); let updated = session .execute("button.click()", "app.main") .unwrap() .document .unwrap(); let texts: Vec<_> = updated .frame .commands .iter() .filter_map(|command| match command { RenderCommand::Text { value, .. } => Some(value.as_str()), _ => None, }) .collect(); assert_eq!(&texts[..2], &["10", "10"]); } #[test] /// 保留 card 业务对象,关闭/重开页面确认隐藏内容修改仍可显示。 /// 再次关闭并删除 Page 全局绑定后回收,Page 弱句柄应失效但 card 仍存在,子项不能反向强持有页面。 fn closing_a_page_releases_its_root_without_retaining_it_through_shared_content() { let mut session = ReplSession::new(22).unwrap(); session .execute( "card = ui.rect(10, 20)\npage = ui.page()\npage.render(card)", "app.main", ) .unwrap(); let globals = session.candidate.globals.unwrap(); let Value::Object(page) = session .candidate .vm .dict_get(globals, &Value::Text("page".into())) .unwrap() .unwrap() else { panic!("expected Page") }; let weak = session.candidate.vm.downgrade(page).unwrap(); session.execute("page.close()", "app.main").unwrap(); session .execute("card.setColor(\"#FFEEDD\")", "app.main") .unwrap(); assert!( session .execute("page.open()", "app.main") .unwrap() .document .is_some() ); session.execute("page.close()", "app.main").unwrap(); session .candidate .vm .dict_delete(globals, &Value::Text("page".into())) .unwrap(); session .bridge .reclaim(&mut session.candidate.vm, &mut session.candidate.roots) .unwrap(); assert!(session.candidate.vm.upgrade(weak).unwrap().is_none()); assert!( session .candidate .vm .dict_get(globals, &Value::Text("card".into())) .unwrap() .is_some() ); } #[test] /// 保存视觉对象 alias 并嵌入容器,给 card 赋新视觉值应沿共享引用更新嵌套出现位置且身份不变。 /// 包含自身的替换被拒绝;unmount 后更新不发布,重新 render 使用最新值。 fn mounted_aliases_update_nested_positions_unmount_and_reject_cycles() { let mut session = ReplSession::new(10).unwrap(); session.execute("card = ui.rect(10, 20)\nother = card\ncontainer = ui.column(0, 0, other)\npage = ui.page()\npage.render(container)", "app.main").unwrap(); let identity = session.execute("other", "app.main").unwrap().value; let updated = session .execute("card = ui.rect(640, 200, 32)", "app.main") .unwrap(); assert_eq!(updated.value, identity); assert_eq!( session.execute("other", "app.main").unwrap().value, identity ); let frame = updated.document.unwrap().frame; assert!(matches!( frame.commands[0], RenderCommand::RoundedRect { width: 640.0, height: 200.0, .. } )); assert!( session .execute("card = ui.column(0, 0, other)", "app.main") .is_err() ); assert!( session .execute("other", "app.main") .unwrap() .document .is_none() ); let unmounted = session .execute("page.unmount()", "app.main") .unwrap() .document .unwrap(); assert!(unmounted.frame.commands.is_empty()); assert!( session .execute("card = ui.rect(80, 50)", "app.main") .unwrap() .document .is_none() ); let remounted = session .execute("page.render(other)", "app.main") .unwrap() .document .unwrap(); assert!(matches!( remounted.frame.commands[0], RenderCommand::RoundedRect { width: 80.0, height: 50.0, .. } )); } #[test] /// 创建文字但未挂载时只保留 VM 值,title 与最后结果 _ 都可跨输入读取。 /// 挂载后引用替换自动更新画面,成功文档保留 Console transcript;无关查询不重复发布。 fn live_session_retains_objects_and_updates_only_after_mounting() { let mut session = ReplSession::new(7).unwrap(); let created = session .execute( r##"title = ui.text("你好,Tessera", 2, "#243047")"##, "app.main", ) .unwrap(); assert!(created.document.is_none()); assert_eq!( session.execute("title", "app.main").unwrap().value, created.value ); assert_eq!( session.execute("_", "app.main").unwrap().value, created.value ); let rendered = session .execute("page = ui.page()\npage.render(title)", "app.main") .unwrap() .document .unwrap(); assert!( matches!(&rendered.frame.commands[0], RenderCommand::Text { value, .. } if value == "你好,Tessera") ); assert_eq!(rendered.root.as_ref().unwrap().kind, "repl-session"); assert!( session .execute(r#"title = ui.text("changed")"#, "app.main") .unwrap() .document .is_some() ); let updated = session .execute("page.render(title)", "app.main") .unwrap() .document .unwrap(); assert!( matches!(&updated.frame.commands[0], RenderCommand::Text { value, .. } if value == "changed") ); assert!(updated.source.contains("// Console input 6")); assert!( session .execute("title", "app.main") .unwrap() .document .is_none() ); } #[test] /// 编译期错误不能执行同输入前面的 value=2;运行期错误则保留已经发生的 value=3。 /// 失败输入的待发布 render 被丢弃,后续显式 render 可恢复;另检查函数局部赋值正常工作。 fn live_session_compiles_before_execution_and_discards_failed_render() { let mut session = ReplSession::new(8).unwrap(); session .execute("value = 1\npage = ui.page()", "app.main") .unwrap(); assert!(session.execute("value = 2\nmissing", "app.main").is_err()); assert_eq!(session.execute("value", "app.main").unwrap().value, "1"); assert!( session .execute( "value = 3\npage.render(ui.text(\"discarded\"))\nui.rect(-1, 1, 0)", "app.main" ) .is_err() ); let retained = session.execute("value", "app.main").unwrap(); assert_eq!(retained.value, "3"); assert!(retained.document.is_none()); // 发布失败后 Page/绑定仍可用,但失败输入的待显示内容不能自动发布,需后续成功的显式 render。 let recovered = session .execute("page.render(ui.text(\"recovered\"))", "app.main") .unwrap() .document .unwrap(); assert!(recovered.frame.commands.iter().any(|command| matches!( command, RenderCommand::Text { value, .. } if value == "recovered" ))); assert!(recovered.frame.commands.iter().all(|command| !matches!( command, RenderCommand::Text { value, .. } if value == "discarded" ))); session .execute( "function local(value: Number): Number { result = value result = 42 return result }", "app.main", ) .unwrap(); assert_eq!( session.execute("local(40)", "app.main").unwrap().value, "42" ); } #[test] /// 普通顶层 page 脚本直接经 Aster 执行,源码、结构树节点和原始行位置必须保留。 /// 比较绘制几何及兼容 main 入口的命令等价性;两个独立 VM 的业务对象身份应不同。 fn top_level_goal_script_renders_without_a_main_or_synthetic_wrapper() { let document = compile(PAGE, "app.main", 9).unwrap(); assert_eq!(document.source, PAGE); let tree = document.root.as_ref().unwrap(); assert_eq!(tree.kind, "script"); assert_eq!(tree.children.len(), 4); assert_eq!(tree.children[0].name, "heading"); assert_eq!(tree.children[1].name, "rectangle"); assert_eq!(tree.children[2].name, "myui"); assert_eq!(tree.children[2].start_line, 3); assert_eq!(tree.children[3].start_line, 4); assert!(tree.id.contains("app.main@9")); assert_eq!(document.frame.commands.len(), 2); assert!( matches!(&document.frame.commands[0], RenderCommand::Text { value, size: 2, x: 24.0, y: 24.0, .. } if value == "Hello Endor") ); assert!( matches!(&document.frame.commands[1], RenderCommand::RoundedRect { x: 24.0, y: 76.0, width: 240.0, height: 80.0, radius: 12.0, color } if color == "#DCE8FF") ); assert_eq!(document.display_list(2.0).unwrap().commands().len(), 3); let wrapped = compile(include_str!("../../../examples/main.endor"), "app.main", 10).unwrap(); assert_eq!( serde_json::to_value(&document.frame.commands).unwrap(), serde_json::to_value(&wrapped.frame.commands).unwrap() ); // 不同 VM 可产生相同绘图命令,但其托管对象身份与展示上下文必须独立。 assert_ne!( document.frame.mounts[0].block_id, wrapped.frame.mounts[0].block_id ); } #[test] /// 提交含括号注释、辅助函数、多行赋值/调用及跨行成员链的完整源程序。 /// 检查渲染成功与结构树起止行,避免用宿主按行切割或简单括号统计代替 Aster 语法解析。 fn script_helpers_multiline_bindings_calls_and_member_continuations_use_aster() { let source = r##"let color = "#242422" // comment with ( and ) function greeting(): Text { return "Hello Endor" } function heading(value: Text): View { return ui.text(value, 2, color) } let title = heading(greeting()) let rectangle = ui.rect( 240, 80, 12, "#DCE8FF" ) let page = ui .page() page .render(ui.column(24, 12, title, rectangle)) "##; let document = compile(source, "app.main", 2).unwrap(); assert_eq!(document.frame.commands.len(), 2); let tree = document.root.unwrap(); assert_eq!(tree.children[1].name, "greeting"); assert_eq!(tree.children[1].start_line, 2); assert_eq!(tree.children[2].name, "heading"); assert_eq!(tree.children[2].start_line, 5); assert_eq!(tree.children[3].start_line, 8); assert_eq!(tree.children[3].end_line, 9); assert_eq!(tree.children.last().unwrap().end_line, 17); } #[test] /// 分别使用 LF/CRLF/CR,在前面含中文的脚本中制造 missing 引用。 /// 诊断行列、字节 span 切片和提交来源都需对应原文;另检查语法错误的原始行号。 fn script_diagnostics_refer_to_original_unicode_source_and_byte_ranges() { for ending in ["\n", "\r\n", "\r"] { let source = format!( "let title = ui.text(\"中文\"){ending}// comment{ending}let broken = missing{ending}ui.page().render(title)" ); let error = compile(&source, "app.main", 27).unwrap_err(); let diagnostic = error.downcast_ref::().unwrap(); assert_eq!(diagnostic.location.line, 3); assert_eq!(diagnostic.location.column, 14); assert_eq!(diagnostic.diagnostic.span.slice(&source), Some("missing")); assert!(diagnostic.origin.to_string().contains("submission 27")); } let error = compile("let page = ui.page()\npage.render(,)", "app.main", 1).unwrap_err(); let diagnostic = error.downcast_ref::().unwrap(); assert_eq!(diagnostic.location.line, 2); } #[test] /// 两个 Page 交替 render 后,把 first.render 保存成函数再调用。 /// 绑定方法必须仍持有原接收者,最后一次 render 选择显示内容 last。 fn pages_bind_render_methods_and_last_render_selects_the_snapshot() { let source = r#"let first = ui.page() let second = ui.page() first.render(ui.text("first")) second.render(ui.text("second")) let paint = first.render paint(ui.text("last"))"#; let document = compile(source, "app.main", 1).unwrap(); assert_eq!(document.frame.commands.len(), 1); assert!( matches!(&document.frame.commands[0], RenderCommand::Text { value, .. } if value == "last") ); } #[test] /// 先发布成功文档,再逐项提交无 render、错误 Page 参数、错误根和 render 后失败的源码。 /// 每个候选都必须失败,已发布 source 与 revision 保持原值,不能出现部分帧。 fn page_api_errors_and_late_failures_do_not_publish_partial_snapshots() { let mut state = NamespaceState { submission: 1, ..NamespaceState::default() }; state .commit(1, compile(PAGE, "app.main", 1).unwrap()) .unwrap(); for source in [ "ui.page()", "let title = ui.text(\"no render\")", "let page = ui.page(1)\npage.render(ui.text(\"x\"))", "let page = ui.page()\npage.render()", "let page = ui.page()\npage.render(\"not a node\")", "let page = ui.page()\npage.render(ui.text(\"partial\"))\nui.missing()", ] { state.submission = state.next_submission().unwrap(); assert!( compile(source, "app.main", state.submission).is_err(), "{source}" ); assert_eq!(state.document.source, PAGE); assert_eq!(state.revision, 1); } } #[test] /// 保留超过 MAX_PAGES 的页面引用后再请求显示,检查明确的 64 page budget 错误。 /// 页面资源预算独立于最终画了多少节点,不能靠只显示一个页面绕过。 fn page_creation_has_a_separate_live_object_budget() { let mut source = String::new(); for index in 0..=ui_bridge::MAX_PAGES { source.push_str(&format!("let page{index} = ui.page()\n")); } source.push_str("page0.render(ui.text(\"x\"))"); let error = compile(&source, "app.main", 1).unwrap_err(); assert!(error.to_string().contains("64 page budget"), "{error:#}"); } #[test] /// 生成每层重复调用前一函数的指数展开计算,最后才创建文字。 /// 即使尚未触及 UI 节点预算,指令总预算仍应终止计算并报告 instructions。 fn script_execution_is_limited_even_without_creating_ui_nodes() { let mut source = "function text0(): Text { return \"Hello Endor\" }\n".to_owned(); for index in 1..=16 { source.push_str(&format!( "function text{index}(): Text {{ let unused = text{}() return text{}() }}\n", index - 1, index - 1 )); } source.push_str("let title = ui.text(text16())\nui.page().render(title)"); let error = compile(&source, "app.main", 1).unwrap_err(); assert!( error .to_string() .contains("execution limit reached: instructions"), "{error:#}" ); } #[test] /// 源 main 返回普通文字,再传给 ui.text 并挂载。 /// 验证 VM 的字符串结果可正确被宿主解码成发布命令,而非要求它已经是视觉对象。 fn literal_string_return_from_aster_can_be_displayed_by_the_host() { let source = "function main(): Text { return \"Hello Endor\" }\nlet title = ui.text(main())\nui.page().render(title)"; let document = compile(source, "app.main", 1).unwrap(); assert!( matches!(&document.frame.commands[0], RenderCommand::Text { value, .. } if value == "Hello Endor") ); } #[test] /// 为相同源码生成两个不同提交的结构树,开发工具先选中旧子节点。 /// 接收新文档后旧 ID 不再有效,选择应回退到新树根,避免沿用旧提交位置。 fn developer_selection_resets_to_the_new_source_snapshot() { let first = compile(PAGE, "app.main", 1).unwrap(); let second = compile(PAGE, "app.main", 2).unwrap(); let mut tools = crate::developer_tools::DeveloperToolsState::default(); tools.open = true; tools.selected_node_id = Some(first.root.as_ref().unwrap().children[0].id.clone()); tools.document_updated(&second); assert_eq!( tools.selected_node_id.as_deref(), Some(second.root.as_ref().unwrap().id.as_str()) ); } #[test] /// 通过兼容模块/main 示例检查结构树、布局、文字实际测量和命令位置。 /// compile 路径清理候选 VM 后,两种显示倍率仍能从拥有的数据生成显示列表,证明发布不依赖悬空 VM 句柄。 fn executes_aster_functions_and_renders_after_vm_cleanup() { let document = compile(EXAMPLE, "app.main", 1).unwrap(); assert_eq!(document.source, EXAMPLE); let tree = document.root.as_ref().unwrap(); assert_eq!(tree.kind, "module"); assert_eq!(tree.name, "app.main"); assert_eq!(tree.children[0].name, "heading"); assert_eq!(tree.children[1].name, "main"); assert_eq!(tree.children[1].start_line, 5); assert_eq!(document.frame.commands.len(), 4); assert!( matches!(&document.frame.commands[0], RenderCommand::Text { value, size: 2, x: 24.0, y: 24.0, .. } if value == "Hello Endor") ); assert!(matches!( &document.frame.commands[1], RenderCommand::RoundedRect { x: 24.0, y: 76.0, width: 240.0, height: 80.0, .. } )); let first_width = crate::text::measure("Aster VM", crate::text::TextStyle::ui(1)).width; assert!(matches!( &document.frame.commands[3], RenderCommand::Text { x, y: 168.0, .. } if (*x - (24.0 + first_width + 12.0 + 8.0 + 12.0)).abs() < 0.01 )); // compile 已清理候选 VM;以下重绘只能使用发布的原生数据,两种显示倍率都不能再依赖 VM 对象。 assert_eq!(document.display_list(1.0).unwrap().commands().len(), 5); assert_eq!(document.display_list(2.0).unwrap().commands().len(), 5); } #[test] /// 辅助函数接收借用 child 并把它放入 Row 两次。 /// 编译完成后两个文字命令各自有正确几何,覆盖变量/返回值/共享子项之间的托管引用有效性。 fn borrowed_ui_handles_survive_variables_helpers_and_reused_children() { let source = r#"function wrap(child: View): View { return ui.row(4, 8, child, child) } function main(): View { let child = ui.text("shared") return wrap(child) }"#; let document = compile(source, "arbitrary.namespace", 3).unwrap(); assert_eq!(document.frame.commands.len(), 2); assert!(matches!( &document.frame.commands[0], RenderCommand::Text { x: 4.0, y: 4.0, .. } )); let width = crate::text::measure("shared", crate::text::TextStyle::ui(1)).width; assert!(matches!( &document.frame.commands[1], RenderCommand::Text { x, y: 4.0, .. } if (*x - (4.0 + width + 8.0)).abs() < 0.01 )); } #[test] /// 把同一模块示例换成 CRLF 或 CR,源快照必须逐字保留。 /// 结构树的 main 起始行仍为 5,检查行定位对不同换行形式一致。 fn architecture_ranges_follow_crlf_and_cr_source_snapshots() { for ending in ["\r\n", "\r"] { let source = EXAMPLE.replace('\n', ending); let document = compile(&source, "app.main", 1).unwrap(); assert_eq!(document.source, source); assert_eq!(document.root.unwrap().children[1].start_line, 5); } } #[test] /// 表驱动拒绝旧 namespace/scene 语法、缺失或有参 main、错误根类型和各类非法 UI 参数。 /// 同时覆盖尺寸/字号/颜色预算与未知名称,确保兼容入口不会默默接受错误程序。 fn rejects_invalid_entry_objects_arguments_and_old_syntax() { for source in [ "namespace app.main export scene Main { render { Text(\"old\") } }", "function helper(): View { return ui.text(\"missing main\") }", "function main(value: View): View { return value }", "function main(): View { return \"wrong root\" }", "function main(): View { return main }", "function main(): View { return ui.text(1) }", "function main(): View { return ui.text(\"x\", 1.0) }", "function main(): View { return ui.text(\"x\", 9) }", "function main(): View { return ui.rect(-1, 1) }", "function main(): View { return ui.rect(1000001, 1) }", "function main(): View { return ui.rect(1, 1, 0, \"#中中\") }", "function main(): View { return ui.column(0, 0, ui.text) }", "function main(): View { return unknown(1) }", "function main(): View { return ui.missing() }", ] { assert!( compile(source, "app.main", 1).is_err(), "accepted: {source}" ); } } #[test] /// 在中文字符串之后制造未知引用,检查 SourceDiagnostic 仍指向第三行和 submission 17。 /// 避免宿主包装源代码后把错误定位成合成代码位置。 fn source_diagnostics_keep_unicode_locations_and_submission_origin() { let error = compile( "function main(): View {\n let title = ui.text(\"中文\")\n return missing\n}", "app.main", 17, ) .unwrap_err(); let error = error.downcast_ref::().unwrap(); assert_eq!(error.location.line, 3); assert!(error.origin.to_string().contains("submission 17")); } #[test] /// 无终止条件的 main 自递归必须被 VM 帧预算截断,报告 frames 而非让宿主栈溢出。 fn recursive_program_stops_at_the_vm_frame_limit() { let error = compile("function main(): View { return main() }", "app.main", 1).unwrap_err(); assert!( error .to_string() .contains("execution limit reached: frames") ); } /// 生成二叉视觉树程序。shared=true 每层只构造一个 child 再复用两次,false 则分别递归构造。 /// 用于把业务对象数量增长和展示出现位置展开增长分开测试,最终由 main 返回最高层节点。 fn nested_functions(levels: usize, shared: bool) -> String { let mut source = "function node0(): View { return ui.text(\"x\") }\n".to_owned(); for index in 1..=levels { let previous = index - 1; if shared { source.push_str(&format!("function node{index}(): View {{ let child = node{previous}() return ui.column(0, 0, child, child) }}\n")); } else { source.push_str(&format!("function node{index}(): View {{ return ui.column(0, 0, node{previous}(), node{previous}()) }}\n")); } } source.push_str(&format!( "function main(): View {{ return node{levels}() }}" )); source } #[test] /// 不共享子项的树先触发 4096 构造节点预算;共享树对象较少但展开出现位置更多。 /// 后者需报告 expanded Block graph,证明两类预算分别约束对象分配和渲染规模。 fn construction_and_expanded_layout_have_separate_budgets() { let error = compile(&nested_functions(12, false), "app.main", 1).unwrap_err(); assert!(error.to_string().contains("4096 node budget"), "{error:#}"); let error = compile(&nested_functions(14, true), "app.main", 2).unwrap_err(); assert!( error.to_string().contains("expanded Block graph"), "{error:#}" ); } #[test] /// 构造 64 层嵌套容器包住一个文字,完整编译后仍应有一条文字命令。 /// 验证允许的深度不会因宿主遍历截断而悄悄丢掉叶节点。 fn managed_ui_depth_is_not_truncated_at_64_levels() { let mut source = "function node0(): View { return ui.text(\"x\") }\n".to_owned(); for index in 1..=64 { source.push_str(&format!( "function node{index}(): View {{ return ui.column(0, 0, node{}()) }}\n", index - 1 )); } source.push_str("function main(): View { return node64() }"); let document = compile(&source, "app.main", 1).unwrap(); assert_eq!(document.frame.commands.len(), 1); } #[test] /// 直接测试 NamespaceState 的提交令牌:失败编译保留旧文档,新 submission 使旧候选失效。 /// clear 后旧候选同样不能复活画面;随后新令牌的合法候选可继续递增 revision。 fn failed_updates_preserve_success_and_delete_invalidates_inflight_work() { let mut state = NamespaceState::default(); state.submission = state.next_submission().unwrap(); assert_eq!( state .commit(state.submission, compile(EXAMPLE, "app.main", 1).unwrap()) .unwrap(), Some(1) ); state.submission = state.next_submission().unwrap(); assert!(compile("invalid", "app.main", state.submission).is_err()); assert_eq!(state.revision, 1); assert_eq!(state.document.source, EXAMPLE); let stale = state.submission; let candidate = compile(EXAMPLE, "app.main", stale).unwrap(); state.submission = state.next_submission().unwrap(); assert!(state.commit(stale, candidate.clone()).unwrap().is_none()); let deleted = state.clear().unwrap(); assert!(state.commit(stale, candidate).unwrap().is_none()); assert_eq!(state.revision, deleted); assert!(state.document.source.is_empty()); state.submission = state.next_submission().unwrap(); let candidate = compile(EXAMPLE, "app.main", state.submission).unwrap(); assert_eq!( state.commit(state.submission, candidate).unwrap(), Some(deleted + 1) ); } // 退出 fixture 在两个窗口展示同一文字,以 log 统计每个出现位置的卸载,并保留一个待取消任务。 const EXIT_SOURCE: &str = r#" class ExitText: TextBlock { log: Object function onUnmount(self: ExitText, mount: Mount): Unit { self.log.increment() } } log = ui.state(0) text = ExitText("exit",1,log) page = Page() page.render(text) second = Window() other = Page() other.render(text) other.moveToWindow(second) pending = ui.sleep(ui,"pending",30000) "#; /// 直接读取退出测试中的 log 托管状态,不通过 execute,因关闭后普通输入已经被禁止。 fn exit_log(session: &ReplSession) -> Value { let globals = session.candidate.globals.unwrap(); let Some(Value::Object(log)) = session .candidate .vm .dict_get(globals, &Value::Text("log".into())) .unwrap() else { panic!("log") }; session.candidate.vm.get_attr(log, "value").unwrap() } #[test] /// 两个窗口共享文字并保有 pending Task,shutdown 返回窗口/Mount/任务清理统计。 /// 两个出现位置各调用一次 onUnmount,重复 shutdown 不再调用,关闭后的 execute 被拒绝。 fn shutdown_unmounts_all_windows_once_and_cancels_tasks() { let (mut session, _) = ReplSession::load(EXIT_SOURCE, "app.main", 701, 1).unwrap(); assert_eq!(exit_log(&session), Value::Number(0_i64.into())); let (windows, mounts, tasks) = session.shutdown().unwrap(); assert_eq!(windows, 2); assert!(mounts >= 2); assert!(tasks >= 1); assert_eq!(exit_log(&session), Value::Number(2_i64.into())); session.shutdown().unwrap(); assert_eq!(exit_log(&session), Value::Number(2_i64.into())); assert!(session.execute("42", "app.main").is_err()); } #[test] /// 手动将会话标为 faulted 后 shutdown,资源仍需清理但 log 保持 0。 /// 验证停止域的退出清理不能借生命周期回调重新执行源代码。 fn shutdown_stopped_runtime_never_reenters_source_hooks() { let (mut session, _) = ReplSession::load(EXIT_SOURCE, "app.main", 702, 1).unwrap(); session.faulted = true; session.shutdown().unwrap(); assert_eq!(exit_log(&session), Value::Number(0_i64.into())); } #[test] /// 把退出 onUnmount 改成启动 sleep;关闭期间必须拒绝新任务并报告 exiting 诊断。 /// 错误使运行时 fault,避免退出清理反而产生无法结束的后台工作。 fn shutdown_hooks_cannot_create_new_background_work() { let source = EXIT_SOURCE.replace("self.log.increment()", "ui.sleep(ui,\"late\",30000)"); let (mut session, _) = ReplSession::load(&source, "app.main", 703, 1).unwrap(); let error = session.shutdown().unwrap_err(); assert!(format!("{error:#}").contains("runtime is exiting; new tasks are forbidden")); assert!(session.is_faulted()); } #[test] /// 以有限 400x300 视口比较 window/vertical/horizontal:普通页受窗口限制,延伸页仅沿声明轴增长。 /// append 新子项后延伸尺寸连同 gap 实时更新,覆盖页面布局模式的旧兼容入口。 fn page_modes_grow_on_the_declared_axis_and_follow_live_children() { for (mode, expected) in [ ("window", (400.0, 300.0)), ("vertical", (400.0, 710.0)), ("horizontal", (910.0, 300.0)), ] { let source = format!( r#"page=Page() page.mode="{mode}" page.gap=10 page.render(RectBlock(450,350)) page.append(RectBlock(450,350))"# ); let (mut session, document) = ReplSession::load_with_viewport( &source, "app.main", 1, 300, Some(crate::layout::Size { width: 400.0, height: 300.0, }), ) .unwrap(); let root = &document.frame.mounts[0]; assert_eq!((root.width, root.height), expected, "{mode}"); if mode == "vertical" { let next = session .execute("page.append(RectBlock(450,350))", "app.main") .unwrap() .document .unwrap(); assert_eq!(next.frame.mounts[0].height, 1070.0); } if mode == "horizontal" { let next = session .execute("page.append(RectBlock(450,350))", "app.main") .unwrap() .document .unwrap(); assert_eq!(next.frame.mounts[0].width, 1370.0); } } } #[test] /// Canvas 中两次使用同一按钮,业务 ID 相同但 Mount ID 不同,均接受带符号世界坐标。 /// 修改位置更新两处;切到另一普通页再回来,原 Page 的 pan/zoom 与页面身份仍保留。 fn canvas_positions_are_live_signed_and_shared_without_copying_objects() { let (mut session, initial) = ReplSession::load_with_viewport( r#" item=Button("same object") item.x=-120 item.y=90 page=Page() page.mode="canvas" page.render(item) page.append(item) page.panX=-160 page.zoom=2 "#, "app.main", 1, 301, Some(crate::layout::Size { width: 400.0, height: 300.0, }), ) .unwrap(); let mounts: Vec<_> = initial .frame .mounts .iter() .filter(|mount| mount.interactive) .collect(); assert_eq!(mounts.len(), 2); assert_eq!(mounts[0].block_id, mounts[1].block_id); assert_ne!(mounts[0].id, mounts[1].id); assert_eq!((mounts[0].x, mounts[0].y), (-120.0, 90.0)); assert_eq!(initial.frame.surface.pan.x, -160.0); assert_eq!(initial.frame.surface.zoom, 2.0); let next = session .execute("item.x=500\nitem.y=-60", "app.main") .unwrap() .document .unwrap(); assert!( next.frame .mounts .iter() .filter(|m| m.interactive) .all(|m| m.x == 500.0 && m.y == -60.0) ); let old_page = next.frame.surface.page.clone(); let window = session .execute( "other=Page()\nother.render(TextBlock(\"other\"))", "app.main", ) .unwrap() .document .unwrap(); assert_eq!(window.frame.surface.mode, crate::page::Mode::Window); let restored = session .execute("page.activate()", "app.main") .unwrap() .document .unwrap(); assert_eq!(restored.frame.surface.page, old_page); assert_eq!(restored.frame.surface.pan.x, -160.0); assert_eq!(restored.frame.surface.zoom, 2.0); } #[test] /// 通过 ui.newTab 加载内置起始页并确认二维视口存在。 /// 逐个按画面文字位置点击示例入口,检查它们都使用 Window 表面、仅延伸示例带 ScrollBlock,再用真实 tab-activate 回到首页。 fn bundled_start_page_uses_independent_layout_scroll_and_scene_viewports() { let mut session = ReplSession::new_with_viewport( 302, Some(crate::layout::Size { width: 1024.0, height: 800.0, }), ) .unwrap(); let mut document = session .execute("ui.newTab()", "app.main") .unwrap() .document .unwrap(); assert_eq!(document.frame.surface.mode, crate::page::Mode::Window); assert!( document .frame .mounts .iter() .any(|mount| mount.canvas_viewport) ); for (label, scrolling) in [("窗口页面", false), ("纵向延伸", true), ("横向延伸", true)] { let home_tab = document .frame .tabs .iter() .find(|tab| tab.title == "自由画布") .unwrap() .id; let point = document .frame .commands .iter() .find_map(|command| match command { RenderCommand::Text { x, y, value, .. } if value == label => { Some(crate::geometry::Point::new(x + 2.0, y + 2.0)) } _ => None, }) .unwrap(); let mount = document .frame .hit_test(point) .expect("button label must be clickable") .id; document = session .dispatch(&crate::events::Input { window: 1, session: document.frame.session, layout_version: document.frame.layout_version, mount, kind: "click".into(), point: Some([point.x, point.y]), press_point: Some([point.x, point.y]), delta: None, tab_drop: None, screen_position: None, }) .unwrap() .document .unwrap(); assert_eq!( document.frame.surface.mode, crate::page::Mode::Window, "{label}" ); assert_eq!( document .frame .mounts .iter() .any(|mount| mount.scroll.is_some()), scrolling, "{label}" ); assert!(document.frame.fault.is_none()); let input = crate::events::Input { window: 1, session: document.frame.session, layout_version: document.frame.layout_version, mount: home_tab, kind: "tab-activate".into(), point: None, press_point: None, delta: None, tab_drop: None, screen_position: None, }; document = session.dispatch(&input).unwrap().document.unwrap(); } }