diff --git a/src/runtime/endor_host/tests.rs b/src/runtime/endor_host/tests.rs index e12939c..d80989b 100644 --- a/src/runtime/endor_host/tests.rs +++ b/src/runtime/endor_host/tests.rs @@ -3904,6 +3904,7 @@ fn loaded_program_console_and_native_events_share_unique_source_ids() { /// 向被裁剪的子项中心发送 click,虽在其原始矩形内也不得触发计数。 /// 随后滚动同一 ScrollBlock 的一个出现位置、scrollIntoView 并扩大容器,分别检查独立偏移、可见性及范围回落到零。 fn scroll_occurrences_are_independent_and_clipped_pointer_input_is_ignored() { + // 加载两个窗口共享 root/scroller 的实际示例;主窗口 frame 用来构造坐标输入。 let (mut session, initial) = ReplSession::load( include_str!("../../../examples/scroll.endor"), "app.main", @@ -3911,7 +3912,9 @@ fn scroll_occurrences_are_independent_and_clipped_pointer_input_is_ignored() { 240, ) .unwrap(); + // 从当前 VM 全局表取业务按钮,后续通过对象身份定位它的主窗口出现位置。 let globals = session.candidate.globals.unwrap(); + // middle 位于滚动内容的中段,初始未滚动时中心应被容器裁剪。 let Value::Object(middle) = session .candidate .vm @@ -3921,17 +3924,21 @@ fn scroll_occurrences_are_independent_and_clipped_pointer_input_is_ignored() { else { panic!("expected Block"); }; + // 只在主窗口发布帧中找 middle 的 Mount,避免选到另一个窗口的同一业务对象。 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, ]; + // 先验证夹具确实产生裁剪外目标;contains 同时考虑有效可见区域,不能只测原始宽高。 assert!(!target.contains(crate::geometry::Point::new(point[0], point[1]))); + // 携带有效会话和布局版本,按下/释放都在该中心点;唯一拒绝原因应为裁剪命中检查。 session .dispatch(&crate::events::Input { window: 1, @@ -3946,10 +3953,12 @@ fn scroll_occurrences_are_independent_and_clipped_pointer_input_is_ignored() { delta: None, }) .unwrap(); + // 业务计数仍为零,证明即使客户端直接提供该 Mount,也不能绕过裁剪触发 click。 assert_eq!( session.execute("count.value", "app.main").unwrap().value, "0" ); + // 在第一个 Mount 连续 scrollTo/scrollBy,验证同次源码输入中相对滚动累加到 150。 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 @@ -3958,6 +3967,7 @@ fn scroll_occurrences_are_independent_and_clipped_pointer_input_is_ignored() { .value, "150" ); + // 第二个出现位置仍为零,偏移属于 Mount,不应共享到同一 ScrollBlock 的另一窗口。 assert_eq!( session .execute("scroller.mounts().at(1).scrollPosition().y", "app.main") @@ -3965,9 +3975,11 @@ fn scroll_occurrences_are_independent_and_clipped_pointer_input_is_ignored() { .value, "0" ); + // 请求把底部按钮的第一个出现位置滚入视野,后面读取的是更新后的文档。 session .execute("last.mounts().at(0).scrollIntoView()", "app.main") .unwrap(); + // 仍通过业务身份查找 last,避免用旧文档的过期几何判断 scrollIntoView。 let Value::Object(last) = session .candidate .vm @@ -3977,17 +3989,22 @@ fn scroll_occurrences_are_independent_and_clipped_pointer_input_is_ignored() { else { panic!("expected Block"); }; + // 取会话最新发布的主窗口帧,检查滚动后的可见性和逐命令裁剪数据。 let frame = &session.documents[&crate::window::MAIN_WINDOW].frame; + // 重新定位底部按钮的最新出现几何,不能沿用滚动前的 target。 let target = frame .mounts .iter() .find(|m| m.block_id == last.to_string()) .unwrap(); + // 按钮中心现在应在有效可见区域内,证明 scrollIntoView 真正改变投影而非只改状态字段。 assert!(target.contains(crate::geometry::Point::new( target.x + target.width / 2.0, target.y + target.height / 2.0 ))); + // 每条命令都应有对应裁剪项,包含源 paint 生成的命令。 assert_eq!(frame.command_clips.len(), frame.commands.len()); + // 增大滚动容器到能容纳全部内容;已有偏移必须随新范围夹回零。 session .execute("scroller.height = 1000", "app.main") .unwrap(); @@ -3998,6 +4015,7 @@ fn scroll_occurrences_are_independent_and_clipped_pointer_input_is_ignored() { .value, "0" ); + // 同时检查最大滚动量归零,避免偏移偶然为零但范围仍停留在旧高度。 assert_eq!( session .execute("saved.scrollPosition().maxY", "app.main") @@ -4011,15 +4029,21 @@ fn scroll_occurrences_are_independent_and_clipped_pointer_input_is_ignored() { /// 为已有 Mount 建立长延时任务,再开始会挂起的 resize 布局并替换视口目标。 /// 取消应恢复旧几何/挂载身份、清除临时 layout,最终重新收敛且原任务仍 pending,避免把放弃的准备当成卸载。 fn new_viewport_cancels_pending_layout_and_restores_saved_mount_context() { + // 重复 40 个同一 item 引用,使源布局有足够工作量进入可暂停路径。 let children = std::iter::repeat_n("item", 40) .collect::>() .join(", "); + // Wide.measure 提供固定尺寸,夹具让挂起发生在布局而非业务程序构造期间。 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}))" ); + // 先完整发布初始页面,后面的取消需要恢复到这份已生效的 Mount 上下文。 let (mut session, _) = ReplSession::load(&source, "app.main", 272, 1).unwrap(); + // 保存已挂载 Mount,并以它为 owner 注册长延时任务;任务状态用来检测是否误当卸载。 session.execute("saved = item.mounts().at(0)\nreceived = ui.state(0)\ntoken = ui.after(saved, \"keep\", 60000, received.increment)", "app.main").unwrap(); + // 读取源 saved 引用,取消后直接检查其原生 Mount payload。 let globals = session.candidate.globals.unwrap(); + // 要求保留的是实际 Mount 对象;不使用重新查询出的新引用掩盖身份丢失。 let Value::Object(saved) = session .candidate .vm @@ -4029,6 +4053,7 @@ fn new_viewport_cancels_pending_layout_and_restores_saved_mount_context() { else { panic!("saved Mount"); }; + // 提交第一个视口目标,启动一轮尚未完成的 resize 布局。 let first = std::collections::BTreeMap::from([( crate::window::MAIN_WINDOW, crate::layout::Size { @@ -4036,13 +4061,17 @@ fn new_viewport_cancels_pending_layout_and_restores_saved_mount_context() { height: 600.0, }, )]); + // 有界推进到 VM 真正挂起,确保接下来的新尺寸会取消活跃续体。 for _ in 0..20 { session.resize_windows_incremental(&first, false).unwrap(); + // 观察到真实暂停调用即停止推进,避免把旧布局完成后再 resize 算作取消测试。 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 { @@ -4050,6 +4079,7 @@ fn new_viewport_cancels_pending_layout_and_restores_saved_mount_context() { height: 650.0, }, )]); + // 首次重定向还不发布新帧,同时必须清除旧 VM 暂停调用。 assert!( session .resize_windows_incremental(&latest, false) @@ -4057,14 +4087,17 @@ fn new_viewport_cancels_pending_layout_and_restores_saved_mount_context() { .is_none() ); assert!(!session.candidate.vm.has_suspended_call()); + // 直接查看保存句柄的 payload:应恢复已挂载标志、清除临时 layout 并保留旧宽度。 let mount = session .candidate .vm .payload::(saved, "Mount") .unwrap(); + // 取消准备工作不等于卸载;恢复状态后才继续完整收敛新布局。 assert!(mount.mounted); assert!(mount.layout.is_none()); assert_eq!(mount.geometry.width, 2.0); + // 完成最新视口下的发布,再确认会话健康、原 owner 任务仍 pending,且只取消过一次。 assert!(session.resize_windows(&latest).unwrap().is_some()); assert!(!session.is_faulted()); assert_eq!( @@ -4078,28 +4111,36 @@ fn new_viewport_cancels_pending_layout_and_restores_saved_mount_context() { /// 增量加载含 80 个出现位置的新候选,在初始布局尚未发布时替换视口目标。 /// 候选文档在完成前始终为空;重新收敛后构建计数仍为 1、挂载计数恰好 80,证明取消只重做布局。 fn candidate_initial_layout_retargets_without_reexecuting_program_or_hooks() { + // 80 个共享出现位置使首次候选布局跨片执行,为发布前的视口替换提供可观察窗口。 let children = std::iter::repeat_n("item", 80) .collect::>() .join(", "); + // built 仅在程序顶层递增,mounted 在每个 onMount 递增,分别检测源码和生命周期是否重放。 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(); + // 以 VM 的暂停调用作为取消前提,不能仅凭 has_pending_refresh 判断当前阶段。 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 { @@ -4107,10 +4148,12 @@ fn candidate_initial_layout_retargets_without_reexecuting_program_or_hooks() { height: 650.0, }, )]); + // 先触发旧续体取消,再通过同步包装推进到最新目标下的完整首帧。 candidate .resize_windows_incremental(&latest, false) .unwrap(); assert!(!candidate.candidate.vm.has_suspended_call()); + // 最后一个宽 2 的子项位于 79×2=158;正确几何之外还要核对程序仅构建一次、挂载恰好 80 次。 let settled = candidate.resize_windows(&latest).unwrap().unwrap(); assert_eq!(settled.frame.mounts.last().unwrap().x, 158.0); assert_eq!( @@ -4124,6 +4167,7 @@ fn candidate_initial_layout_retargets_without_reexecuting_program_or_hooks() { .value, "80" ); + // 取消统计应恰好一次,证明改变视口确实经过候选布局重定向路径。 assert_eq!(source_measure_stat(&mut candidate, "layoutCancels"), 1); } @@ -4131,14 +4175,19 @@ fn candidate_initial_layout_retargets_without_reexecuting_program_or_hooks() { /// 一次输入递增计数、改宽度并返回值,源执行结束后布局继续 Pending。 /// 此时禁止新 mutation/命令投影,保留旧文档;换视口后最终几何更新,但返回值和递增都只发生一次。 fn incremental_input_retains_value_and_never_replays_source_while_retargeting() { + // 构造 80 个共享 item 的 Row,确保一次宽度更新需要分片布局。 let children = std::iter::repeat_n("item", 80) .collect::>() .join(", "); + // count 记录顶层输入执行次数;item.width 更新后影响全部出现位置。 let source = format!( "count = ui.state(0)\nitem = RectBlock(2,20)\npage = Page()\npage.render(Row(0,0,{children}))" ); + // 先完整发布旧页面,后续 Pending 期间必须继续保留其版本。 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", @@ -4146,24 +4195,29 @@ fn incremental_input_retains_value_and_never_replays_source_while_retargeting() &first, ) .unwrap(); + // 业务结果此时已经是 1,但没有新文档;待刷新时不能消费窗口命令或提交另一条修改。 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(); + // 只在 VM 实际挂起时结束推进,保证换视口取消的是活跃工作。 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 { @@ -4171,7 +4225,9 @@ fn incremental_input_retains_value_and_never_replays_source_while_retargeting() height: 650.0, }, )]); + // 先触发重定向,再同步收敛至新帧,不能重新调用 execute_incremental。 session.resize_windows_incremental(&latest, false).unwrap(); + // 宽度已变为 3,最后子项 x=79×3=237;返回值及当前 count 都仍为 1,排除源码重放。 let settled = session.resize_windows(&latest).unwrap().unwrap(); assert_eq!(settled.frame.mounts.last().unwrap().x, 237.0); assert_eq!(result.value, "1"); @@ -4186,19 +4242,24 @@ fn incremental_input_retains_value_and_never_replays_source_while_retargeting() /// 点击回调先改变业务计数,再通过多次增量刷新完成大树布局。 /// 挂起期间旧文档版本不变,最终计数为 1 且 refreshYields 大于零,避免分片时重放 click。 fn incremental_event_runs_callback_once_before_publishing_its_layout() { + // 重复 80 个 item 增加刷新工作量,按钮回调只负责递增 count。 let children = std::iter::repeat_n("item", 80) .collect::>() .join(", "); + // 计数通过 ui.textOf 可视化,点击后必须产生真实布局/绘制刷新而非仅后台字段更新。 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(); + // 事件身份与初始文档一致;无坐标的直接目标 click 专注测试回调与增量刷新衔接。 let input = crate::events::Input { window: crate::window::MAIN_WINDOW, session: session.id, @@ -4211,18 +4272,24 @@ fn incremental_event_runs_callback_once_before_publishing_its_layout() { tab_drop: None, screen_position: None, }; + // 不额外改变窗口尺寸,只推进该次事件已启动的刷新。 let viewports = std::collections::BTreeMap::new(); + // 回调已被调用,但第一步增量派发尚未完成新文档,应留下 pending 刷新。 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; + // 反复推进同一刷新;不得重新 dispatch input,否则会重复执行业务回调。 for _ in 0..1000 { + // 只有返回 Some(document) 才标记完成,None 仍表示分片尚未发布。 if session .resize_windows_incremental(&viewports, false) .unwrap() @@ -4232,6 +4299,7 @@ fn incremental_event_runs_callback_once_before_publishing_its_layout() { break; } } + // 必须完成并清除 pending;最后计数仍为 1,统计中应实际观察到过让出。 assert!(complete); assert!(!session.has_pending_refresh()); assert_eq!( @@ -4245,15 +4313,20 @@ fn incremental_event_runs_callback_once_before_publishing_its_layout() { /// 只用原生布局的大树也应进入可恢复路径。 /// Pending 期间保留旧帧,换视口取消后重算仍产出最后子项 x=158/width=2,并记录切片与取消次数。 fn large_intrinsic_layout_yields_and_retargets_without_geometry_loss() { + // 用 80 次共享引用放大原生 Row 的布局,测试不依赖源方法覆盖也能分片。 let children = std::iter::repeat_n("item", 80) .collect::>() .join(", "); + // 业务对象只有一个 item,所有出现各占宽 2,最后一个的预期 x 为 158。 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(); + // 记录已发布版本,Pending 时不能提前更换对外文档。 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 { @@ -4261,19 +4334,23 @@ fn large_intrinsic_layout_yields_and_retargets_without_geometry_loss() { height: 600.0, }, )]); + // 推进直到 VM 真正暂停;若只有刷新标记而无暂停,就没有覆盖续体取消。 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 { @@ -4281,8 +4358,10 @@ fn large_intrinsic_layout_yields_and_retargets_without_geometry_loss() { height: 650.0, }, )]); + // 先触发取消并检查旧暂停已清除,再继续完成新布局。 session.resize_windows_incremental(&latest, false).unwrap(); assert!(!session.candidate.vm.has_suspended_call()); + // 最终仍为 x=158、width=2;取消一次且布局跨多片,证明不是绕开分片直接复用旧帧。 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); @@ -4294,12 +4373,16 @@ fn large_intrinsic_layout_yields_and_retargets_without_geometry_loss() { /// 两个立即就绪任务都递增同一状态,首次 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(); + // 第一次 poll 交付 a 并启动刷新;尚无完成文档,has_pending_refresh 应为真。 assert!( session .poll_tasks_incremental(&viewports) @@ -4307,6 +4390,7 @@ fn idle_tasks_wait_for_prior_callback_refresh_before_next_delivery() { .is_none() ); assert!(session.has_pending_refresh()); + // 第二次 poll 不能越过未完成刷新再交付 b。 assert!( session .poll_tasks_incremental(&viewports) @@ -4319,6 +4403,7 @@ fn idle_tasks_wait_for_prior_callback_refresh_before_next_delivery() { .layout_version, old_version ); + // 完成第一回调对应的文档,核对版本前进、状态为 1、a 完成而 b 仍 pending。 let first = session.resize_windows(&viewports).unwrap().unwrap(); assert!(first.frame.layout_version > old_version); assert_eq!( @@ -4333,6 +4418,7 @@ fn idle_tasks_wait_for_prior_callback_refresh_before_next_delivery() { session.execute("b.status()", "app.main").unwrap().value, "\"pending\"" ); + // 第一帧完成后才允许 b 交付;再收敛其刷新,应看到状态为 2 且 b 完成。 session.poll_tasks_incremental(&viewports).unwrap(); assert!(session.has_pending_refresh()); session.resize_windows(&viewports).unwrap(); @@ -4350,6 +4436,7 @@ fn idle_tasks_wait_for_prior_callback_refresh_before_next_delivery() { /// 启动增量 resize 后尝试普通 mutation,应拒绝但不使 VM fault。 /// 逐次推进时每个未完成返回都保持旧文档版本,只有整体完成才一次发布新版本并清除 pending。 fn incremental_viewport_refresh_retains_published_documents_until_complete() { + // 源 flex 约束示例提供多阶段布局工作,用来检验视口刷新期间的发布原子性。 let (mut session, _) = ReplSession::load( include_str!("../../../examples/flex-constraints.endor"), "app.main", @@ -4357,9 +4444,11 @@ fn incremental_viewport_refresh_retains_published_documents_until_complete() { 1, ) .unwrap(); + // 从会话当前文档表保存完整帧版本,后续每个未完成切片都逐次核对。 let old_version = session.documents[&crate::window::MAIN_WINDOW] .frame .layout_version; + // 窗口 1 的新逻辑尺寸是本轮刷新目标,循环中保持该目标不变。 let viewports = std::collections::BTreeMap::from([( crate::window::MAIN_WINDOW, crate::layout::Size { @@ -4367,6 +4456,7 @@ fn incremental_viewport_refresh_retains_published_documents_until_complete() { height: 600.0, }, )]); + // 第一步启动刷新并返回 None;此时普通修改应被拒绝,但不应让健康 VM fault。 assert!( session .resize_windows_incremental(&viewports, false) @@ -4376,8 +4466,11 @@ fn incremental_viewport_refresh_retains_published_documents_until_complete() { assert!(session.has_pending_refresh()); assert!(session.execute("blocked = 1", "app.main").is_err()); assert!(!session.is_faulted()); + // 记录实际发布完成,避免循环上限耗尽却误判成功。 let mut completed = false; + // 逐片推进直到发布;每次 None 后立即确认旧文档版本仍保持。 for _ in 0..1000 { + // 只在完整新文档返回时检查版本增加与 pending 清除,并停止推进。 if let Some(document) = session .resize_windows_incremental(&viewports, false) .unwrap() @@ -4387,6 +4480,7 @@ fn incremental_viewport_refresh_retains_published_documents_until_complete() { completed = true; break; } + // 仍未完成的分支必须保留原文档版本,不能只在循环结束时检查最终结果。 assert_eq!( session.documents[&crate::window::MAIN_WINDOW] .frame @@ -4394,6 +4488,7 @@ fn incremental_viewport_refresh_retains_published_documents_until_complete() { old_version ); } + // 确认循环获得了新帧且刷新统计确实发生过让出,覆盖增量而非同步完成路径。 assert!(completed); assert!(source_measure_stat(&mut session, "refreshYields") > 0); } @@ -4402,13 +4497,17 @@ fn incremental_viewport_refresh_retains_published_documents_until_complete() { /// 绕过会话同步包装,直接调用桥接 begin_layout_frame 观察首个 Pending。 /// 循环把工作所有权传回 resume,最终 Complete 才断言完整几何,且 VM 不再残留挂起调用。 fn bridge_layout_can_return_pending_before_committing_a_complete_frame() { + // 40 次共享出现加上源 Row.measure,让桥接布局入口返回可恢复工作。 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}))" ); + // 先建立有效 VM/桥接状态,再绕过会话同步包装直接测试桥接分片接口。 let (mut session, _) = ReplSession::load(&source, "app.main", 270, 1).unwrap(); + // 变更视口约束,防止布局完全沿用初始缓存。 session .bridge .set_viewport( @@ -4419,28 +4518,35 @@ fn bridge_layout_can_return_pending_before_committing_a_complete_frame() { }), ) .unwrap(); + // 只准备根节点,后续 begin_layout_frame 才启动可分片布局。 let root = session .bridge .prepare_frame(&mut session.candidate.vm) .unwrap() .unwrap(); + // 保存工作枚举所有权,每次 Pending 都要把续体重新交回 resume。 let mut progress = session .bridge .begin_layout_frame(&mut session.candidate.vm, root) .unwrap(); + // 首次必须为 Pending 且 VM 有暂停调用,否则未测到桥接的恢复契约。 assert!(matches!( progress, crate::ui_bridge::LayoutProgress::Pending(_) )); assert!(session.candidate.vm.has_suspended_call()); + // 按返回状态继续推进,只有 Complete 分支允许读取最终几何。 loop { + // Pending 携带尚未完成的独占工作;Complete 则携带可检查的完整帧。 match progress { + // 将本片返回的工作移动回桥接,不复制也不重新创建布局,保留已完成片段。 crate::ui_bridge::LayoutProgress::Pending(pending) => { progress = session .bridge .resume_layout_frame(&mut session.candidate.vm, *pending) .unwrap(); } + // 最后子项位置为 39×2=78;完成后 VM 不得遗留暂停调用。 crate::ui_bridge::LayoutProgress::Complete(frame) => { assert_eq!(frame.mounts.last().unwrap().x, 78.0); assert!(!session.candidate.vm.has_suspended_call()); @@ -4454,13 +4560,17 @@ fn bridge_layout_can_return_pending_before_committing_a_complete_frame() { /// 同一 item 在 Row 中重复 40 次,布局需跨多个 VM 切片。 /// 完整帧不能丢失出现位置,第 40 个的 x=78 且 Mount 数量覆盖容器与全部子项。 fn layout_slices_preserve_all_shared_occurrences() { + // 同一业务 item 重复出现 40 次;丢失某个 Mount 会直接改变数量或末项几何。 let children = std::iter::repeat_n("item", 40) .collect::>() .join(", "); + // 源父测量配合原生 Row 排列,跨多个 VM 布局切片验证出现位置保留。 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(); + // 完整帧至少包含容器及 40 个子项,最后一个出现的源 bounds.x 必须为 78。 initial.validate().unwrap(); assert!(initial.frame.mounts.len() >= 41); assert!(source_measure_stat(&mut session, "layoutSlices") > 1); @@ -4477,6 +4587,7 @@ fn layout_slices_preserve_all_shared_occurrences() { /// 有限 Row 把带换行文字的 flex Column 缩窄,文字自然高度必须重新测量,不能沿用早期宽约束下的一行高度。 /// 将文字改短后高度回到 20,确认新求解不把先前分配冻结为永久尺寸。 fn nested_flex_refreshes_natural_height_when_cross_width_changes() { + // 父 Row 只提供 240 宽,内部 flex Column 的文字需在最终分配宽度下重新测量自然高度。 let (mut session, initial) = ReplSession::load( r#" class Narrow: Row { @@ -4494,14 +4605,18 @@ fn nested_flex_refreshes_natural_height_when_cross_width_changes() { 1, ) .unwrap(); + // 先确认发布文档有效,再通过源 Mount API 读取真实排列后的文字高度。 initial.validate().unwrap(); + // 把源返回的数值转为浮点,比较是否多于一行 20;不能冻结首次宽测量得到的单行高度。 let height: f32 = session .execute("paragraph.mounts().at(0).bounds().height", "app.main") .unwrap() .value .parse() .unwrap(); + // 长文字在窄约束下必须换行;随后改短以检验新一轮求解没有沿用旧的分配高度。 assert!(height > 20.0); + // 只改原 paragraph 的文字,下一帧应重测为单行 20,而非替换整棵布局树。 session .execute("paragraph.setText(\"short\")", "app.main") .unwrap(); @@ -4518,6 +4633,8 @@ fn nested_flex_refreshes_natural_height_when_cross_width_changes() { /// 给两个 flex 子项显式 basis、不同增长权重和最大宽度,检查达到上限后剩余空间再分配。 /// 随后切换为收缩并让首项触及最小值,再恢复 auto basis,验证每次新求解都重新计算自然尺寸。 fn bounded_flex_redistributes_growth_and_scaled_shrink() { + // 父宽 340 扣两侧 padding 20、两个 gap 共 20、固定项 60,留给两个 flex 项的总宽为 240。 + // 各 basis 为 100,增长权重 1:3;首项达到 max=105 后,多余空间应重新分配给第二项。 let (mut session, initial) = ReplSession::load( r#" class Wide: Row { @@ -4540,22 +4657,28 @@ fn bounded_flex_redistributes_growth_and_scaled_shrink() { 1, ) .unwrap(); + // 确认最终帧合法,以下查询必须读取出现位置几何,不能只读业务 width 自然值。 initial.validate().unwrap(); + // 本测试闭包按业务名查询首个 Mount 的宽度,供三轮求解共用。 let width = |session: &mut ReplSession, name| { session .execute(&format!("{name}.mounts().at(0).bounds().width"), "app.main") .unwrap() .value }; + // 增长阶段分配为 105/135,总宽仍为 240;首项被上限冻结后剩余增长量转给第二项。 assert_eq!(width(&mut session, "first"), "105"); assert_eq!(width(&mut session, "second"), "135"); + // 切换为无增长、等收缩权重且 basis 均为 200;首项 min=150 触底后,其余收缩应由第二项承担。 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(); + // 收缩结果为 150/90,固定项仍为 60;不能把固定项也拿来吸收缺口。 assert_eq!(width(&mut session, "first"), "150"); assert_eq!(width(&mut session, "second"), "90"); assert_eq!(width(&mut session, "fixed"), "60"); + // 恢复 auto basis 并移除首项界限,求解应从自然宽 20/40 重新开始,不沿用前次分配。 session.execute( "first.flexMin = 0\nfirst.flexMax = 1000000\nfirst.flexBasis = \"auto\"\nsecond.flexBasis = \"auto\"", "app.main", @@ -4568,6 +4691,7 @@ fn bounded_flex_redistributes_growth_and_scaled_shrink() { /// 同一段文字分别出现在两个 Row;首个 Row 的可伸缩兄弟权重改变会挤窄文字。 /// 只第一个出现位置的换行高度增加,第二个保持原高度,证明约束与自然尺寸缓存按 Mount 隔离。 fn native_flex_reflows_shared_text_per_occurrence() { + // 同一 paragraph 分别挂到两个 Row;只有首个 Row 的兄弟 filler 具有后续会改动的增长权重。 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.") @@ -4584,7 +4708,9 @@ fn native_flex_reflows_shared_text_per_occurrence() { 1, ) .unwrap(); + // 先验证完整发布,再按 Mount 索引分别读取共享文字的两个出现高度。 initial.validate().unwrap(); + // 闭包返回指定出现位置的最终高度,显式转 f32 供换行高度比较使用。 let height = |session: &mut ReplSession, index| -> f32 { session .execute( @@ -4596,9 +4722,13 @@ fn native_flex_reflows_shared_text_per_occurrence() { .parse() .unwrap() }; + // 首个出现的初始高度作为受影响位置的基线。 let before = height(&mut session, 0); + // 第二个出现单独保存基线,验证修改另一个父上下文不会污染其测量缓存。 let other = height(&mut session, 1); + // 先确认夹具确实让两个位置获得不同换行高度,而非恰好相同的约束。 assert!(before > other); + // 增大首个 Row 兄弟的权重以挤窄文字;只有第一个出现应增高,第二个必须保持基线。 session.execute("filler.flex = 3", "app.main").unwrap(); assert!(height(&mut session, 0) > before); assert_eq!(height(&mut session, 1), other); @@ -4608,6 +4738,7 @@ fn native_flex_reflows_shared_text_per_occurrence() { /// 有限宽度 Row 先扣 padding、gap 与固定子项,再把 240 剩余宽度按 1:2 分配。 /// 修改权重为 3:1 后同一出现位置实时改为 180/60,验证分配结果反过来约束子测量。 fn weighted_flex_remeasures_children_and_updates_live_weights() { + // 父宽 340 扣除 padding 20、gap 20 和固定项 60,剩余 240 由 first/last 按增长权重分配。 let (mut session, initial) = ReplSession::load(r#" class Wide: Row { function measure(self: Wide, mount: Mount, constraints: Constraints): MeasureResult { return MeasureResult(340, 40) } @@ -4621,6 +4752,7 @@ fn weighted_flex_remeasures_children_and_updates_live_weights() { page = Page() page.render(row) "#, "app.main", 265, 1).unwrap(); + // 有效首帧中权重 1:2 应分得 80/160,检查 Mount 宽度而不是自然业务 width。 initial.validate().unwrap(); assert_eq!( session @@ -4636,6 +4768,7 @@ fn weighted_flex_remeasures_children_and_updates_live_weights() { .value, "160" ); + // 在同一会话把权重改成 3:1,依赖变化应重新分配为 180/60,不能沿用首次分配缓存。 session .execute("first.flex = 3\nlast.flex = 1", "app.main") .unwrap(); @@ -4659,6 +4792,7 @@ fn weighted_flex_remeasures_children_and_updates_live_weights() { /// 表驱动切换 start/center/end/space-between,逐项比较两个子项的 x。 /// 子项宽度始终为自然宽度,mainAlign 只分配剩余间隙,不应被误当成 flex 拉伸。 fn main_alignment_updates_live_geometry_without_changing_sizes() { + // 固定父宽 300、左右 padding 各 10,两子项自然宽 20/40、基础间距 10,留出可对齐的剩余空间。 let (mut session, initial) = ReplSession::load(r#" class Wide: Row { function measure(self: Wide, mount: Mount, constraints: Constraints): MeasureResult { return MeasureResult(300, 60) } @@ -4669,16 +4803,20 @@ fn main_alignment_updates_live_geometry_without_changing_sizes() { page = Page() page.render(row) "#, "app.main", 264, 1).unwrap(); + // 确认基线可发布,后面只改 mainAlign 属性,不重新创建容器或子项。 initial.validate().unwrap(); + // 枚举四种主轴对齐模式及两个预期 x:center 平分剩余空间,end 全放前部,space-between 放入项间。 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(); + // 先核对首项和第二项位置,再检查首项自然宽仍为 20;对齐不应变成 flex 拉伸。 assert_eq!( session .execute("first.mounts().at(0).bounds().x", "app.main") @@ -4707,6 +4845,7 @@ fn main_alignment_updates_live_geometry_without_changing_sizes() { /// 同一 RectBlock 分别放在 Row 和 Column,以两个父容器的 crossAlign 得到独立坐标。 /// alignSelf 显式值覆盖各父策略,恢复 auto 后再次继承,且修改一个父容器不影响另一个出现位置。 fn cross_alignment_is_live_and_specific_to_each_parent_occurrence() { + // 共享矩形分别出现在 Row 与 Column,交叉轴方向不同;父策略分别为 center 与 end。 let (mut session, initial) = ReplSession::load(r#" class Tall: Row { function measure(self: Tall, mount: Mount, constraints: Constraints): MeasureResult { return MeasureResult(200, 100) } @@ -4722,18 +4861,22 @@ fn cross_alignment_is_live_and_specific_to_each_parent_occurrence() { page = Page() page.render(Column(0, 0, row, column)) "#, "app.main", 294, 1).unwrap(); + // 先验证初始帧,随后核对两个出现位置各自的坐标,包含第二容器在外层 Column 中的偏移。 initial.validate().unwrap(); + // 首项在 Row 的 y 上居中,次项在 Column 的 x 上靠末端,不能把两个父上下文合并。 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"), ] { + // 逐表达式读取源 Mount 几何,让位置比较覆盖实际发布布局而非静态属性。 assert_eq!( session.execute(expression, "app.main").unwrap().value, expected ); } + // 业务对象上的显式 start 覆盖两个父容器的默认策略,两处交叉轴位置都应回到 padding 起点。 session .execute("shared.alignSelf = \"start\"", "app.main") .unwrap(); @@ -4751,6 +4894,7 @@ fn cross_alignment_is_live_and_specific_to_each_parent_occurrence() { .value, "10" ); + // 恢复 auto 后重新继承各自父策略;只把 Row 改为 end,Column 的另一出现应仍保持原来的 end。 session .execute( "shared.alignSelf = \"auto\"\nrow.crossAlign = \"end\"",