| // Copyright 2020 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. |
| #![cfg(test)] |
| |
| use { |
| anyhow::{Context as _, Result}, |
| assert_matches::assert_matches, |
| fidl::endpoints::DiscoverableProtocolMarker, |
| fidl::endpoints::{create_request_stream, ProtocolMarker as _}, |
| fidl_fuchsia_input as input, fidl_fuchsia_ui_input as fidl_input, |
| fidl_fuchsia_ui_input3 as ui_input3, fidl_fuchsia_ui_keyboard_focus as fidl_focus, |
| fidl_fuchsia_ui_views as ui_views, fuchsia_async as fasync, |
| fuchsia_component_test::{ |
| Capability, ChildOptions, ChildRef, RealmBuilder, RealmInstance, Ref, Route, |
| }, |
| fuchsia_scenic as scenic, fuchsia_zircon as zx, |
| futures::FutureExt, |
| futures::{ |
| future, |
| stream::{FusedStream, StreamExt}, |
| }, |
| test_case::test_case, |
| test_helpers::create_key_event, |
| }; |
| |
| const URL_TEXT_MANAGER: &str = |
| "fuchsia-pkg://fuchsia.com/keyboard_test_parallel#meta/text_manager.cm"; |
| |
| // A shorthand for type safe routing the given protocol from a child to the parent. |
| async fn route_to_parent<P: DiscoverableProtocolMarker>( |
| builder: &RealmBuilder, |
| child: &ChildRef, |
| ) -> Result<(), fuchsia_component_test::error::Error> { |
| builder |
| .add_route( |
| Route::new().capability(Capability::protocol::<P>()).from(child).to(Ref::parent()), |
| ) |
| .await |
| } |
| |
| /// Wrapper for a `NestedEnvironment` that exposes the protocols offered by text_manager. |
| /// Running each test method in its own environment allows the tests to be run in parallel. |
| struct TestEnvironment { |
| realm: RealmInstance, |
| } |
| |
| impl TestEnvironment { |
| async fn new() -> Result<Self> { |
| let builder = RealmBuilder::new().await?; |
| let text_manager = |
| builder.add_child("text_manager", URL_TEXT_MANAGER, ChildOptions::new()).await?; |
| |
| route_to_parent::<ui_input3::KeyboardMarker>(&builder, &text_manager).await?; |
| route_to_parent::<fidl_input::ImeServiceMarker>(&builder, &text_manager).await?; |
| route_to_parent::<ui_input3::KeyEventInjectorMarker>(&builder, &text_manager).await?; |
| route_to_parent::<fidl_focus::ControllerMarker>(&builder, &text_manager).await?; |
| builder |
| .add_route( |
| Route::new() |
| .capability(Capability::protocol::<fidl_fuchsia_logger::LogSinkMarker>()) |
| .from(Ref::parent()) |
| .to(&text_manager), |
| ) |
| .await?; |
| |
| let realm = builder.build().await?; |
| |
| Ok(TestEnvironment { realm }) |
| } |
| |
| /// Connects to the given discoverable service in the `NestedEnvironment`, with a readable |
| /// context on error. |
| fn connect_to_env_service<P>(&self) -> Result<P> |
| where |
| P: fidl::endpoints::Proxy, |
| P::Protocol: fidl::endpoints::DiscoverableProtocolMarker, |
| { |
| let conn = |
| self.realm.root.connect_to_protocol_at_exposed_dir::<P::Protocol>().with_context( |
| || format!("Failed to connect to test realm's {}", P::Protocol::DEBUG_NAME), |
| ); |
| tracing::debug!("Connected to test realm's {}", P::Protocol::DEBUG_NAME); |
| conn |
| } |
| |
| fn connect_to_focus_controller(&self) -> Result<fidl_focus::ControllerProxy> { |
| self.connect_to_env_service::<_>() |
| } |
| |
| fn connect_to_keyboard_service(&self) -> Result<ui_input3::KeyboardProxy> { |
| self.connect_to_env_service::<_>() |
| } |
| |
| fn connect_to_key_event_injector(&self) -> Result<ui_input3::KeyEventInjectorProxy> { |
| self.connect_to_env_service::<_>() |
| } |
| } |
| |
| fn create_key_down_event(key: input::Key, modifiers: ui_input3::Modifiers) -> ui_input3::KeyEvent { |
| ui_input3::KeyEvent { |
| timestamp: Some(0), |
| key: Some(key), |
| modifiers: Some(modifiers), |
| type_: Some(ui_input3::KeyEventType::Pressed), |
| ..Default::default() |
| } |
| } |
| |
| fn create_key_up_event(key: input::Key, modifiers: ui_input3::Modifiers) -> ui_input3::KeyEvent { |
| ui_input3::KeyEvent { |
| timestamp: Some(0), |
| key: Some(key), |
| modifiers: Some(modifiers), |
| type_: Some(ui_input3::KeyEventType::Released), |
| ..Default::default() |
| } |
| } |
| |
| async fn expect_key_event( |
| listener: &mut ui_input3::KeyboardListenerRequestStream, |
| ) -> ui_input3::KeyEvent { |
| let listener_request = listener.next().await; |
| if let Some(Ok(ui_input3::KeyboardListenerRequest::OnKeyEvent { event, responder, .. })) = |
| listener_request |
| { |
| responder.send(ui_input3::KeyEventStatus::Handled).expect("responding from key listener"); |
| event |
| } else { |
| panic!("Expected key event, got {:?}", listener_request); |
| } |
| } |
| |
| async fn dispatch_and_expect_key_event<'a>( |
| key_dispatcher: &'a test_helpers::KeySimulator<'a>, |
| listener: &mut ui_input3::KeyboardListenerRequestStream, |
| event: ui_input3::KeyEvent, |
| ) -> Result<()> { |
| let (was_handled, event_result) = |
| future::join(key_dispatcher.dispatch(event.clone()), expect_key_event(listener)).await; |
| |
| assert_eq!(was_handled?, true); |
| assert_eq!(event_result.key, event.key); |
| assert_eq!(event_result.type_, event.type_); |
| Ok(()) |
| } |
| |
| async fn expect_key_and_modifiers( |
| listener: &mut ui_input3::KeyboardListenerRequestStream, |
| key: input::Key, |
| modifiers: ui_input3::Modifiers, |
| ) { |
| let event = expect_key_event(listener).await; |
| assert_eq!(event.key, Some(key)); |
| assert_eq!(event.modifiers, Some(modifiers)); |
| } |
| |
| async fn test_disconnecting_keyboard_client_disconnects_listener_with_connections( |
| focus_ctl: fidl_focus::ControllerProxy, |
| key_simulator: &'_ test_helpers::KeySimulator<'_>, |
| keyboard_service_client: ui_input3::KeyboardProxy, |
| keyboard_service_other_client: &ui_input3::KeyboardProxy, |
| ) -> Result<()> { |
| tracing::debug!("test_disconnecting_keyboard_client_disconnects_listener_with_connections"); |
| |
| // Create fake client. |
| let (listener_client_end, mut listener) = |
| fidl::endpoints::create_request_stream::<ui_input3::KeyboardListenerMarker>()?; |
| let view_ref = scenic::ViewRefPair::new()?.view_ref; |
| |
| keyboard_service_client |
| .add_listener(scenic::duplicate_view_ref(&view_ref)?, listener_client_end) |
| .await |
| .expect("add_listener for first client"); |
| |
| // Create another fake client. |
| let (other_listener_client_end, mut other_listener) = |
| fidl::endpoints::create_request_stream::<ui_input3::KeyboardListenerMarker>()?; |
| let other_view_ref = scenic::ViewRefPair::new()?.view_ref; |
| |
| keyboard_service_other_client |
| .add_listener(scenic::duplicate_view_ref(&other_view_ref)?, other_listener_client_end) |
| .await |
| .expect("add_listener for another client"); |
| |
| // Focus second client. |
| focus_ctl.notify(scenic::duplicate_view_ref(&other_view_ref)?).await?; |
| |
| // Drop proxy, emulating first client disconnecting from it. |
| std::mem::drop(keyboard_service_client); |
| |
| // Expect disconnected client key event listener to be disconnected as well. |
| assert_matches!(listener.next().await, None); |
| assert_matches!(listener.is_terminated(), true); |
| |
| // Ensure that the other client is still connected. |
| let (key, modifiers) = (input::Key::A, ui_input3::Modifiers::CAPS_LOCK); |
| let dispatched_event = create_key_down_event(key, modifiers); |
| |
| let (was_handled, _) = future::join( |
| key_simulator.dispatch(dispatched_event), |
| expect_key_and_modifiers(&mut other_listener, key, modifiers), |
| ) |
| .await; |
| |
| assert_eq!(was_handled?, true); |
| |
| let dispatched_event = create_key_up_event(key, modifiers); |
| let (was_handled, _) = future::join( |
| key_simulator.dispatch(dispatched_event), |
| expect_key_and_modifiers(&mut other_listener, key, modifiers), |
| ) |
| .await; |
| |
| assert_eq!(was_handled?, true); |
| Ok(()) |
| } |
| |
| #[fuchsia::test(logging_tags = ["keyboard3_integration_test"])] |
| async fn test_disconnecting_keyboard_client_disconnects_listener_via_key_event_injector( |
| ) -> Result<()> { |
| let test_env = TestEnvironment::new().await?; |
| |
| let key_event_injector = test_env.connect_to_key_event_injector()?; |
| |
| let key_dispatcher = |
| test_helpers::KeyEventInjectorDispatcher { key_event_injector: &key_event_injector }; |
| let key_simulator = test_helpers::KeySimulator::new(&key_dispatcher); |
| |
| let keyboard_service_client_a = test_env.connect_to_keyboard_service().context("client_a")?; |
| |
| let keyboard_service_client_b = test_env.connect_to_keyboard_service().context("client_b")?; |
| |
| test_disconnecting_keyboard_client_disconnects_listener_with_connections( |
| test_env.connect_to_focus_controller()?, |
| &key_simulator, |
| // This one will be dropped as part of the test, so needs to be moved. |
| keyboard_service_client_a, |
| &keyboard_service_client_b, |
| ) |
| .await?; |
| |
| Ok(()) |
| } |
| |
| async fn test_sync_cancel_with_connections( |
| focus_ctl: fidl_focus::ControllerProxy, |
| key_simulator: &'_ test_helpers::KeySimulator<'_>, |
| keyboard_service_client_a: &ui_input3::KeyboardProxy, |
| keyboard_service_client_b: &ui_input3::KeyboardProxy, |
| ) -> Result<()> { |
| // Create fake client. |
| let (listener_client_end_a, mut listener_a) = |
| fidl::endpoints::create_request_stream::<ui_input3::KeyboardListenerMarker>()?; |
| let view_ref_a = scenic::ViewRefPair::new()?.view_ref; |
| |
| keyboard_service_client_a |
| .add_listener(scenic::duplicate_view_ref(&view_ref_a)?, listener_client_end_a) |
| .await |
| .expect("add_listener for first client"); |
| |
| // Create another fake client. |
| let (listener_client_end_b, mut listener_b) = |
| fidl::endpoints::create_request_stream::<ui_input3::KeyboardListenerMarker>()?; |
| let view_ref_b = scenic::ViewRefPair::new()?.view_ref; |
| |
| keyboard_service_client_b |
| .add_listener(scenic::duplicate_view_ref(&view_ref_b)?, listener_client_end_b) |
| .await |
| .expect("add_listener for another client"); |
| |
| let key1 = input::Key::A; |
| let event1_press = ui_input3::KeyEvent { |
| timestamp: Some(0), |
| key: Some(key1), |
| type_: Some(ui_input3::KeyEventType::Pressed), |
| ..Default::default() |
| }; |
| let event1_release = ui_input3::KeyEvent { |
| timestamp: Some(0), |
| key: Some(key1), |
| type_: Some(ui_input3::KeyEventType::Released), |
| ..Default::default() |
| }; |
| |
| // Focus client A. |
| focus_ctl.notify(scenic::duplicate_view_ref(&view_ref_a)?).await?; |
| |
| // Press the key and expect client A to receive the event. |
| dispatch_and_expect_key_event(&key_simulator, &mut listener_a, event1_press).await?; |
| |
| assert!(listener_b.next().now_or_never().is_none(), "listener_b should have no events yet"); |
| |
| // Focus client B. |
| // Expect a cancel event for client A and a sync event for the client B. |
| let (focus_result, client_a_event, client_b_event) = future::join3( |
| focus_ctl.notify(scenic::duplicate_view_ref(&view_ref_b)?), |
| expect_key_event(&mut listener_a), |
| expect_key_event(&mut listener_b), |
| ) |
| .await; |
| |
| focus_result?; |
| |
| assert_eq!( |
| ui_input3::KeyEvent { |
| timestamp: Some(0i64), |
| key: Some(input::Key::A), |
| type_: Some(ui_input3::KeyEventType::Cancel), |
| ..Default::default() |
| }, |
| client_a_event |
| ); |
| |
| assert_eq!( |
| ui_input3::KeyEvent { |
| timestamp: Some(0i64), |
| key: Some(input::Key::A), |
| type_: Some(ui_input3::KeyEventType::Sync), |
| ..Default::default() |
| }, |
| client_b_event |
| ); |
| |
| // Release the key and expect client B to receive an event. |
| dispatch_and_expect_key_event(&key_simulator, &mut listener_b, event1_release).await?; |
| |
| assert!(listener_a.next().now_or_never().is_none(), "listener_a should have no more events"); |
| |
| // Focus client A again. |
| focus_ctl.notify(scenic::duplicate_view_ref(&view_ref_a)?).await?; |
| |
| assert!( |
| listener_a.next().now_or_never().is_none(), |
| "listener_a should have no more events after receiving focus" |
| ); |
| |
| Ok(()) |
| } |
| |
| #[fuchsia::test(logging_tags = ["keyboard3_integration_test"])] |
| async fn test_sync_cancel_via_key_event_injector() -> Result<()> { |
| let test_env = TestEnvironment::new().await?; |
| |
| // This test dispatches keys via KeyEventInjector. |
| let key_event_injector = test_env.connect_to_key_event_injector()?; |
| |
| let key_dispatcher = |
| test_helpers::KeyEventInjectorDispatcher { key_event_injector: &key_event_injector }; |
| let key_simulator = test_helpers::KeySimulator::new(&key_dispatcher); |
| |
| let keyboard_service_client_a = test_env.connect_to_keyboard_service().context("client_a")?; |
| |
| let keyboard_service_client_b = test_env.connect_to_keyboard_service().context("client_b")?; |
| |
| test_sync_cancel_with_connections( |
| test_env.connect_to_focus_controller()?, |
| &key_simulator, |
| &keyboard_service_client_a, |
| &keyboard_service_client_b, |
| ) |
| .await |
| } |
| |
| struct TestHandles { |
| _test_env: TestEnvironment, |
| _keyboard_service: ui_input3::KeyboardProxy, |
| listener_stream: ui_input3::KeyboardListenerRequestStream, |
| injector_service: ui_input3::KeyEventInjectorProxy, |
| _view_ref: ui_views::ViewRef, |
| } |
| |
| impl TestHandles { |
| async fn new() -> Result<TestHandles> { |
| let _test_env = TestEnvironment::new().await?; |
| |
| // Create fake client. |
| let (listener_client_end, listener_stream) = create_request_stream::< |
| ui_input3::KeyboardListenerMarker, |
| >() |
| .with_context(|| { |
| format!("create_request_stream for {}", ui_input3::KeyboardListenerMarker::DEBUG_NAME) |
| })?; |
| let _view_ref = scenic::ViewRefPair::new()?.view_ref; |
| |
| let _keyboard_service: ui_input3::KeyboardProxy = |
| _test_env.connect_to_keyboard_service()?; |
| _keyboard_service |
| .add_listener(scenic::duplicate_view_ref(&_view_ref)?, listener_client_end) |
| .await |
| .expect("add_listener"); |
| |
| let focus_controller = _test_env.connect_to_focus_controller()?; |
| focus_controller.notify(scenic::duplicate_view_ref(&_view_ref)?).await?; |
| |
| let injector_service = _test_env.connect_to_key_event_injector()?; |
| |
| Ok(TestHandles { |
| _test_env, |
| _keyboard_service, |
| listener_stream, |
| injector_service, |
| _view_ref, |
| }) |
| } |
| } |
| |
| fn inject_key_and_receive_keyboard_protocol_message( |
| event: ui_input3::KeyEvent, |
| ) -> Result<(Result<ui_input3::KeyEventStatus, fidl::Error>, ui_input3::KeyEvent)> { |
| fasync::TestExecutor::new().run_singlethreaded(async { |
| let mut handles = TestHandles::new().await?; |
| |
| let (was_handled, received_event) = future::join( |
| handles.injector_service.inject(&event), |
| expect_key_event(&mut handles.listener_stream), |
| ) |
| .await; |
| Ok((was_handled, received_event)) |
| }) |
| } |
| |
| #[test_case(input::Key::A, None => (Some(input::Key::A), None); "without_key_meaning")] |
| #[test_case(input::Key::A, 'a' |
| => (Some(input::Key::A), Some(ui_input3::KeyMeaning::Codepoint(0x61))); |
| "key_and_meaning")] |
| #[test_case(None, 'a' |
| => (None, Some(ui_input3::KeyMeaning::Codepoint(0x61))); |
| "only_key_meaning_lower_alpha")] |
| #[test_case(None, 'A' |
| => (None, Some(ui_input3::KeyMeaning::Codepoint(0x41))); |
| "only_key_meaning_upper_alpha")] |
| #[test_case(None, '1' |
| => (None, Some(ui_input3::KeyMeaning::Codepoint(0x31))); |
| "only_key_meaning_numeric")] |
| #[test_case(None, ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Enter) |
| => (Some(input::Key::Enter), |
| Some(ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Enter))); |
| "only_key_meaning_enter")] |
| #[test_case(None, ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Tab) |
| => (Some(input::Key::Tab), |
| Some(ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Tab))); |
| "only_key_meaning_tab")] |
| #[test_case(None, ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Backspace) |
| => (Some(input::Key::Backspace), |
| Some(ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Backspace))); |
| "only_key_meaning_backspace")] |
| #[test_case(input::Key::Down, ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Down) |
| => (Some(input::Key::Down), |
| Some(ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Down))); |
| "arrow_down")] |
| #[test_case(None, ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Down) |
| => (None, |
| Some(ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Down))); |
| "only_key_meaning_arrow_down")] |
| #[test_case(input::Key::Up, ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Up) |
| => (Some(input::Key::Up), |
| Some(ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Up))); |
| "arrow_up")] |
| #[test_case(input::Key::Left, ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Left) |
| => (Some(input::Key::Left), |
| Some(ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Left))); |
| "arrow_left")] |
| #[test_case(input::Key::Right, ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Right) |
| => (Some(input::Key::Right), |
| Some(ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Right))); |
| "arrow_right")] |
| #[test_case(input::Key::End, ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::End) |
| => (Some(input::Key::End), |
| Some(ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::End))); |
| "end")] |
| #[test_case(input::Key::Home, ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Home) |
| => (Some(input::Key::Home), |
| Some(ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::Home))); |
| "home")] |
| #[test_case(input::Key::PageDown, ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::PageDown) |
| => (Some(input::Key::PageDown), |
| Some(ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::PageDown))); |
| "page_down")] |
| #[test_case(input::Key::PageUp, ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::PageUp) |
| => (Some(input::Key::PageUp), |
| Some(ui_input3::KeyMeaning::NonPrintableKey(ui_input3::NonPrintableKey::PageUp))); |
| "page_up")] |
| fn test_inject_key_yields_expected_key_and_key_meaning( |
| key: impl Into<Option<input::Key>>, |
| key_meaning: impl Into<test_helpers::KeyMeaningWrapper>, |
| ) -> (Option<input::Key>, Option<ui_input3::KeyMeaning>) { |
| let (was_handled, received_event) = inject_key_and_receive_keyboard_protocol_message( |
| create_key_event(zx::Time::ZERO, ui_input3::KeyEventType::Pressed, key, None, key_meaning), |
| ) |
| .expect("injection failed"); |
| assert_matches::assert_matches!(was_handled, Ok(ui_input3::KeyEventStatus::Handled)); |
| (received_event.key, received_event.key_meaning) |
| } |
