1use fidl_fuchsia_driver_framework as fdf;
6use fidl_next::{Request, Responder};
7use fidl_next_fuchsia_hardware_reset::{self as freset, ResetServerHandler};
8use fuchsia_async as fasync;
9use fuchsia_component::server::{ServiceFs, ServiceObjTrait};
10use fuchsia_sync::Mutex;
11use std::sync::Arc;
12
13struct FakeResetState {
14 asserted: bool,
15 toggled: bool,
16}
17
18pub struct FakeReset {
19 state: Arc<Mutex<FakeResetState>>,
20}
21
22impl FakeReset {
23 pub fn new() -> Self {
24 Self { state: Arc::new(Mutex::new(FakeResetState { asserted: false, toggled: false })) }
25 }
26
27 pub fn asserted(&self) -> bool {
28 self.state.lock().asserted
29 }
30
31 pub fn take_toggled(&mut self) -> bool {
33 let mut state = self.state.lock();
34 let toggled = state.toggled;
35 state.toggled = false;
36 toggled
37 }
38
39 pub fn serve<O: ServiceObjTrait>(
40 &self,
41 service_fs: &mut ServiceFs<O>,
42 scope: fasync::ScopeHandle,
43 instance_name: &str,
44 ) -> fdf::Offer {
45 fdf_component::ServiceOffer::<freset::Service>::new_next()
46 .add_default_named_next(
47 service_fs,
48 instance_name,
49 FakeResetService { state: self.state.clone(), scope },
50 )
51 .build_zircon_offer_next()
52 }
53}
54
55struct FakeResetService {
56 state: Arc<Mutex<FakeResetState>>,
57 scope: fasync::ScopeHandle,
58}
59
60impl freset::ServiceHandler for FakeResetService {
61 fn reset(&self, server_end: fidl_next::ServerEnd<freset::Reset>) {
62 server_end.spawn_on(FakeResetServer { state: self.state.clone() }, &self.scope);
63 }
64}
65
66struct FakeResetServer {
67 state: Arc<Mutex<FakeResetState>>,
68}
69
70impl ResetServerHandler for FakeResetServer {
71 async fn assert(&mut self, responder: Responder<freset::reset::Assert>) {
72 self.state.lock().asserted = true;
73 let _ = responder.respond(()).await;
74 }
75
76 async fn deassert(&mut self, responder: Responder<freset::reset::Deassert>) {
77 self.state.lock().asserted = false;
78 let _ = responder.respond(()).await;
79 }
80
81 async fn toggle(&mut self, responder: Responder<freset::reset::Toggle>) {
82 self.state.lock().toggled = true;
83 let _ = responder.respond(()).await;
84 }
85
86 async fn toggle_with_timeout(
87 &mut self,
88 _request: Request<freset::reset::ToggleWithTimeout>,
89 responder: Responder<freset::reset::ToggleWithTimeout>,
90 ) {
91 self.state.lock().toggled = true;
92 let _ = responder.respond(()).await;
93 }
94
95 async fn status(&mut self, responder: Responder<freset::reset::Status>) {
96 let asserted = self.state.lock().asserted;
97 let _ = responder.respond(asserted).await;
98 }
99}