src/ui/bin/text/tests/test_helpers.rs - fuchsia - Git at Google

 // Copyright 2021 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 async_trait::async_trait;
 use {
     anyhow::{format_err, Result},
     fidl_fuchsia_input as input, fidl_fuchsia_ui_input as ui_input,
     fidl_fuchsia_ui_input3 as ui_input3, fuchsia_zircon as zx,
     futures::{
         stream::{self, StreamExt, TryStreamExt},
         FutureExt,
     },
 };

 pub fn default_state() -> ui_input::TextInputState {
     ui_input::TextInputState {
         revision: 1,
         text: "".to_string(),
         selection: ui_input::TextSelection {
             base: 0,
             extent: 0,
             affinity: ui_input::TextAffinity::Upstream,
         },
         composing: ui_input::TextRange { start: -1, end: -1 },
     }
 }

 // Measure text in utf16 code units.
 pub fn measure_utf16(s: &str) -> usize {
     s.chars().map(|c| c.len_utf16()).sum::<usize>()
 }

 // Setup IME text edit state using contents and selection indices.
 pub async fn setup_ime(
     ime: &ui_input::InputMethodEditorProxy,
     text: &str,
     base: i64,
     extent: i64,
 ) -> Result<()> {
     let mut state = default_state();
     state.text = text.to_string();
     state.selection.base = base;
     state.selection.extent = extent;

     ime.set_state(&state).map_err(Into::into)
 }

 // Bind a new IME to the service.
 pub fn bind_editor(
     ime_service: &ui_input::ImeServiceProxy,
 ) -> Result<(ui_input::InputMethodEditorProxy, ui_input::InputMethodEditorClientRequestStream)> {
     let (ime, ime_server_end) =
         fidl::endpoints::create_proxy::<ui_input::InputMethodEditorMarker>().unwrap();
     let (editor_client_end, editor_request_stream) =
         fidl::endpoints::create_request_stream().unwrap();
     ime_service.get_input_method_editor(
         ui_input::KeyboardType::Text,
         ui_input::InputMethodAction::Done,
         &default_state(),
         editor_client_end,
         ime_server_end,
     )?;

     Ok((ime, editor_request_stream))
 }

 /// Provides a method for dispatching keys, in case the tests need to vary
 /// them.
 #[async_trait]
 pub trait KeyDispatcher {
     async fn dispatch(&self, event: ui_input3::KeyEvent) -> Result<bool>;
 }

 /// A [KeyDispatcher] that uses `fuchsia.ui.input.InputMethodEditor` to dispatch keypresses.
 pub struct InputMethodEditorDispatcher<'a> {
     pub ime: &'a ui_input::InputMethodEditorProxy,
 }

 #[async_trait]
 impl<'a> KeyDispatcher for InputMethodEditorDispatcher<'a> {
     async fn dispatch(&self, event: ui_input3::KeyEvent) -> Result<bool> {
         Ok(self.ime.dispatch_key3(&event).await?)
     }
 }

 /// A [KeyDispatcher] that uses `fuchsia.ui.input3.KeyEventInjector` to dispatch keypresses.
 pub struct KeyEventInjectorDispatcher<'a> {
     pub key_event_injector: &'a ui_input3::KeyEventInjectorProxy,
 }

 #[async_trait]
 impl<'a> KeyDispatcher for KeyEventInjectorDispatcher<'a> {
     async fn dispatch(&self, event: ui_input3::KeyEvent) -> Result<bool> {
         Ok(self.key_event_injector.inject(&event).await? == ui_input3::KeyEventStatus::Handled)
     }
 }

 /// A fixture that can use different services to send key events.  Use [KeySimulator::new] to
 /// create a new instance.
 ///
 /// # Example
 ///
 /// ```ignore
 /// let ime_service = connect_to_protocol::<ui_input::ImeServiceMarker>()
 ///     .context("Failed to connect to IME Service")?;
 /// let key_dispatcher = test_helpers::ImeServiceKeyDispatcher { ime_service: &ime_service };
 /// let key_simulator = test_helpers::KeySimulator::new(&key_dispatcher);
 /// // Thereafter...
 /// key_simulator.dispatch(fidl_fuchsia_ui_input3::KeyEvent{...}).await?;
 /// ```
 pub struct KeySimulator<'a> {
     dispatcher: &'a dyn KeyDispatcher,
 }

 impl<'a> KeySimulator<'a> {
     pub fn new(dispatcher: &'a dyn KeyDispatcher) -> Self {
         KeySimulator { dispatcher }
     }

     pub async fn dispatch(&self, event: ui_input3::KeyEvent) -> Result<bool> {
         self.dispatcher.dispatch(event).await
     }

     // Simulate a key press and release of `key`.
     async fn simulate_keypress(&self, key: input::Key) -> Result<()> {
         self.dispatch(ui_input3::KeyEvent {
             timestamp: Some(0),
             type_: Some(ui_input3::KeyEventType::Pressed),
             key: Some(key),
             ..Default::default()
         })
         .await?;
         self.dispatch(ui_input3::KeyEvent {
             timestamp: Some(0),
             type_: Some(ui_input3::KeyEventType::Released),
             key: Some(key),
             ..Default::default()
         })
         .await?;
         Ok(())
     }

     // Simulate keypress with `held_keys` pressed down.
     async fn simulate_ime_keypress_with_held_keys(
         &self,
         key: input::Key,
         held_keys: Vec<input::Key>,
     ) {
         let held_keys_down =
             held_keys.iter().map(|k| (ui_input3::KeyEventType::Pressed, *k)).into_iter();
         let held_keys_up =
             held_keys.iter().map(|k| (ui_input3::KeyEventType::Released, *k)).into_iter();
         let key_press_and_release =
             vec![(ui_input3::KeyEventType::Pressed, key), (ui_input3::KeyEventType::Released, key)]
                 .into_iter();
         let sequence = held_keys_down.chain(key_press_and_release).chain(held_keys_up);
         stream::iter(sequence)
             .for_each(|(type_, key)| {
                 self.dispatch(ui_input3::KeyEvent {
                     timestamp: Some(0),
                     type_: Some(type_),
                     key: Some(key),
                     ..Default::default()
                 })
                 .map(|_| ())
             })
             .await;
     }
 }

 // Simulate keypress by injecting an event into supplied key event injector.
 pub async fn simulate_keypress(
     key_event_injector: &ui_input3::KeyEventInjectorProxy,
     key: input::Key,
 ) -> Result<()> {
     let key_dispatcher = KeyEventInjectorDispatcher { key_event_injector: &key_event_injector };
     let key_simulator = KeySimulator::new(&key_dispatcher);
     key_simulator.simulate_keypress(key).await
 }

 // Simulate keypress by injecting into IME.
 pub async fn simulate_ime_keypress(ime: &ui_input::InputMethodEditorProxy, key: input::Key) {
     simulate_ime_keypress_with_held_keys(ime, key, Vec::new()).await
 }

 // Simulate keypress by injecting into IME, with `held_keys` pressed down.
 pub async fn simulate_ime_keypress_with_held_keys(
     ime: &ui_input::InputMethodEditorProxy,
     key: input::Key,
     held_keys: Vec<input::Key>,
 ) {
     let key_dispatcher = InputMethodEditorDispatcher { ime: &ime };
     let key_simulator = KeySimulator::new(&key_dispatcher);
     key_simulator.simulate_ime_keypress_with_held_keys(key, held_keys).await
 }

 // Get next IME message, assuming it's a `InputMethodEditorClientRequest::DidUpdateState`.
 pub async fn get_state_update(
     editor_stream: &mut ui_input::InputMethodEditorClientRequestStream,
 ) -> Result<(ui_input::TextInputState, Option<ui_input::KeyboardEvent>)> {
     editor_stream
         .map(|request| match request {
             Ok(ui_input::InputMethodEditorClientRequest::DidUpdateState {
                 state, event, ..
             }) => {
                 let keyboard_event = event.map(|e| {
                     if let ui_input::InputEvent::Keyboard(keyboard_event) = *e {
                         keyboard_event
                     } else {
                         panic!("expected DidUpdateState to only send Keyboard events");
                     }
                 });
                 Ok((state, keyboard_event))
             }
             Ok(msg) => Err(format_err!("request should be DidUpdateState, got {:?}", msg)),
             Err(err) => Err(Into::into(err)),
         })
         .try_next()
         .await
         .map(|maybe_msg| maybe_msg.ok_or(format_err!("ime should have sent message")))?
 }

 // Get next IME message, assuming it's a `InputMethodEditorClientRequest::OnAction`.
 pub async fn get_action(
     editor_stream: &mut ui_input::InputMethodEditorClientRequestStream,
 ) -> Result<ui_input::InputMethodAction> {
     editor_stream
         .map(|request| match request {
             Ok(ui_input::InputMethodEditorClientRequest::OnAction { action, .. }) => Ok(action),
             Ok(msg) => Err(format_err!("request should be OnAction, got {:?}", msg)),
             Err(err) => Err(Into::into(err)),
         })
         .try_next()
         .await
         .map(|maybe_msg| maybe_msg.ok_or(format_err!("ime should have sent message")))?
 }

 /// Used to reduce verbosity of instantiating `KeyMeaning`s.
 pub struct KeyMeaningWrapper(Option<ui_input3::KeyMeaning>);

 impl From<ui_input3::KeyMeaning> for KeyMeaningWrapper {
     fn from(src: ui_input3::KeyMeaning) -> Self {
         KeyMeaningWrapper(src.into())
     }
 }

 impl From<Option<ui_input3::KeyMeaning>> for KeyMeaningWrapper {
     fn from(src: Option<ui_input3::KeyMeaning>) -> Self {
         KeyMeaningWrapper(src)
     }
 }

 impl From<KeyMeaningWrapper> for Option<ui_input3::KeyMeaning> {
     fn from(src: KeyMeaningWrapper) -> Self {
         src.0
     }
 }

 impl From<char> for KeyMeaningWrapper {
     fn from(src: char) -> Self {
         Some(ui_input3::KeyMeaning::Codepoint(src as u32)).into()
     }
 }

 impl From<ui_input3::NonPrintableKey> for KeyMeaningWrapper {
     fn from(src: ui_input3::NonPrintableKey) -> Self {
         Some(ui_input3::KeyMeaning::NonPrintableKey(src)).into()
     }
 }

 /// Creates a `KeyEvent` with the given parameters.
 pub fn create_key_event(
     timestamp: zx::Time,
     event_type: ui_input3::KeyEventType,
     key: impl Into<Option<input::Key>>,
     modifiers: impl Into<Option<ui_input3::Modifiers>>,
     key_meaning: impl Into<KeyMeaningWrapper>,
 ) -> ui_input3::KeyEvent {
     let key_meaning: KeyMeaningWrapper = key_meaning.into();
     ui_input3::KeyEvent {
         timestamp: Some(timestamp.into_nanos()),
         type_: Some(event_type),
         key: key.into(),
         modifiers: modifiers.into(),
         key_meaning: key_meaning.into(),
         ..Default::default()
     }
 }
	// Copyright 2021 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 async_trait::async_trait;
	use {
	anyhow::{format_err, Result},
	fidl_fuchsia_input as input, fidl_fuchsia_ui_input as ui_input,
	fidl_fuchsia_ui_input3 as ui_input3, fuchsia_zircon as zx,
	futures::{
	stream::{self, StreamExt, TryStreamExt},
	FutureExt,
	},
	};

	pub fn default_state() -> ui_input::TextInputState {
	ui_input::TextInputState {
	revision: 1,
	text: "".to_string(),
	selection: ui_input::TextSelection {
	base: 0,
	extent: 0,
	affinity: ui_input::TextAffinity::Upstream,
	},
	composing: ui_input::TextRange { start: -1, end: -1 },
	}
	}

	// Measure text in utf16 code units.
	pub fn measure_utf16(s: &str) -> usize {
	s.chars().map(\|c\| c.len_utf16()).sum::<usize>()
	}

	// Setup IME text edit state using contents and selection indices.
	pub async fn setup_ime(
	ime: &ui_input::InputMethodEditorProxy,
	text: &str,
	base: i64,
	extent: i64,
	) -> Result<()> {
	let mut state = default_state();
	state.text = text.to_string();
	state.selection.base = base;
	state.selection.extent = extent;

	ime.set_state(&state).map_err(Into::into)
	}

	// Bind a new IME to the service.
	pub fn bind_editor(
	ime_service: &ui_input::ImeServiceProxy,
	) -> Result<(ui_input::InputMethodEditorProxy, ui_input::InputMethodEditorClientRequestStream)> {
	let (ime, ime_server_end) =
	fidl::endpoints::create_proxy::<ui_input::InputMethodEditorMarker>().unwrap();
	let (editor_client_end, editor_request_stream) =
	fidl::endpoints::create_request_stream().unwrap();
	ime_service.get_input_method_editor(
	ui_input::KeyboardType::Text,
	ui_input::InputMethodAction::Done,
	&default_state(),
	editor_client_end,
	ime_server_end,
	)?;

	Ok((ime, editor_request_stream))
	}

	/// Provides a method for dispatching keys, in case the tests need to vary
	/// them.
	#[async_trait]
	pub trait KeyDispatcher {
	async fn dispatch(&self, event: ui_input3::KeyEvent) -> Result<bool>;
	}

	/// A [KeyDispatcher] that uses `fuchsia.ui.input.InputMethodEditor` to dispatch keypresses.
	pub struct InputMethodEditorDispatcher<'a> {
	pub ime: &'a ui_input::InputMethodEditorProxy,
	}

	#[async_trait]
	impl<'a> KeyDispatcher for InputMethodEditorDispatcher<'a> {
	async fn dispatch(&self, event: ui_input3::KeyEvent) -> Result<bool> {
	Ok(self.ime.dispatch_key3(&event).await?)
	}
	}

	/// A [KeyDispatcher] that uses `fuchsia.ui.input3.KeyEventInjector` to dispatch keypresses.
	pub struct KeyEventInjectorDispatcher<'a> {
	pub key_event_injector: &'a ui_input3::KeyEventInjectorProxy,
	}

	#[async_trait]
	impl<'a> KeyDispatcher for KeyEventInjectorDispatcher<'a> {
	async fn dispatch(&self, event: ui_input3::KeyEvent) -> Result<bool> {
	Ok(self.key_event_injector.inject(&event).await? == ui_input3::KeyEventStatus::Handled)
	}
	}

	/// A fixture that can use different services to send key events. Use [KeySimulator::new] to
	/// create a new instance.
	///
	/// # Example
	///
	/// ```ignore
	/// let ime_service = connect_to_protocol::<ui_input::ImeServiceMarker>()
	/// .context("Failed to connect to IME Service")?;
	/// let key_dispatcher = test_helpers::ImeServiceKeyDispatcher { ime_service: &ime_service };
	/// let key_simulator = test_helpers::KeySimulator::new(&key_dispatcher);
	/// // Thereafter...
	/// key_simulator.dispatch(fidl_fuchsia_ui_input3::KeyEvent{...}).await?;
	/// ```
	pub struct KeySimulator<'a> {
	dispatcher: &'a dyn KeyDispatcher,
	}

	impl<'a> KeySimulator<'a> {
	pub fn new(dispatcher: &'a dyn KeyDispatcher) -> Self {
	KeySimulator { dispatcher }
	}

	pub async fn dispatch(&self, event: ui_input3::KeyEvent) -> Result<bool> {
	self.dispatcher.dispatch(event).await
	}

	// Simulate a key press and release of `key`.
	async fn simulate_keypress(&self, key: input::Key) -> Result<()> {
	self.dispatch(ui_input3::KeyEvent {
	timestamp: Some(0),
	type_: Some(ui_input3::KeyEventType::Pressed),
	key: Some(key),
	..Default::default()
	})
	.await?;
	self.dispatch(ui_input3::KeyEvent {
	timestamp: Some(0),
	type_: Some(ui_input3::KeyEventType::Released),
	key: Some(key),
	..Default::default()
	})
	.await?;
	Ok(())
	}

	// Simulate keypress with `held_keys` pressed down.
	async fn simulate_ime_keypress_with_held_keys(
	&self,
	key: input::Key,
	held_keys: Vec<input::Key>,
	) {
	let held_keys_down =
	held_keys.iter().map(\|k\| (ui_input3::KeyEventType::Pressed, *k)).into_iter();
	let held_keys_up =
	held_keys.iter().map(\|k\| (ui_input3::KeyEventType::Released, *k)).into_iter();
	let key_press_and_release =
	vec![(ui_input3::KeyEventType::Pressed, key), (ui_input3::KeyEventType::Released, key)]
	.into_iter();
	let sequence = held_keys_down.chain(key_press_and_release).chain(held_keys_up);
	stream::iter(sequence)
	.for_each(\|(type_, key)\| {
	self.dispatch(ui_input3::KeyEvent {
	timestamp: Some(0),
	type_: Some(type_),
	key: Some(key),
	..Default::default()
	})
	.map(\|_\| ())
	})
	.await;
	}
	}

	// Simulate keypress by injecting an event into supplied key event injector.
	pub async fn simulate_keypress(
	key_event_injector: &ui_input3::KeyEventInjectorProxy,
	key: input::Key,
	) -> Result<()> {
	let key_dispatcher = KeyEventInjectorDispatcher { key_event_injector: &key_event_injector };
	let key_simulator = KeySimulator::new(&key_dispatcher);
	key_simulator.simulate_keypress(key).await
	}

	// Simulate keypress by injecting into IME.
	pub async fn simulate_ime_keypress(ime: &ui_input::InputMethodEditorProxy, key: input::Key) {
	simulate_ime_keypress_with_held_keys(ime, key, Vec::new()).await
	}

	// Simulate keypress by injecting into IME, with `held_keys` pressed down.
	pub async fn simulate_ime_keypress_with_held_keys(
	ime: &ui_input::InputMethodEditorProxy,
	key: input::Key,
	held_keys: Vec<input::Key>,
	) {
	let key_dispatcher = InputMethodEditorDispatcher { ime: &ime };
	let key_simulator = KeySimulator::new(&key_dispatcher);
	key_simulator.simulate_ime_keypress_with_held_keys(key, held_keys).await
	}

	// Get next IME message, assuming it's a `InputMethodEditorClientRequest::DidUpdateState`.
	pub async fn get_state_update(
	editor_stream: &mut ui_input::InputMethodEditorClientRequestStream,
	) -> Result<(ui_input::TextInputState, Option<ui_input::KeyboardEvent>)> {
	editor_stream
	.map(\|request\| match request {
	Ok(ui_input::InputMethodEditorClientRequest::DidUpdateState {
	state, event, ..
	}) => {
	let keyboard_event = event.map(\|e\| {
	if let ui_input::InputEvent::Keyboard(keyboard_event) = *e {
	keyboard_event
	} else {
	panic!("expected DidUpdateState to only send Keyboard events");
	}
	});
	Ok((state, keyboard_event))
	}
	Ok(msg) => Err(format_err!("request should be DidUpdateState, got {:?}", msg)),
	Err(err) => Err(Into::into(err)),
	})
	.try_next()
	.await
	.map(\|maybe_msg\| maybe_msg.ok_or(format_err!("ime should have sent message")))?
	}

	// Get next IME message, assuming it's a `InputMethodEditorClientRequest::OnAction`.
	pub async fn get_action(
	editor_stream: &mut ui_input::InputMethodEditorClientRequestStream,
	) -> Result<ui_input::InputMethodAction> {
	editor_stream
	.map(\|request\| match request {
	Ok(ui_input::InputMethodEditorClientRequest::OnAction { action, .. }) => Ok(action),
	Ok(msg) => Err(format_err!("request should be OnAction, got {:?}", msg)),
	Err(err) => Err(Into::into(err)),
	})
	.try_next()
	.await
	.map(\|maybe_msg\| maybe_msg.ok_or(format_err!("ime should have sent message")))?
	}

	/// Used to reduce verbosity of instantiating `KeyMeaning`s.
	pub struct KeyMeaningWrapper(Option<ui_input3::KeyMeaning>);

	impl From<ui_input3::KeyMeaning> for KeyMeaningWrapper {
	fn from(src: ui_input3::KeyMeaning) -> Self {
	KeyMeaningWrapper(src.into())
	}
	}

	impl From<Option<ui_input3::KeyMeaning>> for KeyMeaningWrapper {
	fn from(src: Option<ui_input3::KeyMeaning>) -> Self {
	KeyMeaningWrapper(src)
	}
	}

	impl From<KeyMeaningWrapper> for Option<ui_input3::KeyMeaning> {
	fn from(src: KeyMeaningWrapper) -> Self {
	src.0
	}
	}

	impl From<char> for KeyMeaningWrapper {
	fn from(src: char) -> Self {
	Some(ui_input3::KeyMeaning::Codepoint(src as u32)).into()
	}
	}

	impl From<ui_input3::NonPrintableKey> for KeyMeaningWrapper {
	fn from(src: ui_input3::NonPrintableKey) -> Self {
	Some(ui_input3::KeyMeaning::NonPrintableKey(src)).into()
	}
	}

	/// Creates a `KeyEvent` with the given parameters.
	pub fn create_key_event(
	timestamp: zx::Time,
	event_type: ui_input3::KeyEventType,
	key: impl Into<Option<input::Key>>,
	modifiers: impl Into<Option<ui_input3::Modifiers>>,
	key_meaning: impl Into<KeyMeaningWrapper>,
	) -> ui_input3::KeyEvent {
	let key_meaning: KeyMeaningWrapper = key_meaning.into();
	ui_input3::KeyEvent {
	timestamp: Some(timestamp.into_nanos()),
	type_: Some(event_type),
	key: key.into(),
	modifiers: modifiers.into(),
	key_meaning: key_meaning.into(),
	..Default::default()
	}
	}