Skip to main content

fake_reset/
lib.rs

1// Copyright 2026 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use 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    /// Returns and clears the current toggled state.
32    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}