EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
refactor(ui-egui): move src/panels/viewer_text.rs tests to src/panels/viewer_text/tests.rs
aiongg2f26ee2e242d
diff --git a/crates/ui-egui/src/panels/viewer_text.rs b/crates/ui-egui/src/panels/viewer_text.rsindex 5fe55638e..f2becd9b1 100644--- a/crates/ui-egui/src/panels/viewer_text.rs+++ b/crates/ui-egui/src/panels/viewer_text.rs@@ -1424,825 +1424,4 @@ fn draw(app: &mut EffectcraftApp, ui: &mut egui::Ui, painter: &egui::Painter, ma}#[cfg(test)]-mod tests {- //! Incoming IME edits on the custom text editor (the Type tool's own session, not a stock- //! `TextEdit`). Winit reports the bytes around the selection *before* the commit it belongs- //! to, so the deletion and the insert must share one undo step.-- use super::*;- use effectcraft_engine::Session;- use effectcraft_engine::commands::text_edit::TextEdit;- use serde_json::json;-- fn editor(text: &str, anchor: usize, caret: usize) -> (EffectcraftApp, LayerId) {- let mut s = Session::default();- s.execute("comp.new", json!({"name": "IME", "width": 160, "height": 90, "duration": 1})).unwrap();- let layer = s.execute("layer.newText", json!({"text": text})).unwrap()["layer"].as_u64().unwrap();- let lid = LayerId(layer);- s.state.text_edit = Some(TextEdit { layer: lid, anchor, caret, ..Default::default() });- (EffectcraftApp::new(s), lid)- }-- fn doc_text(app: &EffectcraftApp, lid: LayerId) -> String {- layer_doc(&app.session, lid).map(|d| d.text).unwrap_or_default()- }-- fn feed(app: &mut EffectcraftApp, events: Vec<egui::Event>) {- let ctx = egui::Context::default();- let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(320.0, 180.0))), events, ..Default::default() };- let mut out = ctx.run_ui(raw, |ui| keyboard(app, ui, egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(320.0, 180.0))));- out.textures_delta.clear();- }-- #[test]- fn preedit_preview_is_bounded_on_a_character_boundary() {- let text = "é".repeat(MAX_IME_TEXT_BYTES);- let capped = bounded_preedit(text);- assert!(capped.len() <= MAX_IME_TEXT_BYTES);- assert!(capped.is_char_boundary(capped.len()));- assert_eq!(capped.len() % "é".len(), 0, "the cap never leaves half a character");- }-- /// Ending the edit from another panel clears this viewport's pre-edit. The production path- /// used to resolve `viewport_id()` (a context read lock) inside `data_mut` (a write lock);- /// that nested context access deadlocked every pass that drew the viewer.- #[test]- fn ending_an_edit_from_another_panel_clears_the_preedit() {- let (mut app, lid) = editor("abc", 0, 0);- let session = app.session.state.text_edit.as_ref().map_or(1, |e| e.session);- let ctx = egui::Context::default();- let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {- let viewport = ui.ctx().viewport_id();- let preedit = Preedit { owner: ImeOwner { layer: lid, session }, text: "x".into() };- ui.data_mut(|d| d.insert_temp(ime_preedit_id(viewport), preedit));- panel_clicked(&mut app, ui.ctx(), PanelKind::Timeline);- let viewport = ui.ctx().viewport_id();- assert!(ui.data(|d| d.get_temp::<Preedit>(ime_preedit_id(viewport))).is_none(), "the ended edit leaves no preview behind");- });- out.textures_delta.clear();- assert!(app.session.state.text_edit.is_none(), "a click in the Timeline ends the text edit");- }-- #[test]- fn ime_delete_surrounding_bytes_and_the_commit_are_one_undo_step() {- // "café😀": the last character is four bytes, so a byte-count deletion that treated bytes- // as characters would corrupt the document.- let (mut app, lid) = editor("café😀", 5, 5);- feed(- &mut app,- vec![- egui::Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes: 4, after_bytes: 0 }),- egui::Event::Ime(egui::ImeEvent::Commit("X".into())),- ],- );- assert_eq!(doc_text(&app, lid), "caféX", "the emoji is replaced by the committed text");- app.session.execute("edit.undo", json!({})).unwrap();- assert_eq!(doc_text(&app, lid), "café😀", "the replacement is one undo step");- }-- #[test]- fn ime_delete_surrounding_chars_keeps_the_selection_for_the_commit() {- // Stock egui deletes the characters around the selection, not the selection itself: the- // commit that follows replaces "bcd", it does not insert next to a deleted document.- let (mut app, lid) = editor("abcdef", 1, 4);- feed(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurrounding { before_chars: 1, after_chars: 99 })]);- assert_eq!(doc_text(&app, lid), "bcd", "one character before and everything after go");- let sel = app.session.state.text_edit.clone().expect("editing continues");- assert_eq!(sel.range(), 0..3, "the selected text is still selected");- // A deletion-only batch (no commit) leaves "bcd", not an empty document.- app.session.execute("edit.undo", json!({})).unwrap();- assert_eq!(doc_text(&app, lid), "abcdef", "clamped deletion is still one undo step");-- // Delete surround + commit: the commit replaces the kept selection.- let (mut app, lid) = editor("abcdef", 1, 4);- feed(- &mut app,- vec![- egui::Event::Ime(egui::ImeEvent::DeleteSurrounding { before_chars: 1, after_chars: 99 }),- egui::Event::Ime(egui::ImeEvent::Commit("XY".into())),- ],- );- assert_eq!(doc_text(&app, lid), "XY", "the commit replaces the selection");- app.session.execute("edit.undo", json!({})).unwrap();- assert_eq!(doc_text(&app, lid), "abcdef", "the deletion and its commit are one undo step");- }-- /// One UI pass with the editor focused, events applied, and the overlay's observation.- struct ImePass {- ctx: egui::Context,- viewport: egui::ViewportId,- rect: egui::Rect,- }-- impl ImePass {- fn new(viewport: egui::ViewportId) -> Self {- let ctx = egui::Context::default();- install_hooks(&ctx);- Self { ctx, viewport, rect: egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(320.0, 180.0)) }- }-- /// Run one `Context` frame. `overlay` is false for a pass in which the viewer (and so- /// the edit overlay) never drew; `discard` forces a second pass of the same frame.- fn frame(&mut self, app: &mut EffectcraftApp, events: Vec<egui::Event>, overlay: bool, discard: bool) -> Option<egui::output::IMEOutput> {- let ctx = self.ctx.clone();- let rect = self.rect;- let viewport = self.viewport;- let mut viewports = egui::ViewportIdMap::default();- viewports.insert(self.viewport, egui::ViewportInfo::default());- let raw = egui::RawInput { viewport_id: self.viewport, viewports, screen_rect: Some(rect), events, ..Default::default() };- let mut asked = false;- let mut out = ctx.run_ui(raw, |ui| {- begin_ui(ui.ctx());- ui.interact(rect, focus_id(), egui::Sense::focusable_noninteractive());- ui.memory_mut(|m| m.request_focus(focus_id()));- sync_ime_target(ui, app);- keyboard(app, ui, rect);- if overlay {- let pass = ui.ctx().cumulative_pass_nr_for(viewport);- ui.data_mut(|d| d.insert_temp(ime_geometry_id(viewport), (pass, rect, rect)));- }- finish_ime(app, ui);- if discard && !asked {- asked = true;- ui.ctx().request_discard("ime pass test");- }- });- out.textures_delta.clear();- out.platform_output.ime- }- }-- /// One native floating window holding the Timeline's group and then the Viewer's.- fn two_group_window() -> craft_ui::docking::Floating<PanelKind> {- let groups = vec![craft_ui::docking::Group::new(vec![PanelKind::Timeline], 0), craft_ui::docking::Group::new(vec![PanelKind::Viewer(1)], 0)];- craft_ui::docking::Floating::stack(groups, [0.0, 0.0, 320.0, 360.0]).expect("two groups make a window")- }-- impl ImePass {- /// One pass of a native window with a body that edits no text and the Viewer's editor,- /// in the order given, publishing as `NativeIme` decides or, with `every`, after each- /// body. Returns the descriptor and the preedit the pass ended with.- fn window(- &mut self,- app: &mut EffectcraftApp,- window: &craft_ui::docking::Floating<PanelKind>,- events: Vec<egui::Event>,- viewer_first: bool,- every: bool,- ) -> (Option<egui::output::IMEOutput>, Option<String>) {- let ctx = self.ctx.clone();- let (rect, viewport) = (self.rect, self.viewport);- let mut viewports = egui::ViewportIdMap::default();- viewports.insert(viewport, egui::ViewportInfo::default());- let raw = egui::RawInput { viewport_id: viewport, viewports, screen_rect: Some(rect), events, ..Default::default() };- let mut preedit = None;- let mut out = ctx.run_ui(raw, |ui| {- let mut ime = crate::dock_ui::NativeIme::new(std::slice::from_ref(window), &[]);- let order = if viewer_first { [true, false] } else { [false, true] };- for viewer in order {- if ime.begin_body(viewport) {- begin_ui(ui.ctx());- }- if viewer {- ui.interact(rect, focus_id(), egui::Sense::focusable_noninteractive());- ui.memory_mut(|m| m.request_focus(focus_id()));- sync_ime_target(ui, app);- keyboard(app, ui, rect);- let pass = ui.ctx().cumulative_pass_nr_for(viewport);- ui.data_mut(|d| d.insert_temp(ime_geometry_id(viewport), (pass, rect, rect)));- }- if ime.publishes(viewport, ime_recorded(ui.ctx())) || every {- finish_ime(app, ui);- }- }- assert!(ime.unpublished().is_empty(), "the window published");- preedit = read_preedit(ui).map(|p| p.text);- });- out.textures_delta.clear();- (out.platform_output.ime, preedit)- }- }-- #[test]- fn native_window_with_a_group_before_the_viewer_keeps_the_composition() {- let window = two_group_window();- let viewport = craft_ui::docking::DockArea::<PanelKind>::window_viewport(crate::dock_ui::area_id(), window.id);- let preview = || egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None });- for viewer_first in [false, true] {- let (mut app, _) = editor("abcd", 4, 4);- let mut pass = ImePass::new(viewport);- let (first, preedit) = pass.window(&mut app, &window, vec![preview()], viewer_first, false);- let first = first.expect("the editor publishes");- assert_eq!(preedit.as_deref(), Some("é"));- for _ in 0..2 {- let (ime, preedit) = pass.window(&mut app, &window, vec![], viewer_first, false);- let ime = ime.expect("the editor keeps publishing");- assert!(!ime.should_interrupt_composition, "viewer first: {viewer_first}");- assert_eq!((ime.owner, ime.context_generation), (first.owner, first.context_generation), "the same IME context");- assert_eq!(preedit.as_deref(), Some("é"), "the preedit survives the other body");- }- }- // Publishing after the body drawn before the Viewer clears the preedit and interrupts.- let (mut app, _) = editor("abcd", 4, 4);- let mut pass = ImePass::new(viewport);- pass.window(&mut app, &window, vec![preview()], false, true);- let (ime, preedit) = pass.window(&mut app, &window, vec![], false, true);- assert!(ime.expect("the editor publishes").should_interrupt_composition);- assert_eq!(preedit, None);- // A window that drew fewer bodies than its layout counts publishes after every body in- // its next pass.- let mut ime = crate::dock_ui::NativeIme::new(std::slice::from_ref(&window), &[]);- ime.begin_body(viewport);- assert!(!ime.publishes(viewport, false));- let unpublished = ime.unpublished();- assert_eq!(unpublished, vec![viewport]);- let mut ime = crate::dock_ui::NativeIme::new(std::slice::from_ref(&window), &unpublished);- ime.begin_body(viewport);- assert!(ime.publishes(viewport, false));- }-- fn ime_text(ime: &egui::output::IMEOutput) -> (&str, usize, usize) {- let p = ime.surrounding_text.available().expect("committed surrounding text");- (p.text.as_str(), p.cursor, p.anchor)- }-- #[test]- fn discarded_custom_request_then_home_rearms_the_identical_caret() {- let (mut app, lid) = editor("abcd", 4, 4);- app.ui.start_screen = false;- app.ui.tool = Tool::Type;- app.ui.focused = PanelKind::Composition;- let ctx = egui::Context::default();- install_hooks(&ctx);- let mut frame = eframe::Frame::_new_kittest();- let raw = || egui::RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1200.0, 800.0))), ..Default::default() };- for _ in 0..3 {- let mut output = ctx.run_ui(raw(), |ui| {- eframe::App::logic(&mut app, ui.ctx(), &mut frame);- app.draw(ui, &frame);- });- output.textures_delta.clear();- }- let mut input = raw();- input.events.push(egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None }));- let mut output = ctx.run_ui(input, |ui| {- eframe::App::logic(&mut app, ui.ctx(), &mut frame);- app.draw(ui, &frame);- });- output.textures_delta.clear();- assert!(output.platform_output.ime.is_some());- app.session.execute("text.setSelection", json!({"caret": 1})).unwrap();- let selection = app.session.state.text_edit.clone();- let mut passes = 0;- let mut discarded = None;- let mut output = ctx.run_ui(raw(), |ui| {- passes += 1;- if passes > 1 {- app.ui.start_screen = true;- }- eframe::App::logic(&mut app, ui.ctx(), &mut frame);- app.draw(ui, &frame);- if passes == 1 {- assert!(ui.ctx().output(|output| output.ime.is_some()));- discarded = read_reset(ui.ctx()).and_then(|guard| guard.request);- ui.ctx().request_discard("custom IME descriptor discarded before Home");- }- });- output.textures_delta.clear();- assert!(passes >= 2);- let first = discarded.expect("the actual discarded custom pass requested a fence");- assert!(output.platform_output.ime.is_none());- assert!(read_reset(&ctx).unwrap().suspended);- assert!(read_reset(&ctx).unwrap().request.is_none());- assert_eq!(app.session.state.text_edit, selection, "Home did not move the model caret");- app.ui.start_screen = false;- let mut output = ctx.run_ui(raw(), |ui| {- eframe::App::logic(&mut app, ui.ctx(), &mut frame);- app.draw(ui, &frame);- });- output.textures_delta.clear();- let second = output.platform_output.ime.unwrap().reset_request.expect("same caret reactivation publishes a new real ID");- assert_ne!(first, second);- let mut output = ctx.run_ui(raw(), |ui| {- eframe::App::logic(&mut app, ui.ctx(), &mut frame);- app.draw(ui, &frame);- });- output.textures_delta.clear();- assert!(output.platform_output.ime.unwrap().reset_request.is_none());- let mut input = raw();- input.events.extend([- egui::Event::ImeResetCompleted { request_id: first },- egui::Event::Ime(egui::ImeEvent::Commit("X".into())),- egui::Event::ImeResetCompleted { request_id: second },- egui::Event::Ime(egui::ImeEvent::Preedit { text: "が".into(), active_range_chars: None }),- egui::Event::Ime(egui::ImeEvent::Commit("が".into())),- ]);- let mut output = ctx.run_ui(input, |ui| {- eframe::App::logic(&mut app, ui.ctx(), &mut frame);- app.draw(ui, &frame);- });- output.textures_delta.clear();- assert_eq!(doc_text(&app, lid), "aがbcd");- }-- #[test]- fn viewport_fences_and_duplicate_completion_keep_their_exact_lifetime() {- let (mut app, lid) = editor("abcd", 4, 4);- let mut root = ImePass::new(egui::ViewportId::ROOT);- let mut detached = ImePass::new(egui::ViewportId::from_hash_of("effect-ime-detached"));- let preview = || egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None });- root.frame(&mut app, vec![preview()], true, false);- detached.frame(&mut app, vec![preview()], true, false);- app.session.execute("text.setSelection", json!({"caret": 1})).unwrap();- let first = root.frame(&mut app, vec![], true, false).unwrap().reset_request.unwrap();- let second = detached.frame(&mut app, vec![], true, false).unwrap().reset_request.unwrap();- assert_ne!(first, second);- detached.frame(&mut app, vec![egui::Event::ImeResetCompleted { request_id: first }, egui::Event::Ime(egui::ImeEvent::Commit("X".into()))], true, false);- assert_eq!(doc_text(&app, lid), "abcd");- let pending = detached.ctx.data(|data| data.get_temp::<ResetGuard>(reset_id(detached.viewport))).unwrap().request;- assert_eq!(pending, Some(second), "a root marker cannot release the detached viewport's full ID");- let output = detached- .frame(- &mut app,- vec![- egui::Event::ImeResetCompleted { request_id: second },- preview(),- egui::Event::ImeResetCompleted { request_id: second },- egui::Event::Ime(egui::ImeEvent::Commit("が".into())),- ],- true,- false,- )- .unwrap();- assert_eq!(doc_text(&app, lid), "aがbcd");- assert!(output.reset_request.is_none(), "a duplicate control cannot reconstruct the cleared guard");- // An actual context-generation change at unchanged selection still supersedes a wait.- root.frame(&mut app, vec![], true, false);- let replaced = root.frame(&mut app, vec![], false, false);- assert!(replaced.is_none());- let replacement = root.frame(&mut app, vec![], true, false).unwrap().reset_request.unwrap();- assert_ne!(first, replacement);- }-- #[test]- fn ime_descriptor_sends_committed_text_and_preserves_a_reversed_selection() {- let (mut app, _) = editor("café😀", 2, 5);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- let first = pass.frame(&mut app, vec![], true, false).expect("the focused editor owns IME");- assert_eq!(first.owner, ime_target(&app).expect("an edit target").owner);- assert!(first.context_generation > 0);- assert_eq!(ime_text(&first), ("café😀", 9, 2), "UTF-8 bytes, with the caret's direction kept");- assert_eq!(first.change_cause, egui::ImeChangeCause::Other, "starting a context is application origin");- assert_eq!((first.rect, first.cursor_rect), (pass.rect, pass.rect), "the real caret geometry");-- let again = pass.frame(&mut app, vec![], true, false).expect("still editing");- assert_eq!(again.context_generation, first.context_generation, "an unchanged pass keeps the context");- assert_eq!(again.surrounding_text, first.surrounding_text);- }-- #[test]- fn accepted_ime_commit_is_input_method_and_ordinary_typing_is_other() {- let (mut app, lid) = editor("ab", 2, 2);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- let first = pass.frame(&mut app, vec![], true, false).expect("editing");- let generation = first.context_generation;-- let commit = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, false).expect("still editing");- assert_eq!(doc_text(&app, lid), "ab日");- assert_eq!(ime_text(&commit), ("ab日", 5, 5));- assert_eq!(commit.change_cause, egui::ImeChangeCause::InputMethod, "only the accepted commit earns it");- assert_eq!(commit.context_generation, generation, "an ordinary text change is not a new context");-- let typed = pass.frame(&mut app, vec![egui::Event::Text("x".into())], true, false).expect("still editing");- assert_eq!(doc_text(&app, lid), "ab日x");- assert_eq!(typed.change_cause, egui::ImeChangeCause::Other, "typing is application work");- assert_eq!(typed.context_generation, generation);- }-- #[test]- fn ime_delete_and_commit_chain_is_input_method_with_a_reversed_selection() {- let (mut app, lid) = editor("abcdef", 4, 1);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- pass.frame(&mut app, vec![], true, false).expect("editing");-- let deleted = pass- .frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurrounding { before_chars: 1, after_chars: 1 })], true, false)- .expect("still editing");- assert_eq!(doc_text(&app, lid), "bcdf", "one character goes before and one after the selection");- assert_eq!(ime_text(&deleted), ("bcdf", 0, 3), "the selected text and its reversed direction stay");- assert_eq!(deleted.change_cause, egui::ImeChangeCause::InputMethod);-- let committed = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("X".into()))], true, false).expect("still editing");- assert_eq!(doc_text(&app, lid), "Xf", "the commit replaces the kept selection");- assert_eq!(committed.change_cause, egui::ImeChangeCause::InputMethod, "the delete and commit are one accepted chain");- app.session.execute("edit.undo", json!({})).unwrap();- assert_eq!(doc_text(&app, lid), "abcdef", "the replacement is one undo step");- }-- #[test]- fn an_application_edit_in_the_same_frame_dominates_the_ime_cause() {- // Application edit before the IME commit.- let (mut app, lid) = editor("ab", 2, 2);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- pass.frame(&mut app, vec![], true, false).expect("editing");- let mixed = pass- .frame(&mut app, vec![egui::Event::Text("x".into()), egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, false)- .expect("still editing");- assert_eq!(doc_text(&app, lid), "abx日");- assert_eq!(mixed.change_cause, egui::ImeChangeCause::Other, "the earlier application edit dominates");-- // Application edit after the IME commit.- let (mut app, lid) = editor("ab", 2, 2);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- pass.frame(&mut app, vec![], true, false).expect("editing");- let mixed = pass- .frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into())), egui::Event::Text("x".into())], true, false)- .expect("still editing");- assert_eq!(doc_text(&app, lid), "ab日x");- assert_eq!(mixed.change_cause, egui::ImeChangeCause::Other, "the later application edit dominates");- }-- #[test]- fn preedit_is_excluded_from_the_committed_snapshot_and_keeps_the_context() {- let (mut app, lid) = editor("ab", 2, 2);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- let first = pass.frame(&mut app, vec![], true, false).expect("editing");-- let preview = pass- .frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)- .expect("still editing");- assert_eq!(doc_text(&app, lid), "ab", "the pre-edit never enters the document");- assert_eq!(ime_text(&preview), ("ab", 2, 2), "only committed text is sent");- assert_eq!(preview.context_generation, first.context_generation, "pre-edit updates keep the composition");-- let commit = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("に".into()))], true, false).expect("still editing");- assert_eq!(doc_text(&app, lid), "abに");- assert_eq!(commit.change_cause, egui::ImeChangeCause::InputMethod, "clearing the pre-edit and committing is IME work");- assert_eq!(commit.context_generation, first.context_generation);- }-- #[test]- fn empty_and_unavailable_surrounding_text_are_distinct() {- let (mut app, _) = editor("", 0, 0);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- let empty = pass.frame(&mut app, vec![], true, false).expect("editing");- assert_eq!(ime_text(&empty), ("", 0, 0), "an available-empty document is not unavailable");-- let text = "a".repeat(5000);- let (mut app, _) = editor(&text, 0, 5000);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- let wide = pass.frame(&mut app, vec![], true, false).expect("editing");- assert!(matches!(wide.surrounding_text, egui::output::IMESurroundingText::Unavailable), "a selection wider than the limit is unavailable");- assert_eq!(wide.owner, ime_target(&app).expect("an edit target").owner, "identity survives unavailable text");- }-- #[test]- fn an_unrelated_undo_keeps_a_wide_selection_composition() {- // A selection wider than the IME limit reports unavailable surrounding text, whose- // receipt identity is a revision. That revision must follow the editor, not the whole- // project: undoing an unrelated opacity change used to look like an editor mutation and- // cancel an active composition.- let text = "a".repeat(5000);- let (mut app, lid) = editor(&text, 0, 5000);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- let first = pass.frame(&mut app, vec![], true, false).expect("editing");- assert!(matches!(first.surrounding_text, egui::output::IMESurroundingText::Unavailable), "the wide selection is unavailable");-- let composing = pass- .frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)- .expect("still editing");- assert_eq!(composing.context_generation, first.context_generation, "the pre-edit keeps the context");- let owner = ime_owner(&app).expect("an editor owner");- assert!(matches!(- pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))),- Some(ImeComposition::Active(active)) if active == owner- ));-- app.session.execute("prop.set", json!({"layer": lid.0, "path": "transform/opacity", "value": 50})).unwrap();- app.session.execute("edit.undo", json!({})).unwrap();- let after = pass.frame(&mut app, vec![], true, false).expect("still editing");- assert_eq!(after.context_generation, first.context_generation, "an unrelated undo does not start a new context");- assert!(- matches!(- pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))),- Some(ImeComposition::Active(active)) if active == owner- ),- "the wide-selection composition survives an unrelated undo"- );- assert!(read_reset(&pass.ctx).is_none(), "no IME reset was requested");-- // The composition is still the live one: its commit is accepted and earns the- // input-method cause rather than being poisoned as leftover application work.- let commit = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("x".into()))], true, false).expect("still editing");- assert_eq!(doc_text(&app, lid), "x", "the preserved composition commits into the wide selection");- assert_eq!(commit.change_cause, egui::ImeChangeCause::InputMethod);- }-- #[test]- fn a_failed_batch_with_a_transient_edit_does_not_revive_a_wide_selection_composition() {- // The final document equals the pre-batch one, but the intermediate insert/delete was a- // real document change. Its IME revision must stay the high-water mark; otherwise the- // active wide-selection composition would look current and accept its old commit.- let text = "a".repeat(5000);- let (mut app, lid) = editor(&text, 0, 5000);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- pass.frame(&mut app, vec![], true, false).expect("editing");- pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)- .expect("still editing");- let owner = ime_owner(&app).expect("an editor owner");- assert!(matches!(- pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))),- Some(ImeComposition::Active(active)) if active == owner- ));-- let r = app.session.execute(- "engine.batch",- json!({"atomic": true, "steps": [- {"command": "text.insert", "params": {"text": "x", "range": [5000, 5000]}},- {"command": "text.delete", "params": {}},- {"command": "no.suchCommand", "params": {}}- ]}),- );- assert!(r.is_err());- assert_eq!(doc_text(&app, lid), text, "the batch restored the final document");-- pass.frame(&mut app, vec![], true, false).expect("still editing");- assert!(read_reset(&pass.ctx).is_some(), "the advanced revision retires the old IME context");- assert!(- matches!(pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))), Some(ImeComposition::Stale)),- "the failed batch's transient edit leaves the old composition stale"- );- let stale = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("z".into()))], true, false).expect("still editing");- assert_eq!(doc_text(&app, lid), text, "the stale composition cannot commit into the restored document");- assert_ne!(stale.change_cause, egui::ImeChangeCause::InputMethod, "a rejected commit earns no IME receipt");- }-- #[test]- fn a_wide_content_change_invalidates_the_active_composition() {- let text = "a".repeat(5000);- let (mut app, lid) = editor(&text, 0, 5000);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- pass.frame(&mut app, vec![], true, false).expect("editing");- pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)- .expect("still editing");-- let replaced = "b".repeat(5000);- app.session.execute("layer.setText", json!({"layer": lid.0, "text": replaced})).unwrap();- let after = pass.frame(&mut app, vec![], true, false).expect("still editing");- assert_eq!(doc_text(&app, lid), replaced);- assert!(after.should_interrupt_composition, "replacing the wide document starts a new IME context");- assert!(- matches!(pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))), Some(ImeComposition::Stale)),- "the old composition is stale after the content change"- );- pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("z".into()))], true, false).expect("still editing");- assert_eq!(doc_text(&app, lid), replaced, "a delayed commit from the old document is rejected");- }-- #[test]- fn a_wide_selection_change_invalidates_the_active_composition() {- let text = "a".repeat(5000);- let (mut app, lid) = editor(&text, 0, 5000);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- pass.frame(&mut app, vec![], true, false).expect("editing");- pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)- .expect("still editing");-- // Still wider than the IME window limit, so this exercises the unavailable-text- // selection identity rather than merely making the surrounding text available.- app.session.execute("text.setSelection", json!({"start": 0, "end": 4500})).unwrap();- pass.frame(&mut app, vec![], true, false).expect("still editing");- assert!(read_reset(&pass.ctx).is_some(), "an application selection change retires the composition");- assert!(- matches!(pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))), Some(ImeComposition::Stale)),- "the old composition cannot follow the selection"- );- pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("z".into()))], true, false).expect("still editing");- assert_eq!(doc_text(&app, lid), text, "the stale composition cannot mutate the wide selection");- }-- #[test]- fn replaced_edit_session_and_hidden_passes_start_a_new_context() {- let (mut app, _) = editor("text", 4, 4);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- let before = pass.frame(&mut app, vec![], true, false).expect("editing");- if let Some(edit) = app.session.state.text_edit.as_mut() {- edit.session = edit.session.wrapping_add(1);- }- let replaced = pass.frame(&mut app, vec![], true, false).expect("editing");- assert!(replaced.context_generation > before.context_generation, "a recreated target does not inherit the old context");- assert_eq!(replaced.change_cause, egui::ImeChangeCause::Other);- assert!(replaced.should_interrupt_composition, "a new replacement epoch cancels the platform composition");-- let (mut app, _) = editor("abc", 3, 3);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- let visible = pass.frame(&mut app, vec![], true, false).expect("editing");- assert!(pass.frame(&mut app, vec![], false, false).is_none(), "a hidden editor reports no IME owner");- let back = pass.frame(&mut app, vec![], true, false).expect("editing again");- assert!(back.context_generation > visible.context_generation, "reappearing starts exactly one new context");- }-- #[test]- fn preedit_from_a_replaced_target_cannot_commit_into_the_new_session() {- let (mut app, first) = editor("A", 1, 1);- let second = app.session.execute("layer.newText", json!({"text": "B"})).unwrap()["layer"].as_u64().unwrap();- let mut pass = ImePass::new(egui::ViewportId::ROOT);- pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "か".into(), active_range_chars: None })], true, false)- .expect("editing the first layer");-- app.session.execute("text.edit", json!({"layer": second, "caret": 1})).unwrap();- let switched = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, false).expect("editing the second layer");- assert_eq!(doc_text(&app, LayerId(second)), "B", "a delayed commit from the old composition is ignored");- assert_eq!(doc_text(&app, first), "A", "the old layer is not changed either");- assert_eq!(switched.owner, ime_target(&app).expect("second target").owner);- assert!(switched.should_interrupt_composition, "the target switch interrupts the old composition");- }-- #[test]- fn hidden_pass_clears_this_viewports_preedit_preview() {- let (mut app, _) = editor("ab", 2, 2);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false).expect("editing");- assert!(pass.ctx.data(|d| d.get_temp::<Preedit>(ime_preedit_id(pass.viewport))).is_some());- assert!(pass.frame(&mut app, vec![], false, false).is_none());- assert!(pass.ctx.data(|d| d.get_temp::<Preedit>(ime_preedit_id(pass.viewport))).is_none(), "a pass without the overlay clears this viewport's preview");- }-- #[test]- fn a_discarded_pass_keeps_the_frame_cause_and_the_context() {- let (mut app, lid) = editor("ab", 2, 2);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- let first = pass.frame(&mut app, vec![], true, false).expect("editing");- let committed = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, true).expect("the final pass of the frame");- assert_eq!(doc_text(&app, lid), "ab日", "the discarded pass did not replay the event");- assert_eq!(committed.change_cause, egui::ImeChangeCause::InputMethod, "an unchanged later pass keeps the frame's cause");- assert_eq!(committed.context_generation, first.context_generation, "both passes are one context");- }-- #[test]- fn two_viewports_keep_independent_ime_contexts() {- let (mut app, _) = editor("ab", 2, 2);- let mut first = ImePass::new(egui::ViewportId::ROOT);- let mut second = ImePass::new(egui::ViewportId::from_hash_of("ime-test-second-viewport"));- let one = first.frame(&mut app, vec![], true, false).expect("editing in the first viewport");- let two = second.frame(&mut app, vec![], true, false).expect("editing in the second viewport");- assert_ne!(one.context_generation, two.context_generation, "each viewport has its own generation");- let again = first.frame(&mut app, vec![], true, false).expect("editing in the first viewport");- assert_eq!(again.context_generation, one.context_generation, "the second viewport did not disturb the first");- }-- /// Draw one real `EffectcraftApp::draw` pass, so `draw`'s all-exit finalizer runs.- fn draw_app_pass(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, events: Vec<egui::Event>) -> egui::FullOutput {- let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1200.0, 800.0))), events, ..Default::default() };- let mut out = ctx.run_ui(raw, |ui| app.draw(ui, frame));- out.textures_delta.clear();- out- }-- /// One headless pass with the custom viewer and a real stock `TextEdit` side by side.- ///- /// The first call focuses the custom editor before `keyboard` (the outside press arrives- /// there). The second call leaves the stock field's focus alone, so the stock descriptor- /// is published by the same `output.ime` writer that an unrelated field would use.- fn stock_pass(- pass: &mut ImePass,- app: &mut EffectcraftApp,- events: Vec<egui::Event>,- stock: &mut String,- custom_focus: bool,- ) -> Option<egui::output::IMEOutput> {- let ctx = pass.ctx.clone();- let viewport = pass.viewport;- let custom = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(160.0, 90.0));- let stock_rect = egui::Rect::from_min_size(egui::pos2(180.0, 30.0), egui::vec2(120.0, 24.0));- let stock_id = egui::Id::unique("effectcraft-ime-test-stock");- let mut viewports = egui::ViewportIdMap::default();- viewports.insert(viewport, egui::ViewportInfo::default());- let raw = egui::RawInput { viewport_id: viewport, viewports, screen_rect: Some(pass.rect), events, ..Default::default() };- let mut out = ctx.run_ui(raw, |ui| {- begin_ui(ui.ctx());- if custom_focus {- ui.interact(custom, focus_id(), egui::Sense::focusable_noninteractive());- ui.memory_mut(|m| m.request_focus(focus_id()));- sync_ime_target(ui, app);- keyboard(app, ui, custom);- } else {- // The stock field holds focus after the outside press; keep that ownership while- // the second pass publishes the actual stock descriptor.- ui.memory_mut(|m| m.request_focus(stock_id));- }- let _ = ui.put(stock_rect, egui::TextEdit::singleline(stock).id(stock_id));- finish_ime(app, ui);- });- out.textures_delta.clear();- out.platform_output.ime- }-- #[test]- fn outside_pointer_to_stock_allocates_no_new_request_and_defers_the_replacement() {- let (mut app, lid) = editor("abcd", 4, 4);- let mut pass = ImePass::new(egui::ViewportId::ROOT);- let preview = || egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None });- pass.frame(&mut app, vec![preview()], true, false).expect("the custom editor starts a composition");- app.session.execute("text.setSelection", json!({"caret": 1})).unwrap();- let first = pass.frame(&mut app, vec![], true, false).expect("the caret change publishes a request").reset_request.expect("the real request ID");- // Complete the first interruption, then start a fresh composition with no waiting guard.- pass.frame(&mut app, vec![egui::Event::ImeResetCompleted { request_id: first }], true, false);- let active = pass.frame(&mut app, vec![preview()], true, false).expect("a fresh composition");- assert!(active.reset_request.is_none(), "a fresh composition does not wait on an old request");- assert_eq!(doc_text(&app, lid), "abcd");-- // The press outside the viewer also gives the stock field focus. It must not allocate a- // new request: core would attach that request to the stock descriptor next pass.- let outside = egui::pos2(240.0, 42.0);- let mut stock = String::new();- stock_pass(- &mut pass,- &mut app,- vec![- egui::Event::PointerMoved(outside),- egui::Event::PointerButton { pos: outside, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE },- ],- &mut stock,- true,- );- let guard = pass.ctx.data(|d| d.get_temp::<ResetGuard>(reset_id(pass.viewport))).expect("the custom guard is retired locally");- assert!(guard.suspended && guard.request.is_none(), "the outside press retires the old request without allocating another");- let stock_ime = stock_pass(&mut pass, &mut app, vec![], &mut stock, false).expect("the actual stock field owns IME");- assert_ne!(stock_ime.owner, ime_target(&app).expect("the custom target is still live").owner);- assert!(stock_ime.reset_request.is_none(), "a new outside-press request would surface on the stock output");- assert_eq!(doc_text(&app, lid), "abcd");-- // Returning to a confirmed eligible custom output allocates the one replacement.- let replacement = pass.frame(&mut app, vec![], true, false).expect("the custom editor owns IME again").reset_request.expect("the deferred replacement");- assert_ne!(first, replacement);- assert!(pass.frame(&mut app, vec![], true, false).expect("still editing").reset_request.is_none(), "the replacement is one-shot");- }-- #[test]- fn fonts_and_device_loss_all_exit_finalizers_suspend_without_allocating() {- let (mut app, _lid) = editor("abcd", 1, 1);- app.ui.start_screen = false;- app.ui.tool = Tool::Type;- app.ui.focused = PanelKind::Composition;- app.show_panel(PanelKind::Composition);- let ctx = egui::Context::default();- install_hooks(&ctx);- let frame = eframe::Frame::_new_kittest();- let preview = || egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None });- // The first pass installs fonts and the next draws the real viewer.- for _ in 0..3 {- draw_app_pass(&mut app, &ctx, &frame, vec![]);- }- draw_app_pass(&mut app, &ctx, &frame, vec![preview()]);- app.session.execute("text.setSelection", json!({"caret": 2})).unwrap();- let first = draw_app_pass(&mut app, &ctx, &frame, vec![])- .platform_output- .ime- .expect("the normal pass publishes the custom descriptor")- .reset_request- .expect("one request for the caret interruption");-- // A real font-install pass draws nothing, but `draw` still reaches the finalizer.- app.styled = false;- let fonts = draw_app_pass(&mut app, &ctx, &frame, vec![]);- assert!(!app.is_ready(), "the font-install pass cannot draw");- assert!(fonts.platform_output.ime.is_none(), "no custom descriptor is published");- let guard = ctx.data(|d| d.get_temp::<ResetGuard>(reset_id(egui::ViewportId::ROOT))).expect("the waiting guard");- assert!(guard.suspended && guard.request.is_none(), "the all-exit finalizer retired it without allocating");- let second = draw_app_pass(&mut app, &ctx, &frame, vec![])- .platform_output- .ime- .expect("returning to a drawing pass publishes the custom descriptor")- .reset_request- .expect("the deferred request");- assert_ne!(first, second);-- // The device-loss early return is the other all-exit path. Preset the close bookkeeping- // so this test does not autosave; the pass must still retire the waiting guard.- app.gpu_failure_applied = Some(true);- app.device_lost_close = Some(true);- let lost = draw_app_pass(&mut app, &ctx, &frame, vec![]);- assert!(lost.platform_output.ime.is_none(), "a lost renderer publishes no descriptor");- let guard = ctx.data(|d| d.get_temp::<ResetGuard>(reset_id(egui::ViewportId::ROOT))).expect("the waiting guard");- assert!(guard.suspended && guard.request.is_none(), "the device-loss finalizer retired it without allocating");- app.gpu_failure_applied = None;- let third = draw_app_pass(&mut app, &ctx, &frame, vec![])- .platform_output- .ime- .expect("a drawing pass publishes the custom descriptor again")- .reset_request- .expect("the deferred request is one-shot");- assert_ne!(third, second);- }-- #[test]- fn ime_delete_without_a_session_or_with_an_empty_range_does_nothing() {- let (mut app, lid) = editor("abc", 1, 1);- feed(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes: 0, after_bytes: 0 })]);- assert_eq!(doc_text(&app, lid), "abc");- app.session.state.text_edit = None;- feed(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes: 2, after_bytes: 0 })]);- assert_eq!(doc_text(&app, lid), "abc");- }-}+mod tests;diff --git a/crates/ui-egui/src/panels/viewer_text/tests.rs b/crates/ui-egui/src/panels/viewer_text/tests.rsnew file mode 100644index 000000000..787d55cc1--- /dev/null+++ b/crates/ui-egui/src/panels/viewer_text/tests.rs@@ -0,0 +1,820 @@+//! Incoming IME edits on the custom text editor (the Type tool's own session, not a stock+//! `TextEdit`). Winit reports the bytes around the selection *before* the commit it belongs+//! to, so the deletion and the insert must share one undo step.++use super::*;+use effectcraft_engine::Session;+use effectcraft_engine::commands::text_edit::TextEdit;+use serde_json::json;++fn editor(text: &str, anchor: usize, caret: usize) -> (EffectcraftApp, LayerId) {+ let mut s = Session::default();+ s.execute("comp.new", json!({"name": "IME", "width": 160, "height": 90, "duration": 1})).unwrap();+ let layer = s.execute("layer.newText", json!({"text": text})).unwrap()["layer"].as_u64().unwrap();+ let lid = LayerId(layer);+ s.state.text_edit = Some(TextEdit { layer: lid, anchor, caret, ..Default::default() });+ (EffectcraftApp::new(s), lid)+}++fn doc_text(app: &EffectcraftApp, lid: LayerId) -> String {+ layer_doc(&app.session, lid).map(|d| d.text).unwrap_or_default()+}++fn feed(app: &mut EffectcraftApp, events: Vec<egui::Event>) {+ let ctx = egui::Context::default();+ let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(320.0, 180.0))), events, ..Default::default() };+ let mut out = ctx.run_ui(raw, |ui| keyboard(app, ui, egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(320.0, 180.0))));+ out.textures_delta.clear();+}++#[test]+fn preedit_preview_is_bounded_on_a_character_boundary() {+ let text = "é".repeat(MAX_IME_TEXT_BYTES);+ let capped = bounded_preedit(text);+ assert!(capped.len() <= MAX_IME_TEXT_BYTES);+ assert!(capped.is_char_boundary(capped.len()));+ assert_eq!(capped.len() % "é".len(), 0, "the cap never leaves half a character");+}++/// Ending the edit from another panel clears this viewport's pre-edit. The production path+/// used to resolve `viewport_id()` (a context read lock) inside `data_mut` (a write lock);+/// that nested context access deadlocked every pass that drew the viewer.+#[test]+fn ending_an_edit_from_another_panel_clears_the_preedit() {+ let (mut app, lid) = editor("abc", 0, 0);+ let session = app.session.state.text_edit.as_ref().map_or(1, |e| e.session);+ let ctx = egui::Context::default();+ let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {+ let viewport = ui.ctx().viewport_id();+ let preedit = Preedit { owner: ImeOwner { layer: lid, session }, text: "x".into() };+ ui.data_mut(|d| d.insert_temp(ime_preedit_id(viewport), preedit));+ panel_clicked(&mut app, ui.ctx(), PanelKind::Timeline);+ let viewport = ui.ctx().viewport_id();+ assert!(ui.data(|d| d.get_temp::<Preedit>(ime_preedit_id(viewport))).is_none(), "the ended edit leaves no preview behind");+ });+ out.textures_delta.clear();+ assert!(app.session.state.text_edit.is_none(), "a click in the Timeline ends the text edit");+}++#[test]+fn ime_delete_surrounding_bytes_and_the_commit_are_one_undo_step() {+ // "café😀": the last character is four bytes, so a byte-count deletion that treated bytes+ // as characters would corrupt the document.+ let (mut app, lid) = editor("café😀", 5, 5);+ feed(+ &mut app,+ vec![+ egui::Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes: 4, after_bytes: 0 }),+ egui::Event::Ime(egui::ImeEvent::Commit("X".into())),+ ],+ );+ assert_eq!(doc_text(&app, lid), "caféX", "the emoji is replaced by the committed text");+ app.session.execute("edit.undo", json!({})).unwrap();+ assert_eq!(doc_text(&app, lid), "café😀", "the replacement is one undo step");+}++#[test]+fn ime_delete_surrounding_chars_keeps_the_selection_for_the_commit() {+ // Stock egui deletes the characters around the selection, not the selection itself: the+ // commit that follows replaces "bcd", it does not insert next to a deleted document.+ let (mut app, lid) = editor("abcdef", 1, 4);+ feed(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurrounding { before_chars: 1, after_chars: 99 })]);+ assert_eq!(doc_text(&app, lid), "bcd", "one character before and everything after go");+ let sel = app.session.state.text_edit.clone().expect("editing continues");+ assert_eq!(sel.range(), 0..3, "the selected text is still selected");+ // A deletion-only batch (no commit) leaves "bcd", not an empty document.+ app.session.execute("edit.undo", json!({})).unwrap();+ assert_eq!(doc_text(&app, lid), "abcdef", "clamped deletion is still one undo step");++ // Delete surround + commit: the commit replaces the kept selection.+ let (mut app, lid) = editor("abcdef", 1, 4);+ feed(+ &mut app,+ vec![+ egui::Event::Ime(egui::ImeEvent::DeleteSurrounding { before_chars: 1, after_chars: 99 }),+ egui::Event::Ime(egui::ImeEvent::Commit("XY".into())),+ ],+ );+ assert_eq!(doc_text(&app, lid), "XY", "the commit replaces the selection");+ app.session.execute("edit.undo", json!({})).unwrap();+ assert_eq!(doc_text(&app, lid), "abcdef", "the deletion and its commit are one undo step");+}++/// One UI pass with the editor focused, events applied, and the overlay's observation.+struct ImePass {+ ctx: egui::Context,+ viewport: egui::ViewportId,+ rect: egui::Rect,+}++impl ImePass {+ fn new(viewport: egui::ViewportId) -> Self {+ let ctx = egui::Context::default();+ install_hooks(&ctx);+ Self { ctx, viewport, rect: egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(320.0, 180.0)) }+ }++ /// Run one `Context` frame. `overlay` is false for a pass in which the viewer (and so+ /// the edit overlay) never drew; `discard` forces a second pass of the same frame.+ fn frame(&mut self, app: &mut EffectcraftApp, events: Vec<egui::Event>, overlay: bool, discard: bool) -> Option<egui::output::IMEOutput> {+ let ctx = self.ctx.clone();+ let rect = self.rect;+ let viewport = self.viewport;+ let mut viewports = egui::ViewportIdMap::default();+ viewports.insert(self.viewport, egui::ViewportInfo::default());+ let raw = egui::RawInput { viewport_id: self.viewport, viewports, screen_rect: Some(rect), events, ..Default::default() };+ let mut asked = false;+ let mut out = ctx.run_ui(raw, |ui| {+ begin_ui(ui.ctx());+ ui.interact(rect, focus_id(), egui::Sense::focusable_noninteractive());+ ui.memory_mut(|m| m.request_focus(focus_id()));+ sync_ime_target(ui, app);+ keyboard(app, ui, rect);+ if overlay {+ let pass = ui.ctx().cumulative_pass_nr_for(viewport);+ ui.data_mut(|d| d.insert_temp(ime_geometry_id(viewport), (pass, rect, rect)));+ }+ finish_ime(app, ui);+ if discard && !asked {+ asked = true;+ ui.ctx().request_discard("ime pass test");+ }+ });+ out.textures_delta.clear();+ out.platform_output.ime+ }+}++/// One native floating window holding the Timeline's group and then the Viewer's.+fn two_group_window() -> craft_ui::docking::Floating<PanelKind> {+ let groups = vec![craft_ui::docking::Group::new(vec![PanelKind::Timeline], 0), craft_ui::docking::Group::new(vec![PanelKind::Viewer(1)], 0)];+ craft_ui::docking::Floating::stack(groups, [0.0, 0.0, 320.0, 360.0]).expect("two groups make a window")+}++impl ImePass {+ /// One pass of a native window with a body that edits no text and the Viewer's editor,+ /// in the order given, publishing as `NativeIme` decides or, with `every`, after each+ /// body. Returns the descriptor and the preedit the pass ended with.+ fn window(+ &mut self,+ app: &mut EffectcraftApp,+ window: &craft_ui::docking::Floating<PanelKind>,+ events: Vec<egui::Event>,+ viewer_first: bool,+ every: bool,+ ) -> (Option<egui::output::IMEOutput>, Option<String>) {+ let ctx = self.ctx.clone();+ let (rect, viewport) = (self.rect, self.viewport);+ let mut viewports = egui::ViewportIdMap::default();+ viewports.insert(viewport, egui::ViewportInfo::default());+ let raw = egui::RawInput { viewport_id: viewport, viewports, screen_rect: Some(rect), events, ..Default::default() };+ let mut preedit = None;+ let mut out = ctx.run_ui(raw, |ui| {+ let mut ime = crate::dock_ui::NativeIme::new(std::slice::from_ref(window), &[]);+ let order = if viewer_first { [true, false] } else { [false, true] };+ for viewer in order {+ if ime.begin_body(viewport) {+ begin_ui(ui.ctx());+ }+ if viewer {+ ui.interact(rect, focus_id(), egui::Sense::focusable_noninteractive());+ ui.memory_mut(|m| m.request_focus(focus_id()));+ sync_ime_target(ui, app);+ keyboard(app, ui, rect);+ let pass = ui.ctx().cumulative_pass_nr_for(viewport);+ ui.data_mut(|d| d.insert_temp(ime_geometry_id(viewport), (pass, rect, rect)));+ }+ if ime.publishes(viewport, ime_recorded(ui.ctx())) || every {+ finish_ime(app, ui);+ }+ }+ assert!(ime.unpublished().is_empty(), "the window published");+ preedit = read_preedit(ui).map(|p| p.text);+ });+ out.textures_delta.clear();+ (out.platform_output.ime, preedit)+ }+}++#[test]+fn native_window_with_a_group_before_the_viewer_keeps_the_composition() {+ let window = two_group_window();+ let viewport = craft_ui::docking::DockArea::<PanelKind>::window_viewport(crate::dock_ui::area_id(), window.id);+ let preview = || egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None });+ for viewer_first in [false, true] {+ let (mut app, _) = editor("abcd", 4, 4);+ let mut pass = ImePass::new(viewport);+ let (first, preedit) = pass.window(&mut app, &window, vec![preview()], viewer_first, false);+ let first = first.expect("the editor publishes");+ assert_eq!(preedit.as_deref(), Some("é"));+ for _ in 0..2 {+ let (ime, preedit) = pass.window(&mut app, &window, vec![], viewer_first, false);+ let ime = ime.expect("the editor keeps publishing");+ assert!(!ime.should_interrupt_composition, "viewer first: {viewer_first}");+ assert_eq!((ime.owner, ime.context_generation), (first.owner, first.context_generation), "the same IME context");+ assert_eq!(preedit.as_deref(), Some("é"), "the preedit survives the other body");+ }+ }+ // Publishing after the body drawn before the Viewer clears the preedit and interrupts.+ let (mut app, _) = editor("abcd", 4, 4);+ let mut pass = ImePass::new(viewport);+ pass.window(&mut app, &window, vec![preview()], false, true);+ let (ime, preedit) = pass.window(&mut app, &window, vec![], false, true);+ assert!(ime.expect("the editor publishes").should_interrupt_composition);+ assert_eq!(preedit, None);+ // A window that drew fewer bodies than its layout counts publishes after every body in+ // its next pass.+ let mut ime = crate::dock_ui::NativeIme::new(std::slice::from_ref(&window), &[]);+ ime.begin_body(viewport);+ assert!(!ime.publishes(viewport, false));+ let unpublished = ime.unpublished();+ assert_eq!(unpublished, vec![viewport]);+ let mut ime = crate::dock_ui::NativeIme::new(std::slice::from_ref(&window), &unpublished);+ ime.begin_body(viewport);+ assert!(ime.publishes(viewport, false));+}++fn ime_text(ime: &egui::output::IMEOutput) -> (&str, usize, usize) {+ let p = ime.surrounding_text.available().expect("committed surrounding text");+ (p.text.as_str(), p.cursor, p.anchor)+}++#[test]+fn discarded_custom_request_then_home_rearms_the_identical_caret() {+ let (mut app, lid) = editor("abcd", 4, 4);+ app.ui.start_screen = false;+ app.ui.tool = Tool::Type;+ app.ui.focused = PanelKind::Composition;+ let ctx = egui::Context::default();+ install_hooks(&ctx);+ let mut frame = eframe::Frame::_new_kittest();+ let raw = || egui::RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1200.0, 800.0))), ..Default::default() };+ for _ in 0..3 {+ let mut output = ctx.run_ui(raw(), |ui| {+ eframe::App::logic(&mut app, ui.ctx(), &mut frame);+ app.draw(ui, &frame);+ });+ output.textures_delta.clear();+ }+ let mut input = raw();+ input.events.push(egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None }));+ let mut output = ctx.run_ui(input, |ui| {+ eframe::App::logic(&mut app, ui.ctx(), &mut frame);+ app.draw(ui, &frame);+ });+ output.textures_delta.clear();+ assert!(output.platform_output.ime.is_some());+ app.session.execute("text.setSelection", json!({"caret": 1})).unwrap();+ let selection = app.session.state.text_edit.clone();+ let mut passes = 0;+ let mut discarded = None;+ let mut output = ctx.run_ui(raw(), |ui| {+ passes += 1;+ if passes > 1 {+ app.ui.start_screen = true;+ }+ eframe::App::logic(&mut app, ui.ctx(), &mut frame);+ app.draw(ui, &frame);+ if passes == 1 {+ assert!(ui.ctx().output(|output| output.ime.is_some()));+ discarded = read_reset(ui.ctx()).and_then(|guard| guard.request);+ ui.ctx().request_discard("custom IME descriptor discarded before Home");+ }+ });+ output.textures_delta.clear();+ assert!(passes >= 2);+ let first = discarded.expect("the actual discarded custom pass requested a fence");+ assert!(output.platform_output.ime.is_none());+ assert!(read_reset(&ctx).unwrap().suspended);+ assert!(read_reset(&ctx).unwrap().request.is_none());+ assert_eq!(app.session.state.text_edit, selection, "Home did not move the model caret");+ app.ui.start_screen = false;+ let mut output = ctx.run_ui(raw(), |ui| {+ eframe::App::logic(&mut app, ui.ctx(), &mut frame);+ app.draw(ui, &frame);+ });+ output.textures_delta.clear();+ let second = output.platform_output.ime.unwrap().reset_request.expect("same caret reactivation publishes a new real ID");+ assert_ne!(first, second);+ let mut output = ctx.run_ui(raw(), |ui| {+ eframe::App::logic(&mut app, ui.ctx(), &mut frame);+ app.draw(ui, &frame);+ });+ output.textures_delta.clear();+ assert!(output.platform_output.ime.unwrap().reset_request.is_none());+ let mut input = raw();+ input.events.extend([+ egui::Event::ImeResetCompleted { request_id: first },+ egui::Event::Ime(egui::ImeEvent::Commit("X".into())),+ egui::Event::ImeResetCompleted { request_id: second },+ egui::Event::Ime(egui::ImeEvent::Preedit { text: "が".into(), active_range_chars: None }),+ egui::Event::Ime(egui::ImeEvent::Commit("が".into())),+ ]);+ let mut output = ctx.run_ui(input, |ui| {+ eframe::App::logic(&mut app, ui.ctx(), &mut frame);+ app.draw(ui, &frame);+ });+ output.textures_delta.clear();+ assert_eq!(doc_text(&app, lid), "aがbcd");+}++#[test]+fn viewport_fences_and_duplicate_completion_keep_their_exact_lifetime() {+ let (mut app, lid) = editor("abcd", 4, 4);+ let mut root = ImePass::new(egui::ViewportId::ROOT);+ let mut detached = ImePass::new(egui::ViewportId::from_hash_of("effect-ime-detached"));+ let preview = || egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None });+ root.frame(&mut app, vec![preview()], true, false);+ detached.frame(&mut app, vec![preview()], true, false);+ app.session.execute("text.setSelection", json!({"caret": 1})).unwrap();+ let first = root.frame(&mut app, vec![], true, false).unwrap().reset_request.unwrap();+ let second = detached.frame(&mut app, vec![], true, false).unwrap().reset_request.unwrap();+ assert_ne!(first, second);+ detached.frame(&mut app, vec![egui::Event::ImeResetCompleted { request_id: first }, egui::Event::Ime(egui::ImeEvent::Commit("X".into()))], true, false);+ assert_eq!(doc_text(&app, lid), "abcd");+ let pending = detached.ctx.data(|data| data.get_temp::<ResetGuard>(reset_id(detached.viewport))).unwrap().request;+ assert_eq!(pending, Some(second), "a root marker cannot release the detached viewport's full ID");+ let output = detached+ .frame(+ &mut app,+ vec![+ egui::Event::ImeResetCompleted { request_id: second },+ preview(),+ egui::Event::ImeResetCompleted { request_id: second },+ egui::Event::Ime(egui::ImeEvent::Commit("が".into())),+ ],+ true,+ false,+ )+ .unwrap();+ assert_eq!(doc_text(&app, lid), "aがbcd");+ assert!(output.reset_request.is_none(), "a duplicate control cannot reconstruct the cleared guard");+ // An actual context-generation change at unchanged selection still supersedes a wait.+ root.frame(&mut app, vec![], true, false);+ let replaced = root.frame(&mut app, vec![], false, false);+ assert!(replaced.is_none());+ let replacement = root.frame(&mut app, vec![], true, false).unwrap().reset_request.unwrap();+ assert_ne!(first, replacement);+}++#[test]+fn ime_descriptor_sends_committed_text_and_preserves_a_reversed_selection() {+ let (mut app, _) = editor("café😀", 2, 5);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ let first = pass.frame(&mut app, vec![], true, false).expect("the focused editor owns IME");+ assert_eq!(first.owner, ime_target(&app).expect("an edit target").owner);+ assert!(first.context_generation > 0);+ assert_eq!(ime_text(&first), ("café😀", 9, 2), "UTF-8 bytes, with the caret's direction kept");+ assert_eq!(first.change_cause, egui::ImeChangeCause::Other, "starting a context is application origin");+ assert_eq!((first.rect, first.cursor_rect), (pass.rect, pass.rect), "the real caret geometry");++ let again = pass.frame(&mut app, vec![], true, false).expect("still editing");+ assert_eq!(again.context_generation, first.context_generation, "an unchanged pass keeps the context");+ assert_eq!(again.surrounding_text, first.surrounding_text);+}++#[test]+fn accepted_ime_commit_is_input_method_and_ordinary_typing_is_other() {+ let (mut app, lid) = editor("ab", 2, 2);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ let first = pass.frame(&mut app, vec![], true, false).expect("editing");+ let generation = first.context_generation;++ let commit = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, false).expect("still editing");+ assert_eq!(doc_text(&app, lid), "ab日");+ assert_eq!(ime_text(&commit), ("ab日", 5, 5));+ assert_eq!(commit.change_cause, egui::ImeChangeCause::InputMethod, "only the accepted commit earns it");+ assert_eq!(commit.context_generation, generation, "an ordinary text change is not a new context");++ let typed = pass.frame(&mut app, vec![egui::Event::Text("x".into())], true, false).expect("still editing");+ assert_eq!(doc_text(&app, lid), "ab日x");+ assert_eq!(typed.change_cause, egui::ImeChangeCause::Other, "typing is application work");+ assert_eq!(typed.context_generation, generation);+}++#[test]+fn ime_delete_and_commit_chain_is_input_method_with_a_reversed_selection() {+ let (mut app, lid) = editor("abcdef", 4, 1);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ pass.frame(&mut app, vec![], true, false).expect("editing");++ let deleted = pass+ .frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurrounding { before_chars: 1, after_chars: 1 })], true, false)+ .expect("still editing");+ assert_eq!(doc_text(&app, lid), "bcdf", "one character goes before and one after the selection");+ assert_eq!(ime_text(&deleted), ("bcdf", 0, 3), "the selected text and its reversed direction stay");+ assert_eq!(deleted.change_cause, egui::ImeChangeCause::InputMethod);++ let committed = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("X".into()))], true, false).expect("still editing");+ assert_eq!(doc_text(&app, lid), "Xf", "the commit replaces the kept selection");+ assert_eq!(committed.change_cause, egui::ImeChangeCause::InputMethod, "the delete and commit are one accepted chain");+ app.session.execute("edit.undo", json!({})).unwrap();+ assert_eq!(doc_text(&app, lid), "abcdef", "the replacement is one undo step");+}++#[test]+fn an_application_edit_in_the_same_frame_dominates_the_ime_cause() {+ // Application edit before the IME commit.+ let (mut app, lid) = editor("ab", 2, 2);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ pass.frame(&mut app, vec![], true, false).expect("editing");+ let mixed = pass+ .frame(&mut app, vec![egui::Event::Text("x".into()), egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, false)+ .expect("still editing");+ assert_eq!(doc_text(&app, lid), "abx日");+ assert_eq!(mixed.change_cause, egui::ImeChangeCause::Other, "the earlier application edit dominates");++ // Application edit after the IME commit.+ let (mut app, lid) = editor("ab", 2, 2);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ pass.frame(&mut app, vec![], true, false).expect("editing");+ let mixed = pass+ .frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into())), egui::Event::Text("x".into())], true, false)+ .expect("still editing");+ assert_eq!(doc_text(&app, lid), "ab日x");+ assert_eq!(mixed.change_cause, egui::ImeChangeCause::Other, "the later application edit dominates");+}++#[test]+fn preedit_is_excluded_from_the_committed_snapshot_and_keeps_the_context() {+ let (mut app, lid) = editor("ab", 2, 2);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ let first = pass.frame(&mut app, vec![], true, false).expect("editing");++ let preview = pass+ .frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)+ .expect("still editing");+ assert_eq!(doc_text(&app, lid), "ab", "the pre-edit never enters the document");+ assert_eq!(ime_text(&preview), ("ab", 2, 2), "only committed text is sent");+ assert_eq!(preview.context_generation, first.context_generation, "pre-edit updates keep the composition");++ let commit = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("に".into()))], true, false).expect("still editing");+ assert_eq!(doc_text(&app, lid), "abに");+ assert_eq!(commit.change_cause, egui::ImeChangeCause::InputMethod, "clearing the pre-edit and committing is IME work");+ assert_eq!(commit.context_generation, first.context_generation);+}++#[test]+fn empty_and_unavailable_surrounding_text_are_distinct() {+ let (mut app, _) = editor("", 0, 0);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ let empty = pass.frame(&mut app, vec![], true, false).expect("editing");+ assert_eq!(ime_text(&empty), ("", 0, 0), "an available-empty document is not unavailable");++ let text = "a".repeat(5000);+ let (mut app, _) = editor(&text, 0, 5000);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ let wide = pass.frame(&mut app, vec![], true, false).expect("editing");+ assert!(matches!(wide.surrounding_text, egui::output::IMESurroundingText::Unavailable), "a selection wider than the limit is unavailable");+ assert_eq!(wide.owner, ime_target(&app).expect("an edit target").owner, "identity survives unavailable text");+}++#[test]+fn an_unrelated_undo_keeps_a_wide_selection_composition() {+ // A selection wider than the IME limit reports unavailable surrounding text, whose+ // receipt identity is a revision. That revision must follow the editor, not the whole+ // project: undoing an unrelated opacity change used to look like an editor mutation and+ // cancel an active composition.+ let text = "a".repeat(5000);+ let (mut app, lid) = editor(&text, 0, 5000);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ let first = pass.frame(&mut app, vec![], true, false).expect("editing");+ assert!(matches!(first.surrounding_text, egui::output::IMESurroundingText::Unavailable), "the wide selection is unavailable");++ let composing = pass+ .frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)+ .expect("still editing");+ assert_eq!(composing.context_generation, first.context_generation, "the pre-edit keeps the context");+ let owner = ime_owner(&app).expect("an editor owner");+ assert!(matches!(+ pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))),+ Some(ImeComposition::Active(active)) if active == owner+ ));++ app.session.execute("prop.set", json!({"layer": lid.0, "path": "transform/opacity", "value": 50})).unwrap();+ app.session.execute("edit.undo", json!({})).unwrap();+ let after = pass.frame(&mut app, vec![], true, false).expect("still editing");+ assert_eq!(after.context_generation, first.context_generation, "an unrelated undo does not start a new context");+ assert!(+ matches!(+ pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))),+ Some(ImeComposition::Active(active)) if active == owner+ ),+ "the wide-selection composition survives an unrelated undo"+ );+ assert!(read_reset(&pass.ctx).is_none(), "no IME reset was requested");++ // The composition is still the live one: its commit is accepted and earns the+ // input-method cause rather than being poisoned as leftover application work.+ let commit = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("x".into()))], true, false).expect("still editing");+ assert_eq!(doc_text(&app, lid), "x", "the preserved composition commits into the wide selection");+ assert_eq!(commit.change_cause, egui::ImeChangeCause::InputMethod);+}++#[test]+fn a_failed_batch_with_a_transient_edit_does_not_revive_a_wide_selection_composition() {+ // The final document equals the pre-batch one, but the intermediate insert/delete was a+ // real document change. Its IME revision must stay the high-water mark; otherwise the+ // active wide-selection composition would look current and accept its old commit.+ let text = "a".repeat(5000);+ let (mut app, lid) = editor(&text, 0, 5000);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ pass.frame(&mut app, vec![], true, false).expect("editing");+ pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)+ .expect("still editing");+ let owner = ime_owner(&app).expect("an editor owner");+ assert!(matches!(+ pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))),+ Some(ImeComposition::Active(active)) if active == owner+ ));++ let r = app.session.execute(+ "engine.batch",+ json!({"atomic": true, "steps": [+ {"command": "text.insert", "params": {"text": "x", "range": [5000, 5000]}},+ {"command": "text.delete", "params": {}},+ {"command": "no.suchCommand", "params": {}}+ ]}),+ );+ assert!(r.is_err());+ assert_eq!(doc_text(&app, lid), text, "the batch restored the final document");++ pass.frame(&mut app, vec![], true, false).expect("still editing");+ assert!(read_reset(&pass.ctx).is_some(), "the advanced revision retires the old IME context");+ assert!(+ matches!(pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))), Some(ImeComposition::Stale)),+ "the failed batch's transient edit leaves the old composition stale"+ );+ let stale = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("z".into()))], true, false).expect("still editing");+ assert_eq!(doc_text(&app, lid), text, "the stale composition cannot commit into the restored document");+ assert_ne!(stale.change_cause, egui::ImeChangeCause::InputMethod, "a rejected commit earns no IME receipt");+}++#[test]+fn a_wide_content_change_invalidates_the_active_composition() {+ let text = "a".repeat(5000);+ let (mut app, lid) = editor(&text, 0, 5000);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ pass.frame(&mut app, vec![], true, false).expect("editing");+ pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)+ .expect("still editing");++ let replaced = "b".repeat(5000);+ app.session.execute("layer.setText", json!({"layer": lid.0, "text": replaced})).unwrap();+ let after = pass.frame(&mut app, vec![], true, false).expect("still editing");+ assert_eq!(doc_text(&app, lid), replaced);+ assert!(after.should_interrupt_composition, "replacing the wide document starts a new IME context");+ assert!(+ matches!(pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))), Some(ImeComposition::Stale)),+ "the old composition is stale after the content change"+ );+ pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("z".into()))], true, false).expect("still editing");+ assert_eq!(doc_text(&app, lid), replaced, "a delayed commit from the old document is rejected");+}++#[test]+fn a_wide_selection_change_invalidates_the_active_composition() {+ let text = "a".repeat(5000);+ let (mut app, lid) = editor(&text, 0, 5000);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ pass.frame(&mut app, vec![], true, false).expect("editing");+ pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)+ .expect("still editing");++ // Still wider than the IME window limit, so this exercises the unavailable-text+ // selection identity rather than merely making the surrounding text available.+ app.session.execute("text.setSelection", json!({"start": 0, "end": 4500})).unwrap();+ pass.frame(&mut app, vec![], true, false).expect("still editing");+ assert!(read_reset(&pass.ctx).is_some(), "an application selection change retires the composition");+ assert!(+ matches!(pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))), Some(ImeComposition::Stale)),+ "the old composition cannot follow the selection"+ );+ pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("z".into()))], true, false).expect("still editing");+ assert_eq!(doc_text(&app, lid), text, "the stale composition cannot mutate the wide selection");+}++#[test]+fn replaced_edit_session_and_hidden_passes_start_a_new_context() {+ let (mut app, _) = editor("text", 4, 4);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ let before = pass.frame(&mut app, vec![], true, false).expect("editing");+ if let Some(edit) = app.session.state.text_edit.as_mut() {+ edit.session = edit.session.wrapping_add(1);+ }+ let replaced = pass.frame(&mut app, vec![], true, false).expect("editing");+ assert!(replaced.context_generation > before.context_generation, "a recreated target does not inherit the old context");+ assert_eq!(replaced.change_cause, egui::ImeChangeCause::Other);+ assert!(replaced.should_interrupt_composition, "a new replacement epoch cancels the platform composition");++ let (mut app, _) = editor("abc", 3, 3);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ let visible = pass.frame(&mut app, vec![], true, false).expect("editing");+ assert!(pass.frame(&mut app, vec![], false, false).is_none(), "a hidden editor reports no IME owner");+ let back = pass.frame(&mut app, vec![], true, false).expect("editing again");+ assert!(back.context_generation > visible.context_generation, "reappearing starts exactly one new context");+}++#[test]+fn preedit_from_a_replaced_target_cannot_commit_into_the_new_session() {+ let (mut app, first) = editor("A", 1, 1);+ let second = app.session.execute("layer.newText", json!({"text": "B"})).unwrap()["layer"].as_u64().unwrap();+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "か".into(), active_range_chars: None })], true, false)+ .expect("editing the first layer");++ app.session.execute("text.edit", json!({"layer": second, "caret": 1})).unwrap();+ let switched = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, false).expect("editing the second layer");+ assert_eq!(doc_text(&app, LayerId(second)), "B", "a delayed commit from the old composition is ignored");+ assert_eq!(doc_text(&app, first), "A", "the old layer is not changed either");+ assert_eq!(switched.owner, ime_target(&app).expect("second target").owner);+ assert!(switched.should_interrupt_composition, "the target switch interrupts the old composition");+}++#[test]+fn hidden_pass_clears_this_viewports_preedit_preview() {+ let (mut app, _) = editor("ab", 2, 2);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false).expect("editing");+ assert!(pass.ctx.data(|d| d.get_temp::<Preedit>(ime_preedit_id(pass.viewport))).is_some());+ assert!(pass.frame(&mut app, vec![], false, false).is_none());+ assert!(pass.ctx.data(|d| d.get_temp::<Preedit>(ime_preedit_id(pass.viewport))).is_none(), "a pass without the overlay clears this viewport's preview");+}++#[test]+fn a_discarded_pass_keeps_the_frame_cause_and_the_context() {+ let (mut app, lid) = editor("ab", 2, 2);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ let first = pass.frame(&mut app, vec![], true, false).expect("editing");+ let committed = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, true).expect("the final pass of the frame");+ assert_eq!(doc_text(&app, lid), "ab日", "the discarded pass did not replay the event");+ assert_eq!(committed.change_cause, egui::ImeChangeCause::InputMethod, "an unchanged later pass keeps the frame's cause");+ assert_eq!(committed.context_generation, first.context_generation, "both passes are one context");+}++#[test]+fn two_viewports_keep_independent_ime_contexts() {+ let (mut app, _) = editor("ab", 2, 2);+ let mut first = ImePass::new(egui::ViewportId::ROOT);+ let mut second = ImePass::new(egui::ViewportId::from_hash_of("ime-test-second-viewport"));+ let one = first.frame(&mut app, vec![], true, false).expect("editing in the first viewport");+ let two = second.frame(&mut app, vec![], true, false).expect("editing in the second viewport");+ assert_ne!(one.context_generation, two.context_generation, "each viewport has its own generation");+ let again = first.frame(&mut app, vec![], true, false).expect("editing in the first viewport");+ assert_eq!(again.context_generation, one.context_generation, "the second viewport did not disturb the first");+}++/// Draw one real `EffectcraftApp::draw` pass, so `draw`'s all-exit finalizer runs.+fn draw_app_pass(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, events: Vec<egui::Event>) -> egui::FullOutput {+ let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1200.0, 800.0))), events, ..Default::default() };+ let mut out = ctx.run_ui(raw, |ui| app.draw(ui, frame));+ out.textures_delta.clear();+ out+}++/// One headless pass with the custom viewer and a real stock `TextEdit` side by side.+///+/// The first call focuses the custom editor before `keyboard` (the outside press arrives+/// there). The second call leaves the stock field's focus alone, so the stock descriptor+/// is published by the same `output.ime` writer that an unrelated field would use.+fn stock_pass(+ pass: &mut ImePass,+ app: &mut EffectcraftApp,+ events: Vec<egui::Event>,+ stock: &mut String,+ custom_focus: bool,+) -> Option<egui::output::IMEOutput> {+ let ctx = pass.ctx.clone();+ let viewport = pass.viewport;+ let custom = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(160.0, 90.0));+ let stock_rect = egui::Rect::from_min_size(egui::pos2(180.0, 30.0), egui::vec2(120.0, 24.0));+ let stock_id = egui::Id::unique("effectcraft-ime-test-stock");+ let mut viewports = egui::ViewportIdMap::default();+ viewports.insert(viewport, egui::ViewportInfo::default());+ let raw = egui::RawInput { viewport_id: viewport, viewports, screen_rect: Some(pass.rect), events, ..Default::default() };+ let mut out = ctx.run_ui(raw, |ui| {+ begin_ui(ui.ctx());+ if custom_focus {+ ui.interact(custom, focus_id(), egui::Sense::focusable_noninteractive());+ ui.memory_mut(|m| m.request_focus(focus_id()));+ sync_ime_target(ui, app);+ keyboard(app, ui, custom);+ } else {+ // The stock field holds focus after the outside press; keep that ownership while+ // the second pass publishes the actual stock descriptor.+ ui.memory_mut(|m| m.request_focus(stock_id));+ }+ let _ = ui.put(stock_rect, egui::TextEdit::singleline(stock).id(stock_id));+ finish_ime(app, ui);+ });+ out.textures_delta.clear();+ out.platform_output.ime+}++#[test]+fn outside_pointer_to_stock_allocates_no_new_request_and_defers_the_replacement() {+ let (mut app, lid) = editor("abcd", 4, 4);+ let mut pass = ImePass::new(egui::ViewportId::ROOT);+ let preview = || egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None });+ pass.frame(&mut app, vec![preview()], true, false).expect("the custom editor starts a composition");+ app.session.execute("text.setSelection", json!({"caret": 1})).unwrap();+ let first = pass.frame(&mut app, vec![], true, false).expect("the caret change publishes a request").reset_request.expect("the real request ID");+ // Complete the first interruption, then start a fresh composition with no waiting guard.+ pass.frame(&mut app, vec![egui::Event::ImeResetCompleted { request_id: first }], true, false);+ let active = pass.frame(&mut app, vec![preview()], true, false).expect("a fresh composition");+ assert!(active.reset_request.is_none(), "a fresh composition does not wait on an old request");+ assert_eq!(doc_text(&app, lid), "abcd");++ // The press outside the viewer also gives the stock field focus. It must not allocate a+ // new request: core would attach that request to the stock descriptor next pass.+ let outside = egui::pos2(240.0, 42.0);+ let mut stock = String::new();+ stock_pass(+ &mut pass,+ &mut app,+ vec![+ egui::Event::PointerMoved(outside),+ egui::Event::PointerButton { pos: outside, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE },+ ],+ &mut stock,+ true,+ );+ let guard = pass.ctx.data(|d| d.get_temp::<ResetGuard>(reset_id(pass.viewport))).expect("the custom guard is retired locally");+ assert!(guard.suspended && guard.request.is_none(), "the outside press retires the old request without allocating another");+ let stock_ime = stock_pass(&mut pass, &mut app, vec![], &mut stock, false).expect("the actual stock field owns IME");+ assert_ne!(stock_ime.owner, ime_target(&app).expect("the custom target is still live").owner);+ assert!(stock_ime.reset_request.is_none(), "a new outside-press request would surface on the stock output");+ assert_eq!(doc_text(&app, lid), "abcd");++ // Returning to a confirmed eligible custom output allocates the one replacement.+ let replacement = pass.frame(&mut app, vec![], true, false).expect("the custom editor owns IME again").reset_request.expect("the deferred replacement");+ assert_ne!(first, replacement);+ assert!(pass.frame(&mut app, vec![], true, false).expect("still editing").reset_request.is_none(), "the replacement is one-shot");+}++#[test]+fn fonts_and_device_loss_all_exit_finalizers_suspend_without_allocating() {+ let (mut app, _lid) = editor("abcd", 1, 1);+ app.ui.start_screen = false;+ app.ui.tool = Tool::Type;+ app.ui.focused = PanelKind::Composition;+ app.show_panel(PanelKind::Composition);+ let ctx = egui::Context::default();+ install_hooks(&ctx);+ let frame = eframe::Frame::_new_kittest();+ let preview = || egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None });+ // The first pass installs fonts and the next draws the real viewer.+ for _ in 0..3 {+ draw_app_pass(&mut app, &ctx, &frame, vec![]);+ }+ draw_app_pass(&mut app, &ctx, &frame, vec![preview()]);+ app.session.execute("text.setSelection", json!({"caret": 2})).unwrap();+ let first = draw_app_pass(&mut app, &ctx, &frame, vec![])+ .platform_output+ .ime+ .expect("the normal pass publishes the custom descriptor")+ .reset_request+ .expect("one request for the caret interruption");++ // A real font-install pass draws nothing, but `draw` still reaches the finalizer.+ app.styled = false;+ let fonts = draw_app_pass(&mut app, &ctx, &frame, vec![]);+ assert!(!app.is_ready(), "the font-install pass cannot draw");+ assert!(fonts.platform_output.ime.is_none(), "no custom descriptor is published");+ let guard = ctx.data(|d| d.get_temp::<ResetGuard>(reset_id(egui::ViewportId::ROOT))).expect("the waiting guard");+ assert!(guard.suspended && guard.request.is_none(), "the all-exit finalizer retired it without allocating");+ let second = draw_app_pass(&mut app, &ctx, &frame, vec![])+ .platform_output+ .ime+ .expect("returning to a drawing pass publishes the custom descriptor")+ .reset_request+ .expect("the deferred request");+ assert_ne!(first, second);++ // The device-loss early return is the other all-exit path. Preset the close bookkeeping+ // so this test does not autosave; the pass must still retire the waiting guard.+ app.gpu_failure_applied = Some(true);+ app.device_lost_close = Some(true);+ let lost = draw_app_pass(&mut app, &ctx, &frame, vec![]);+ assert!(lost.platform_output.ime.is_none(), "a lost renderer publishes no descriptor");+ let guard = ctx.data(|d| d.get_temp::<ResetGuard>(reset_id(egui::ViewportId::ROOT))).expect("the waiting guard");+ assert!(guard.suspended && guard.request.is_none(), "the device-loss finalizer retired it without allocating");+ app.gpu_failure_applied = None;+ let third = draw_app_pass(&mut app, &ctx, &frame, vec![])+ .platform_output+ .ime+ .expect("a drawing pass publishes the custom descriptor again")+ .reset_request+ .expect("the deferred request is one-shot");+ assert_ne!(third, second);+}++#[test]+fn ime_delete_without_a_session_or_with_an_empty_range_does_nothing() {+ let (mut app, lid) = editor("abc", 1, 1);+ feed(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes: 0, after_bytes: 0 })]);+ assert_eq!(doc_text(&app, lid), "abc");+ app.session.state.text_edit = None;+ feed(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes: 2, after_bytes: 0 })]);+ assert_eq!(doc_text(&app, lid), "abc");+}