| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use crate::ime_service::ImeService; |
| use failure::ResultExt; |
| use fidl::encoding::OutOfLine; |
| use fidl::endpoints::RequestStream; |
| use fidl_fuchsia_ui_input as uii; |
| use fidl_fuchsia_ui_input::InputMethodEditorRequest as ImeReq; |
| use fidl_fuchsia_ui_text as txt; |
| use fuchsia_syslog::{fx_log_err, fx_log_warn}; |
| use futures::prelude::*; |
| use lazy_static::lazy_static; |
| use parking_lot::Mutex; |
| use regex::Regex; |
| use std::char; |
| use std::collections::HashMap; |
| use std::ops::Range; |
| use std::sync::{Arc, Weak}; |
| use unicode_segmentation::{GraphemeCursor, UnicodeSegmentation}; |
| |
| // TODO(lard): move constants into common, centralized location? |
| pub const HID_USAGE_KEY_BACKSPACE: u32 = 0x2a; |
| pub const HID_USAGE_KEY_RIGHT: u32 = 0x4f; |
| pub const HID_USAGE_KEY_LEFT: u32 = 0x50; |
| pub const HID_USAGE_KEY_ENTER: u32 = 0x28; |
| pub const HID_USAGE_KEY_DELETE: u32 = 0x2e; |
| |
| /// The internal state of the IME, usually held within the IME behind an Arc<Mutex> |
| /// so it can be accessed from multiple places. |
| pub struct ImeState { |
| text_state: uii::TextInputState, |
| |
| /// A handle to call methods on the text field. |
| client: Box<uii::InputMethodEditorClientProxyInterface>, |
| |
| keyboard_type: uii::KeyboardType, |
| action: uii::InputMethodAction, |
| ime_service: ImeService, |
| |
| /// We expose a TextField interface to an input method. There are also legacy |
| /// input methods that just send key events through inject_input — in this case, |
| /// input_method would be None, and these events would be handled by the |
| /// inject_input method. ImeState can only handle talking to one input_method |
| /// at a time; it's the responsibility of some other code (likely inside |
| /// ImeService) to multiplex multiple TextField interfaces into this one. |
| input_method: Option<txt::TextFieldControlHandle>, |
| |
| /// A number used to serve the TextField interface. It increments any time any |
| /// party makes a change to the state. |
| revision: u64, |
| |
| /// A TextPoint is a u64 token that represents a character position in the new |
| /// TextField interface. Each token is a unique ID; this represents the ID we |
| /// will assign to the next TextPoint that is created. It increments every time |
| /// a TextPoint is created. This is never reset, even when TextPoints are |
| /// invalidated; TextPoints have globally unique IDs. |
| next_text_point_id: u64, |
| |
| /// A TextPoint is a u64 token that represents a character position in the new |
| /// TextField interface. This maps TextPoint IDs to byte indexes inside |
| /// `text_state.text`. When a new revision is created, all preexisting TextPoints |
| /// are deleted, which means we clear this out. |
| text_points: HashMap<u64, usize>, |
| } |
| |
| /// A service that talks to a text field, providing it edits and cursor state updates |
| /// in response to user input. |
| #[derive(Clone)] |
| pub struct Ime(Arc<Mutex<ImeState>>); |
| |
| impl Ime { |
| pub fn new<I: 'static + uii::InputMethodEditorClientProxyInterface>( |
| keyboard_type: uii::KeyboardType, |
| action: uii::InputMethodAction, |
| initial_state: uii::TextInputState, |
| client: I, |
| ime_service: ImeService, |
| ) -> Ime { |
| let state = ImeState { |
| text_state: initial_state, |
| client: Box::new(client), |
| keyboard_type, |
| action, |
| ime_service, |
| revision: 0, |
| next_text_point_id: 0, |
| text_points: HashMap::new(), |
| input_method: None, |
| }; |
| Ime(Arc::new(Mutex::new(state))) |
| } |
| |
| pub fn downgrade(&self) -> Weak<Mutex<ImeState>> { |
| Arc::downgrade(&self.0) |
| } |
| |
| pub fn upgrade(weak: &Weak<Mutex<ImeState>>) -> Option<Ime> { |
| weak.upgrade().map(|arc| Ime(arc)) |
| } |
| |
| pub fn bind_text_field(&self, mut stream: txt::TextFieldRequestStream) { |
| let control_handle = stream.control_handle(); |
| { |
| let mut state = self.0.lock(); |
| let res = control_handle.send_on_update(&mut state.as_text_field_state()); |
| if let Err(e) = res { |
| fx_log_err!("{}", e); |
| } else { |
| state.input_method = Some(control_handle); |
| } |
| } |
| let self_clone = self.clone(); |
| fuchsia_async::spawn( |
| async move { |
| while let Some(msg) = await!(stream.try_next()) |
| .context("error reading value from text field request stream")? |
| { |
| if let Err(e) = self_clone.handle_text_field_msg(msg) { |
| fx_log_err!("Error when replying to TextFieldRequest: {}", e); |
| } |
| } |
| Ok(()) |
| } |
| .unwrap_or_else(|e: failure::Error| fx_log_err!("{:?}", e)), |
| ); |
| } |
| |
| pub fn bind_ime(&self, chan: fuchsia_async::Channel) { |
| let self_clone = self.clone(); |
| let self_clone_2 = self.clone(); |
| fuchsia_async::spawn( |
| async move { |
| let mut stream = uii::InputMethodEditorRequestStream::from_channel(chan); |
| while let Some(msg) = await!(stream.try_next()) |
| .context("error reading value from IME request stream")? |
| { |
| self_clone.handle_ime_message(msg); |
| } |
| Ok(()) |
| } |
| .unwrap_or_else(|e: failure::Error| fx_log_err!("{:?}", e)) |
| .then(async move |()| { |
| // this runs when IME stream closes |
| // clone to ensure we only hold one lock at a time |
| let ime_service = self_clone_2.0.lock().ime_service.clone(); |
| ime_service.update_keyboard_visibility_from_ime(&self_clone_2.0, false); |
| }), |
| ); |
| } |
| |
| /// Handles a TextFieldRequest, returning a FIDL error if one occurred when sending a reply. |
| // TODO(lard): finish implementation |
| fn handle_text_field_msg(&self, msg: txt::TextFieldRequest) -> Result<(), fidl::Error> { |
| match msg { |
| txt::TextFieldRequest::PointOffset { responder, .. } => { |
| return responder.send(&mut txt::TextPoint { id: 0 }, txt::TextError::BadRequest); |
| } |
| txt::TextFieldRequest::Distance { responder, .. } => { |
| return responder.send(0, txt::TextError::BadRequest); |
| } |
| txt::TextFieldRequest::Contents { responder, .. } => { |
| return responder.send( |
| "", |
| &mut txt::TextPoint { id: 0 }, |
| txt::TextError::BadRequest, |
| ); |
| } |
| txt::TextFieldRequest::CommitEdit { responder, .. } => { |
| return responder.send(txt::TextError::BadRequest); |
| } |
| // other cases don't have a responder, so we can just ignore in this temporary code |
| // instead of replying with an error. |
| _ => { |
| return Ok(()); |
| } |
| } |
| } |
| |
| /// Handles a request from the legancy IME API, an InputMethodEditorRequest. |
| fn handle_ime_message(&self, msg: uii::InputMethodEditorRequest) { |
| match msg { |
| ImeReq::SetKeyboardType { keyboard_type, .. } => { |
| let mut state = self.0.lock(); |
| state.keyboard_type = keyboard_type; |
| } |
| ImeReq::SetState { state, .. } => { |
| self.set_state(state); |
| } |
| ImeReq::InjectInput { event, .. } => { |
| self.inject_input(event); |
| } |
| ImeReq::Show { .. } => { |
| // clone to ensure we only hold one lock at a time |
| let ime_service = self.0.lock().ime_service.clone(); |
| ime_service.show_keyboard(); |
| } |
| ImeReq::Hide { .. } => { |
| // clone to ensure we only hold one lock at a time |
| let ime_service = self.0.lock().ime_service.clone(); |
| ime_service.hide_keyboard(); |
| } |
| } |
| } |
| |
| fn set_state(&self, input_state: uii::TextInputState) { |
| let mut state = self.0.lock(); |
| state.text_state = input_state; |
| // the old C++ IME implementation didn't call did_update_state here, so this second argument is false. |
| state.increment_revision(None, false); |
| } |
| |
| pub fn inject_input(&self, event: uii::InputEvent) { |
| let mut state = self.0.lock(); |
| let keyboard_event = match event { |
| uii::InputEvent::Keyboard(e) => e, |
| _ => return, |
| }; |
| |
| if keyboard_event.phase == uii::KeyboardEventPhase::Pressed |
| || keyboard_event.phase == uii::KeyboardEventPhase::Repeat |
| { |
| if keyboard_event.code_point != 0 { |
| state.type_keycode(keyboard_event.code_point); |
| state.increment_revision(Some(keyboard_event), true) |
| } else { |
| match keyboard_event.hid_usage { |
| HID_USAGE_KEY_BACKSPACE => { |
| state.delete_backward(); |
| state.increment_revision(Some(keyboard_event), true); |
| } |
| HID_USAGE_KEY_DELETE => { |
| state.delete_forward(); |
| state.increment_revision(Some(keyboard_event), true); |
| } |
| HID_USAGE_KEY_LEFT => { |
| state.cursor_horizontal_move(keyboard_event.modifiers, false); |
| state.increment_revision(Some(keyboard_event), true); |
| } |
| HID_USAGE_KEY_RIGHT => { |
| state.cursor_horizontal_move(keyboard_event.modifiers, true); |
| state.increment_revision(Some(keyboard_event), true); |
| } |
| HID_USAGE_KEY_ENTER => { |
| state.client.on_action(state.action).unwrap_or_else(|e| { |
| fx_log_warn!("error sending action to ImeClient: {:?}", e) |
| }); |
| } |
| _ => { |
| // Not an editing key, forward the event to clients. |
| state.increment_revision(Some(keyboard_event), true); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /// Horizontal motion type for the cursor. |
| enum HorizontalMotion { |
| GraphemeLeft(GraphemeTraversal), |
| GraphemeRight, |
| WordLeft, |
| WordRight, |
| } |
| |
| /// How the cursor should traverse grapheme clusters. |
| enum GraphemeTraversal { |
| /// Move by whole grapheme clusters at a time. |
| /// |
| /// This traversal mode should be used when using arrow keys, or when deleting forward (with the |
| /// <kbd>Delete</kbd> key). |
| WholeGrapheme, |
| /// Generally move by whole grapheme clusters, but allow moving through individual combining |
| /// characters, if present at the end of the grapheme cluster. |
| /// |
| /// This traversal mode should be used when deleting backward (<kbd>Backspace</kbd>), but not |
| /// when deleting forward or using arrow keys. |
| /// |
| /// This ensures that when a user is typing text and composes a character out of individual |
| /// combining diacritics, it should be possible to correct a mistake by pressing |
| /// <kbd>Backspace</kbd>. If we were to allow _moving the cursor_ left and right through |
| /// diacritics, that would only cause user confusion, as the blinking caret would not move |
| /// visibly while within a single grapheme cluster. |
| CombiningCharacters, |
| } |
| |
| impl ImeState { |
| /// Any time the state is updated, this method is called, which allows ImeState to inform any |
| /// listening clients (either TextField or InputMethodEditorClientProxy) that state has updated. |
| /// If InputMethodEditorClient caused the update with SetState, set call_did_update_state so that |
| /// we don't send its own edit back to it. Otherwise, set to true. |
| pub fn increment_revision( |
| &mut self, |
| e: Option<uii::KeyboardEvent>, |
| call_did_update_state: bool, |
| ) { |
| self.revision += 1; |
| self.text_points = HashMap::new(); |
| let mut state = self.as_text_field_state(); |
| if let Some(input_method) = &self.input_method { |
| if let Err(e) = input_method.send_on_update(&mut state) { |
| fx_log_err!("error when sending update to TextField listener: {}", e); |
| } |
| } |
| |
| if call_did_update_state { |
| if let Some(ev) = e { |
| self.client |
| .did_update_state( |
| &mut self.text_state, |
| Some(OutOfLine(&mut uii::InputEvent::Keyboard(ev))), |
| ) |
| .unwrap_or_else(|e| { |
| fx_log_warn!("error sending state update to ImeClient: {:?}", e) |
| }); |
| } else { |
| self.client.did_update_state(&mut self.text_state, None).unwrap_or_else(|e| { |
| fx_log_warn!("error sending state update to ImeClient: {:?}", e) |
| }); |
| } |
| } |
| } |
| |
| /// Converts the current self.text_state (the IME API v1 representation of the text field's state) |
| /// into the v2 representation txt::TextFieldState. |
| fn as_text_field_state(&mut self) -> txt::TextFieldState { |
| let anchor_first = self.text_state.selection.base < self.text_state.selection.extent; |
| txt::TextFieldState { |
| document: txt::TextRange { |
| start: self.new_point(0), |
| end: self.new_point(self.text_state.text.len()), |
| }, |
| selection: Some(Box::new(txt::TextSelection { |
| range: txt::TextRange { |
| start: self.new_point(if anchor_first { |
| self.text_state.selection.base as usize |
| } else { |
| self.text_state.selection.extent as usize |
| }), |
| end: self.new_point(if anchor_first { |
| self.text_state.selection.extent as usize |
| } else { |
| self.text_state.selection.base as usize |
| }), |
| }, |
| anchor: if anchor_first { |
| txt::TextSelectionAnchor::AnchoredAtStart |
| } else { |
| txt::TextSelectionAnchor::AnchoredAtEnd |
| }, |
| affinity: txt::TextAffinity::Upstream, |
| })), |
| // TODO(lard): these three regions should be correctly populated from text_state. |
| composition: None, |
| composition_highlight: None, |
| dead_key_highlight: None, |
| revision: self.revision, |
| } |
| } |
| |
| /// Creates a new TextPoint corresponding to the byte index `index`. |
| fn new_point(&mut self, index: usize) -> txt::TextPoint { |
| let id = self.next_text_point_id; |
| self.next_text_point_id += 1; |
| self.text_points.insert(id, index); |
| txt::TextPoint { id } |
| } |
| |
| // gets start and len, and sets base/extent to start of string if don't exist |
| pub fn selection(&mut self) -> Range<usize> { |
| let s = &mut self.text_state.selection; |
| s.base = s.base.max(0).min(self.text_state.text.len() as i64); |
| s.extent = s.extent.max(0).min(self.text_state.text.len() as i64); |
| let start = s.base.min(s.extent) as usize; |
| let end = s.base.max(s.extent) as usize; |
| (start..end) |
| } |
| |
| pub fn type_keycode(&mut self, code_point: u32) { |
| self.text_state.revision += 1; |
| |
| let replacement = match char::from_u32(code_point) { |
| Some(v) => v.to_string(), |
| None => return, |
| }; |
| |
| let selection = self.selection(); |
| self.text_state.text.replace_range(selection.clone(), &replacement); |
| |
| self.text_state.selection.base = selection.start as i64 + replacement.len() as i64; |
| self.text_state.selection.extent = self.text_state.selection.base; |
| } |
| |
| /// Calculates an adjacent cursor position to left or right of the current position. |
| /// |
| /// * `start`: Starting position in the string, as a byte offset. |
| /// * `motion`: Whether to go right or left, and whether to allow entering grapheme clusters. |
| fn adjacent_cursor_position(&self, start: usize, motion: HorizontalMotion) -> usize { |
| match motion { |
| HorizontalMotion::GraphemeRight => self.adjacent_cursor_position_grapheme_right(start), |
| HorizontalMotion::GraphemeLeft(traversal) => { |
| self.adjacent_cursor_position_grapheme_left(start, traversal) |
| } |
| HorizontalMotion::WordLeft => self.adjacent_cursor_position_word_left(start), |
| HorizontalMotion::WordRight => self.adjacent_cursor_position_word_right(start), |
| } |
| } |
| |
| fn adjacent_cursor_position_word_left(&self, start: usize) -> usize { |
| if start == 0 { |
| return 0; |
| } |
| let text = &self.text_state.text[0..start]; |
| // Find the next word to the left. |
| let word = match UnicodeSegmentation::unicode_words(text).rev().next() { |
| Some(word) => word, |
| // No words - go to the string start. |
| None => return 0, |
| }; |
| // Find start of the next word. |
| if let Some((pos, _)) = UnicodeSegmentation::split_word_bound_indices(text) |
| .rev() |
| .find(|(_, next_word)| next_word == &word) |
| { |
| pos |
| } else { |
| 0 |
| } |
| } |
| |
| fn adjacent_cursor_position_word_right(&self, start: usize) -> usize { |
| let text = &self.text_state.text[start..]; |
| let text_length = text.len(); |
| if text_length == 0 { |
| return start; |
| } |
| let mut words_iter = UnicodeSegmentation::unicode_words(text); |
| // Find the next word to the right. |
| let word = match words_iter.next() { |
| Some(word) => word, |
| // No words - go the end of the string. |
| None => return start + text_length, |
| }; |
| let mut word_bound_indices = UnicodeSegmentation::split_word_bound_indices(text); |
| // Skip over boundaries until a next word is found. |
| let word_bound = word_bound_indices.find(|(_, next_word)| next_word == &word); |
| |
| // Return start of the next boundary after the word, if there is one. |
| if let Some((next_boundary_pos, _)) = word_bound_indices.next() { |
| start + next_boundary_pos |
| } else if let Some((pos, next_word)) = word_bound { |
| // Last word - go to end of the word. |
| start + pos + next_word.len() |
| } else { |
| // No more words - go to the end of the line. |
| start + text_length |
| } |
| } |
| |
| fn get_grapheme_boundary(&self, start: usize, next: bool) -> Option<usize> { |
| let text_length = self.text_state.text.len(); |
| let mut cursor = GraphemeCursor::new(start, text_length, true); |
| let result = if next { |
| cursor.next_boundary(&self.text_state.text, 0) |
| } else { |
| cursor.prev_boundary(&self.text_state.text, 0) |
| }; |
| result.unwrap_or(None) |
| } |
| |
| fn adjacent_cursor_position_grapheme_right(&self, start: usize) -> usize { |
| self.get_grapheme_boundary(start, true).unwrap_or(self.text_state.text.len()) |
| } |
| |
| fn adjacent_cursor_position_grapheme_left( |
| &self, |
| start: usize, |
| traversal: GraphemeTraversal, |
| ) -> usize { |
| let prev_boundary = self.get_grapheme_boundary(start, false); |
| if let Some(offset) = prev_boundary { |
| if let GraphemeTraversal::CombiningCharacters = traversal { |
| let grapheme_str = &self.text_state.text[offset..start]; |
| let last_char_str = match grapheme_str.char_indices().last() { |
| Some((last_char_offset, _c)) => Some(&grapheme_str[last_char_offset..]), |
| None => None, |
| }; |
| if let Some(last_char_str) = last_char_str { |
| lazy_static! { |
| /// A regex that matches combining characters, e.g. accents and other |
| /// diacritics. Rust does not provide a way to check the Unicode categories |
| /// of `char`s directly, so this is the simplest workaround for now. |
| static ref COMBINING_REGEX: Regex = Regex::new(r"\p{M}$").unwrap(); |
| } |
| if COMBINING_REGEX.is_match(last_char_str) { |
| return start - last_char_str.len(); |
| } |
| } |
| } |
| offset |
| } else { |
| // Can't go left from the beginning of the string. |
| 0 |
| } |
| } |
| |
| pub fn delete_backward(&mut self) { |
| self.text_state.revision += 1; |
| |
| // set base and extent to 0 if either is -1, to ensure there is a selection/cursor |
| self.selection(); |
| |
| if self.text_state.selection.base == self.text_state.selection.extent { |
| // Select one grapheme or character to the left, so that it can be uniformly handled by |
| // the selection-deletion code below. |
| self.text_state.selection.base = self.adjacent_cursor_position( |
| self.text_state.selection.base as usize, |
| HorizontalMotion::GraphemeLeft(GraphemeTraversal::CombiningCharacters), |
| ) as i64; |
| } |
| self.delete_selection(); |
| } |
| |
| pub fn delete_forward(&mut self) { |
| self.text_state.revision += 1; |
| |
| // Ensure valid selection/cursor. |
| self.selection(); |
| |
| if self.text_state.selection.base == self.text_state.selection.extent { |
| // Select one grapheme to the right so that it can be handled by the selection-deletion |
| // code below. |
| self.text_state.selection.extent = self.adjacent_cursor_position( |
| self.text_state.selection.base as usize, |
| HorizontalMotion::GraphemeRight, |
| ) as i64; |
| } |
| self.delete_selection(); |
| } |
| |
| /// Deletes the selected text if the selection isn't empty. |
| /// Does not increment revision number. Should only be called from methods that do. |
| fn delete_selection(&mut self) { |
| // Delete the current selection. |
| let selection = self.selection(); |
| if selection.start != selection.end { |
| self.text_state.text.replace_range(selection.clone(), ""); |
| self.text_state.selection.extent = selection.start as i64; |
| self.text_state.selection.base = self.text_state.selection.extent; |
| } |
| } |
| |
| pub fn cursor_horizontal_move(&mut self, modifiers: u32, go_right: bool) { |
| self.text_state.revision += 1; |
| |
| let shift_pressed = modifiers & uii::MODIFIER_SHIFT != 0; |
| let ctrl_pressed = modifiers & uii::MODIFIER_CONTROL != 0; |
| let selection = self.selection(); |
| let text_is_selected = selection.start != selection.end; |
| let mut new_position = self.text_state.selection.extent; |
| |
| if !shift_pressed && text_is_selected { |
| // canceling selection, new position based on start/end of selection |
| if go_right { |
| new_position = selection.end as i64; |
| } else { |
| new_position = selection.start as i64; |
| } |
| if ctrl_pressed { |
| new_position = self.adjacent_cursor_position( |
| new_position as usize, |
| if go_right { HorizontalMotion::WordRight } else { HorizontalMotion::WordLeft }, |
| ) as i64; |
| } |
| } else { |
| // new position based previous value of extent |
| new_position = self.adjacent_cursor_position( |
| new_position as usize, |
| match (go_right, ctrl_pressed) { |
| (true, true) => HorizontalMotion::WordRight, |
| (false, true) => HorizontalMotion::WordLeft, |
| (true, false) => HorizontalMotion::GraphemeRight, |
| (false, false) => { |
| HorizontalMotion::GraphemeLeft(GraphemeTraversal::WholeGrapheme) |
| } |
| }, |
| ) as i64; |
| } |
| |
| self.text_state.selection.extent = new_position; |
| if !shift_pressed { |
| self.text_state.selection.base = new_position; |
| } |
| self.text_state.selection.affinity = uii::TextAffinity::Downstream; |
| } |
| } |
| |
| #[cfg(test)] |
| mod test { |
| use super::*; |
| use crate::test_helpers::{clone_state, default_state}; |
| use fidl; |
| use fuchsia_zircon as zx; |
| use std::sync::mpsc::{channel, Receiver, Sender}; |
| |
| fn set_up( |
| text: &str, |
| base: i64, |
| extent: i64, |
| ) -> (Ime, Receiver<uii::TextInputState>, Receiver<uii::InputMethodAction>) { |
| let (client, statechan, actionchan) = MockImeClient::new(); |
| let mut state = default_state(); |
| state.text = text.to_string(); |
| state.selection.base = base; |
| state.selection.extent = extent; |
| let ime = Ime::new( |
| uii::KeyboardType::Text, |
| uii::InputMethodAction::Search, |
| state, |
| client, |
| ImeService::new(), |
| ); |
| (ime, statechan, actionchan) |
| } |
| |
| fn simulate_keypress<K: Into<u32> + Copy>( |
| ime: &mut Ime, |
| key: K, |
| hid_key: bool, |
| modifiers: u32, |
| ) { |
| let hid_usage = if hid_key { key.into() } else { 0 }; |
| let code_point = if hid_key { 0 } else { key.into() }; |
| ime.inject_input(uii::InputEvent::Keyboard(uii::KeyboardEvent { |
| event_time: 0, |
| device_id: 0, |
| phase: uii::KeyboardEventPhase::Pressed, |
| hid_usage, |
| code_point, |
| modifiers, |
| })); |
| ime.inject_input(uii::InputEvent::Keyboard(uii::KeyboardEvent { |
| event_time: 0, |
| device_id: 0, |
| phase: uii::KeyboardEventPhase::Released, |
| hid_usage, |
| code_point, |
| modifiers, |
| })); |
| } |
| |
| struct MockImeClient { |
| pub state: Mutex<Sender<uii::TextInputState>>, |
| pub action: Mutex<Sender<uii::InputMethodAction>>, |
| } |
| impl MockImeClient { |
| fn new() -> (MockImeClient, Receiver<uii::TextInputState>, Receiver<uii::InputMethodAction>) |
| { |
| let (s_send, s_rec) = channel(); |
| let (a_send, a_rec) = channel(); |
| let client = MockImeClient { state: Mutex::new(s_send), action: Mutex::new(a_send) }; |
| (client, s_rec, a_rec) |
| } |
| } |
| impl uii::InputMethodEditorClientProxyInterface for MockImeClient { |
| fn did_update_state( |
| &self, |
| state: &mut uii::TextInputState, |
| mut _event: Option<fidl::encoding::OutOfLine<uii::InputEvent>>, |
| ) -> Result<(), fidl::Error> { |
| let state2 = clone_state(state); |
| self.state |
| .lock() |
| .send(state2) |
| .map_err(|_| fidl::Error::ClientWrite(zx::Status::PEER_CLOSED)) |
| } |
| fn on_action(&self, action: uii::InputMethodAction) -> Result<(), fidl::Error> { |
| self.action |
| .lock() |
| .send(action) |
| .map_err(|_| fidl::Error::ClientWrite(zx::Status::PEER_CLOSED)) |
| } |
| } |
| |
| #[test] |
| fn test_mock_ime_channels() { |
| let (client, statechan, actionchan) = MockImeClient::new(); |
| let mut ime = Ime::new( |
| uii::KeyboardType::Text, |
| uii::InputMethodAction::Search, |
| default_state(), |
| client, |
| ImeService::new(), |
| ); |
| assert_eq!(true, statechan.try_recv().is_err()); |
| assert_eq!(true, actionchan.try_recv().is_err()); |
| simulate_keypress(&mut ime, 'a', false, uii::MODIFIER_NONE); |
| assert_eq!(false, statechan.try_recv().is_err()); |
| assert_eq!(true, actionchan.try_recv().is_err()); |
| } |
| |
| #[test] |
| fn test_delete_backward_empty_string() { |
| let (mut ime, statechan, _actionchan) = set_up("", -1, -1); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!(0, state.selection.base); |
| assert_eq!(0, state.selection.extent); |
| |
| // a second delete still does nothing, but increments revision |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(3, state.revision); |
| assert_eq!(0, state.selection.base); |
| assert_eq!(0, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_forward_empty_string() { |
| let (mut ime, statechan, _actionchan) = set_up("", -1, -1); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_DELETE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!(0, state.selection.base); |
| assert_eq!(0, state.selection.extent); |
| |
| // a second delete still does nothing, but increments revision |
| simulate_keypress(&mut ime, HID_USAGE_KEY_DELETE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(3, state.revision); |
| assert_eq!(0, state.selection.base); |
| assert_eq!(0, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_backward_beginning_string() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi", 0, 0); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abcdefghi", state.text); |
| assert_eq!(0, state.selection.base); |
| assert_eq!(0, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_forward_beginning_string() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi", 0, 0); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_DELETE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("bcdefghi", state.text); |
| assert_eq!(0, state.selection.base); |
| assert_eq!(0, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_backward_first_char_selected() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi", 0, 1); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("bcdefghi", state.text); |
| assert_eq!(0, state.selection.base); |
| assert_eq!(0, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_forward_last_char_selected() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi", 8, 9); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_DELETE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abcdefgh", state.text); |
| assert_eq!(8, state.selection.base); |
| assert_eq!(8, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_backward_end_string() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi", 9, 9); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abcdefgh", state.text); |
| assert_eq!(8, state.selection.base); |
| assert_eq!(8, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_forward_end_string() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi", 9, 9); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_DELETE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abcdefghi", state.text); |
| assert_eq!(9, state.selection.base); |
| assert_eq!(9, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_backward_combining_diacritic() { |
| // U+0301: combining acute accent. 2 bytes. |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi\u{0301}", 11, 11); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abcdefghi", state.text); |
| assert_eq!(9, state.selection.base); |
| assert_eq!(9, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_forward_combining_diacritic() { |
| // U+0301: combining acute accent. 2 bytes. |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi\u{0301}jkl", 8, 8); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_DELETE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abcdefghjkl", state.text); |
| assert_eq!(8, state.selection.base); |
| assert_eq!(8, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_backward_emoji() { |
| // Emoji with a color modifier. |
| let text = "abcdefghi👦🏻"; |
| let len = text.len() as i64; |
| let (mut ime, statechan, _actionchan) = set_up(text, len, len); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abcdefghi", state.text); |
| assert_eq!(9, state.selection.base); |
| assert_eq!(9, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_forward_emoji() { |
| // Emoji with a color modifier. |
| let text = "abcdefghi👦🏻"; |
| let (mut ime, statechan, _actionchan) = set_up(text, 9, 9); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_DELETE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abcdefghi", state.text); |
| assert_eq!(9, state.selection.base); |
| assert_eq!(9, state.selection.extent); |
| } |
| |
| /// Flags are more complicated because they consist of two REGIONAL INDICATOR SYMBOL LETTERs. |
| #[test] |
| fn test_delete_backward_flag() { |
| // French flag |
| let text = "abcdefghi🇫🇷"; |
| let len = text.len() as i64; |
| let (mut ime, statechan, _actionchan) = set_up(text, len, len); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abcdefghi", state.text); |
| assert_eq!(9, state.selection.base); |
| assert_eq!(9, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_forward_flag() { |
| // French flag |
| let text = "abcdefghi🇫🇷"; |
| let (mut ime, statechan, _actionchan) = set_up(text, 9, 9); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_DELETE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abcdefghi", state.text); |
| assert_eq!(9, state.selection.base); |
| assert_eq!(9, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_selection() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi", 3, 6); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abcghi", state.text); |
| assert_eq!(3, state.selection.base); |
| assert_eq!(3, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_selection_inverted() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi", 6, 3); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abcghi", state.text); |
| assert_eq!(3, state.selection.base); |
| assert_eq!(3, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_no_selection() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi", -1, -1); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abcdefghi", state.text); |
| assert_eq!(0, state.selection.base); |
| assert_eq!(0, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_with_zero_width_selection() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi", 3, 3); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abdefghi", state.text); |
| assert_eq!(2, state.selection.base); |
| assert_eq!(2, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_with_zero_width_selection_at_end() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi", 9, 9); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abcdefgh", state.text); |
| assert_eq!(8, state.selection.base); |
| assert_eq!(8, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_delete_selection_out_of_bounds() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi", 20, 24); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abcdefgh", state.text); |
| assert_eq!(8, state.selection.base); |
| assert_eq!(8, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_cursor_left_on_selection() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi", 1, 5); |
| |
| // right with shift |
| simulate_keypress(&mut ime, HID_USAGE_KEY_RIGHT, true, uii::MODIFIER_SHIFT); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!(1, state.selection.base); |
| assert_eq!(6, state.selection.extent); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_LEFT, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(3, state.revision); |
| assert_eq!(1, state.selection.base); |
| assert_eq!(1, state.selection.extent); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_LEFT, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(4, state.revision); |
| assert_eq!(0, state.selection.base); |
| assert_eq!(0, state.selection.extent); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_LEFT, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(5, state.revision); |
| assert_eq!(0, state.selection.base); |
| assert_eq!(0, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_cursor_left_on_inverted_selection() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi", 6, 3); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_LEFT, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!(3, state.selection.base); |
| assert_eq!(3, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_cursor_right_on_selection() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdefghi", 3, 9); |
| |
| // left with shift |
| simulate_keypress(&mut ime, HID_USAGE_KEY_LEFT, true, uii::MODIFIER_SHIFT); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!(3, state.selection.base); |
| assert_eq!(8, state.selection.extent); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_RIGHT, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(3, state.revision); |
| assert_eq!(8, state.selection.base); |
| assert_eq!(8, state.selection.extent); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_RIGHT, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(4, state.revision); |
| assert_eq!(9, state.selection.base); |
| assert_eq!(9, state.selection.extent); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_RIGHT, true, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(5, state.revision); |
| assert_eq!(9, state.selection.base); |
| assert_eq!(9, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_cursor_word_left_no_words() { |
| let (mut ime, statechan, _actionchan) = set_up("¿ - _ - ?", 5, 5); |
| |
| // left with control |
| simulate_keypress(&mut ime, HID_USAGE_KEY_LEFT, true, uii::MODIFIER_CONTROL); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!(0, state.selection.base); |
| assert_eq!(0, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_cursor_word_left() { |
| let (mut ime, statechan, _actionchan) = set_up("4.2 . foobar", 7, 7); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_LEFT, true, uii::MODIFIER_CONTROL); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!(6, state.selection.base); |
| assert_eq!(6, state.selection.extent); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_LEFT, true, uii::MODIFIER_CONTROL); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(3, state.revision); |
| assert_eq!(0, state.selection.base); |
| assert_eq!(0, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_cursor_word_right_no_words() { |
| let (mut ime, statechan, _actionchan) = set_up("¿ - _ - ?", 5, 5); |
| |
| // right with control |
| simulate_keypress(&mut ime, HID_USAGE_KEY_RIGHT, true, uii::MODIFIER_CONTROL); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!(10, state.selection.base); |
| assert_eq!(10, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_cursor_word_right() { |
| let (mut ime, statechan, _actionchan) = set_up("4.2 . foobar", 1, 1); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_RIGHT, true, uii::MODIFIER_CONTROL); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!(3, state.selection.base); |
| assert_eq!(3, state.selection.extent); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_RIGHT, true, uii::MODIFIER_CONTROL); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(3, state.revision); |
| assert_eq!(12, state.selection.base); |
| assert_eq!(12, state.selection.extent); |
| |
| // Try to navigate off text limits. |
| simulate_keypress(&mut ime, HID_USAGE_KEY_RIGHT, true, uii::MODIFIER_CONTROL); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(4, state.revision); |
| assert_eq!(12, state.selection.base); |
| assert_eq!(12, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_cursor_word_off_limits() { |
| let (mut ime, statechan, _actionchan) = set_up("word", 1, 1); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_RIGHT, true, uii::MODIFIER_CONTROL); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!(4, state.selection.base); |
| assert_eq!(4, state.selection.extent); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_RIGHT, true, uii::MODIFIER_CONTROL); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(3, state.revision); |
| assert_eq!(4, state.selection.base); |
| assert_eq!(4, state.selection.extent); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_LEFT, true, uii::MODIFIER_CONTROL); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(4, state.revision); |
| assert_eq!(0, state.selection.base); |
| assert_eq!(0, state.selection.extent); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_LEFT, true, uii::MODIFIER_CONTROL); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(5, state.revision); |
| assert_eq!(0, state.selection.base); |
| assert_eq!(0, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_cursor_word() { |
| let (mut ime, statechan, _actionchan) = set_up("a.c 2.2 ¿? x yz", 8, 8); |
| |
| simulate_keypress( |
| &mut ime, |
| HID_USAGE_KEY_RIGHT, |
| true, |
| uii::MODIFIER_CONTROL | uii::MODIFIER_SHIFT, |
| ); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!(8, state.selection.base); |
| assert_eq!(9, state.selection.extent); |
| |
| simulate_keypress( |
| &mut ime, |
| HID_USAGE_KEY_RIGHT, |
| true, |
| uii::MODIFIER_CONTROL | uii::MODIFIER_SHIFT, |
| ); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(3, state.revision); |
| assert_eq!(8, state.selection.base); |
| assert_eq!(15, state.selection.extent); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_LEFT, true, uii::MODIFIER_CONTROL); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(4, state.revision); |
| assert_eq!(6, state.selection.base); |
| assert_eq!(6, state.selection.extent); |
| |
| simulate_keypress( |
| &mut ime, |
| HID_USAGE_KEY_LEFT, |
| true, |
| uii::MODIFIER_CONTROL | uii::MODIFIER_SHIFT, |
| ); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(5, state.revision); |
| assert_eq!(6, state.selection.base); |
| assert_eq!(0, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_type_empty_string() { |
| let (mut ime, statechan, _actionchan) = set_up("", 0, 0); |
| |
| simulate_keypress(&mut ime, 'a', false, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("a", state.text); |
| assert_eq!(1, state.selection.base); |
| assert_eq!(1, state.selection.extent); |
| |
| simulate_keypress(&mut ime, 'b', false, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(3, state.revision); |
| assert_eq!("ab", state.text); |
| assert_eq!(2, state.selection.base); |
| assert_eq!(2, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_type_at_beginning() { |
| let (mut ime, statechan, _actionchan) = set_up("cde", 0, 0); |
| |
| simulate_keypress(&mut ime, 'a', false, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("acde", state.text); |
| assert_eq!(1, state.selection.base); |
| assert_eq!(1, state.selection.extent); |
| |
| simulate_keypress(&mut ime, 'b', false, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(3, state.revision); |
| assert_eq!("abcde", state.text); |
| assert_eq!(2, state.selection.base); |
| assert_eq!(2, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_type_selection() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdef", 2, 5); |
| |
| simulate_keypress(&mut ime, 'x', false, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abxf", state.text); |
| assert_eq!(3, state.selection.base); |
| assert_eq!(3, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_type_inverted_selection() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdef", 5, 2); |
| |
| simulate_keypress(&mut ime, 'x', false, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("abxf", state.text); |
| assert_eq!(3, state.selection.base); |
| assert_eq!(3, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_type_invalid_selection() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdef", -10, 1); |
| |
| simulate_keypress(&mut ime, 'x', false, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("xbcdef", state.text); |
| assert_eq!(1, state.selection.base); |
| assert_eq!(1, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_set_state() { |
| let (mut ime, statechan, _actionchan) = set_up("abcdef", 1, 1); |
| |
| let mut override_state = default_state(); |
| override_state.text = "meow?".to_string(); |
| override_state.selection.base = 4; |
| override_state.selection.extent = 5; |
| ime.set_state(override_state); |
| simulate_keypress(&mut ime, '!', false, uii::MODIFIER_NONE); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("meow!", state.text); |
| assert_eq!(5, state.selection.base); |
| assert_eq!(5, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_action() { |
| let (mut ime, statechan, actionchan) = set_up("abcdef", 1, 1); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_ENTER, true, uii::MODIFIER_NONE); |
| assert!(statechan.try_recv().is_err()); // assert did not update state |
| assert!(actionchan.try_recv().is_ok()); // assert DID send action |
| } |
| |
| #[test] |
| fn test_unicode_selection() { |
| let (mut ime, statechan, _actionchan) = set_up("m😸eow", 1, 1); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_RIGHT, true, uii::MODIFIER_SHIFT); |
| assert!(statechan.try_recv().is_ok()); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_SHIFT); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(3, state.revision); |
| assert_eq!("meow", state.text); |
| assert_eq!(1, state.selection.base); |
| assert_eq!(1, state.selection.extent); |
| } |
| |
| #[test] |
| fn test_unicode_backspace() { |
| let base: i64 = "m😸".len() as i64; |
| let (mut ime, statechan, _actionchan) = set_up("m😸eow", base, base); |
| |
| simulate_keypress(&mut ime, HID_USAGE_KEY_BACKSPACE, true, uii::MODIFIER_SHIFT); |
| let state = statechan.try_recv().unwrap(); |
| assert_eq!(2, state.revision); |
| assert_eq!("meow", state.text); |
| assert_eq!(1, state.selection.base); |
| assert_eq!(1, state.selection.extent); |
| } |
| } |
