fidl_fuchsia_diagnostics_test/
fidl_fuchsia_diagnostics_test.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_diagnostics_test_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
15pub struct DetectControllerEnterTestModeRequest {
16    pub test_controller: fidl::endpoints::ServerEnd<TestCaseControllerMarker>,
17}
18
19impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
20    for DetectControllerEnterTestModeRequest
21{
22}
23
24#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
25pub struct DetectControllerMarker;
26
27impl fidl::endpoints::ProtocolMarker for DetectControllerMarker {
28    type Proxy = DetectControllerProxy;
29    type RequestStream = DetectControllerRequestStream;
30    #[cfg(target_os = "fuchsia")]
31    type SynchronousProxy = DetectControllerSynchronousProxy;
32
33    const DEBUG_NAME: &'static str = "fuchsia.diagnostics.test.DetectController";
34}
35impl fidl::endpoints::DiscoverableProtocolMarker for DetectControllerMarker {}
36
37pub trait DetectControllerProxyInterface: Send + Sync {
38    type EnterTestModeResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
39    fn r#enter_test_mode(
40        &self,
41        test_controller: fidl::endpoints::ServerEnd<TestCaseControllerMarker>,
42    ) -> Self::EnterTestModeResponseFut;
43}
44#[derive(Debug)]
45#[cfg(target_os = "fuchsia")]
46pub struct DetectControllerSynchronousProxy {
47    client: fidl::client::sync::Client,
48}
49
50#[cfg(target_os = "fuchsia")]
51impl fidl::endpoints::SynchronousProxy for DetectControllerSynchronousProxy {
52    type Proxy = DetectControllerProxy;
53    type Protocol = DetectControllerMarker;
54
55    fn from_channel(inner: fidl::Channel) -> Self {
56        Self::new(inner)
57    }
58
59    fn into_channel(self) -> fidl::Channel {
60        self.client.into_channel()
61    }
62
63    fn as_channel(&self) -> &fidl::Channel {
64        self.client.as_channel()
65    }
66}
67
68#[cfg(target_os = "fuchsia")]
69impl DetectControllerSynchronousProxy {
70    pub fn new(channel: fidl::Channel) -> Self {
71        let protocol_name = <DetectControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
72        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
73    }
74
75    pub fn into_channel(self) -> fidl::Channel {
76        self.client.into_channel()
77    }
78
79    /// Waits until an event arrives and returns it. It is safe for other
80    /// threads to make concurrent requests while waiting for an event.
81    pub fn wait_for_event(
82        &self,
83        deadline: zx::MonotonicInstant,
84    ) -> Result<DetectControllerEvent, fidl::Error> {
85        DetectControllerEvent::decode(self.client.wait_for_event(deadline)?)
86    }
87
88    /// Enter the test mode. Return when the program is ready and idle.
89    /// If already in test mode, it will not return until the first test mode is
90    /// exited by closing its test_controller client_end.
91    pub fn r#enter_test_mode(
92        &self,
93        mut test_controller: fidl::endpoints::ServerEnd<TestCaseControllerMarker>,
94        ___deadline: zx::MonotonicInstant,
95    ) -> Result<(), fidl::Error> {
96        let _response = self
97            .client
98            .send_query::<DetectControllerEnterTestModeRequest, fidl::encoding::EmptyPayload>(
99                (test_controller,),
100                0x6f4bb79cfba4f84,
101                fidl::encoding::DynamicFlags::empty(),
102                ___deadline,
103            )?;
104        Ok(_response)
105    }
106}
107
108#[cfg(target_os = "fuchsia")]
109impl From<DetectControllerSynchronousProxy> for zx::Handle {
110    fn from(value: DetectControllerSynchronousProxy) -> Self {
111        value.into_channel().into()
112    }
113}
114
115#[cfg(target_os = "fuchsia")]
116impl From<fidl::Channel> for DetectControllerSynchronousProxy {
117    fn from(value: fidl::Channel) -> Self {
118        Self::new(value)
119    }
120}
121
122#[derive(Debug, Clone)]
123pub struct DetectControllerProxy {
124    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
125}
126
127impl fidl::endpoints::Proxy for DetectControllerProxy {
128    type Protocol = DetectControllerMarker;
129
130    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
131        Self::new(inner)
132    }
133
134    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
135        self.client.into_channel().map_err(|client| Self { client })
136    }
137
138    fn as_channel(&self) -> &::fidl::AsyncChannel {
139        self.client.as_channel()
140    }
141}
142
143impl DetectControllerProxy {
144    /// Create a new Proxy for fuchsia.diagnostics.test/DetectController.
145    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
146        let protocol_name = <DetectControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
147        Self { client: fidl::client::Client::new(channel, protocol_name) }
148    }
149
150    /// Get a Stream of events from the remote end of the protocol.
151    ///
152    /// # Panics
153    ///
154    /// Panics if the event stream was already taken.
155    pub fn take_event_stream(&self) -> DetectControllerEventStream {
156        DetectControllerEventStream { event_receiver: self.client.take_event_receiver() }
157    }
158
159    /// Enter the test mode. Return when the program is ready and idle.
160    /// If already in test mode, it will not return until the first test mode is
161    /// exited by closing its test_controller client_end.
162    pub fn r#enter_test_mode(
163        &self,
164        mut test_controller: fidl::endpoints::ServerEnd<TestCaseControllerMarker>,
165    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
166        DetectControllerProxyInterface::r#enter_test_mode(self, test_controller)
167    }
168}
169
170impl DetectControllerProxyInterface for DetectControllerProxy {
171    type EnterTestModeResponseFut =
172        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
173    fn r#enter_test_mode(
174        &self,
175        mut test_controller: fidl::endpoints::ServerEnd<TestCaseControllerMarker>,
176    ) -> Self::EnterTestModeResponseFut {
177        fn _decode(
178            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
179        ) -> Result<(), fidl::Error> {
180            let _response = fidl::client::decode_transaction_body::<
181                fidl::encoding::EmptyPayload,
182                fidl::encoding::DefaultFuchsiaResourceDialect,
183                0x6f4bb79cfba4f84,
184            >(_buf?)?;
185            Ok(_response)
186        }
187        self.client.send_query_and_decode::<DetectControllerEnterTestModeRequest, ()>(
188            (test_controller,),
189            0x6f4bb79cfba4f84,
190            fidl::encoding::DynamicFlags::empty(),
191            _decode,
192        )
193    }
194}
195
196pub struct DetectControllerEventStream {
197    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
198}
199
200impl std::marker::Unpin for DetectControllerEventStream {}
201
202impl futures::stream::FusedStream for DetectControllerEventStream {
203    fn is_terminated(&self) -> bool {
204        self.event_receiver.is_terminated()
205    }
206}
207
208impl futures::Stream for DetectControllerEventStream {
209    type Item = Result<DetectControllerEvent, fidl::Error>;
210
211    fn poll_next(
212        mut self: std::pin::Pin<&mut Self>,
213        cx: &mut std::task::Context<'_>,
214    ) -> std::task::Poll<Option<Self::Item>> {
215        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
216            &mut self.event_receiver,
217            cx
218        )?) {
219            Some(buf) => std::task::Poll::Ready(Some(DetectControllerEvent::decode(buf))),
220            None => std::task::Poll::Ready(None),
221        }
222    }
223}
224
225#[derive(Debug)]
226pub enum DetectControllerEvent {}
227
228impl DetectControllerEvent {
229    /// Decodes a message buffer as a [`DetectControllerEvent`].
230    fn decode(
231        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
232    ) -> Result<DetectControllerEvent, fidl::Error> {
233        let (bytes, _handles) = buf.split_mut();
234        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
235        debug_assert_eq!(tx_header.tx_id, 0);
236        match tx_header.ordinal {
237            _ => Err(fidl::Error::UnknownOrdinal {
238                ordinal: tx_header.ordinal,
239                protocol_name:
240                    <DetectControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
241            }),
242        }
243    }
244}
245
246/// A Stream of incoming requests for fuchsia.diagnostics.test/DetectController.
247pub struct DetectControllerRequestStream {
248    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
249    is_terminated: bool,
250}
251
252impl std::marker::Unpin for DetectControllerRequestStream {}
253
254impl futures::stream::FusedStream for DetectControllerRequestStream {
255    fn is_terminated(&self) -> bool {
256        self.is_terminated
257    }
258}
259
260impl fidl::endpoints::RequestStream for DetectControllerRequestStream {
261    type Protocol = DetectControllerMarker;
262    type ControlHandle = DetectControllerControlHandle;
263
264    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
265        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
266    }
267
268    fn control_handle(&self) -> Self::ControlHandle {
269        DetectControllerControlHandle { inner: self.inner.clone() }
270    }
271
272    fn into_inner(
273        self,
274    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
275    {
276        (self.inner, self.is_terminated)
277    }
278
279    fn from_inner(
280        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
281        is_terminated: bool,
282    ) -> Self {
283        Self { inner, is_terminated }
284    }
285}
286
287impl futures::Stream for DetectControllerRequestStream {
288    type Item = Result<DetectControllerRequest, fidl::Error>;
289
290    fn poll_next(
291        mut self: std::pin::Pin<&mut Self>,
292        cx: &mut std::task::Context<'_>,
293    ) -> std::task::Poll<Option<Self::Item>> {
294        let this = &mut *self;
295        if this.inner.check_shutdown(cx) {
296            this.is_terminated = true;
297            return std::task::Poll::Ready(None);
298        }
299        if this.is_terminated {
300            panic!("polled DetectControllerRequestStream after completion");
301        }
302        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
303            |bytes, handles| {
304                match this.inner.channel().read_etc(cx, bytes, handles) {
305                    std::task::Poll::Ready(Ok(())) => {}
306                    std::task::Poll::Pending => return std::task::Poll::Pending,
307                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
308                        this.is_terminated = true;
309                        return std::task::Poll::Ready(None);
310                    }
311                    std::task::Poll::Ready(Err(e)) => {
312                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
313                            e.into(),
314                        ))))
315                    }
316                }
317
318                // A message has been received from the channel
319                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
320
321                std::task::Poll::Ready(Some(match header.ordinal {
322                    0x6f4bb79cfba4f84 => {
323                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
324                        let mut req = fidl::new_empty!(
325                            DetectControllerEnterTestModeRequest,
326                            fidl::encoding::DefaultFuchsiaResourceDialect
327                        );
328                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DetectControllerEnterTestModeRequest>(&header, _body_bytes, handles, &mut req)?;
329                        let control_handle =
330                            DetectControllerControlHandle { inner: this.inner.clone() };
331                        Ok(DetectControllerRequest::EnterTestMode {
332                            test_controller: req.test_controller,
333
334                            responder: DetectControllerEnterTestModeResponder {
335                                control_handle: std::mem::ManuallyDrop::new(control_handle),
336                                tx_id: header.tx_id,
337                            },
338                        })
339                    }
340                    _ => Err(fidl::Error::UnknownOrdinal {
341                        ordinal: header.ordinal,
342                        protocol_name:
343                            <DetectControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
344                    }),
345                }))
346            },
347        )
348    }
349}
350
351/// Allows a test framework to invoke a special test mode and control program
352/// operations.
353#[derive(Debug)]
354pub enum DetectControllerRequest {
355    /// Enter the test mode. Return when the program is ready and idle.
356    /// If already in test mode, it will not return until the first test mode is
357    /// exited by closing its test_controller client_end.
358    EnterTestMode {
359        test_controller: fidl::endpoints::ServerEnd<TestCaseControllerMarker>,
360        responder: DetectControllerEnterTestModeResponder,
361    },
362}
363
364impl DetectControllerRequest {
365    #[allow(irrefutable_let_patterns)]
366    pub fn into_enter_test_mode(
367        self,
368    ) -> Option<(
369        fidl::endpoints::ServerEnd<TestCaseControllerMarker>,
370        DetectControllerEnterTestModeResponder,
371    )> {
372        if let DetectControllerRequest::EnterTestMode { test_controller, responder } = self {
373            Some((test_controller, responder))
374        } else {
375            None
376        }
377    }
378
379    /// Name of the method defined in FIDL
380    pub fn method_name(&self) -> &'static str {
381        match *self {
382            DetectControllerRequest::EnterTestMode { .. } => "enter_test_mode",
383        }
384    }
385}
386
387#[derive(Debug, Clone)]
388pub struct DetectControllerControlHandle {
389    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
390}
391
392impl fidl::endpoints::ControlHandle for DetectControllerControlHandle {
393    fn shutdown(&self) {
394        self.inner.shutdown()
395    }
396    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
397        self.inner.shutdown_with_epitaph(status)
398    }
399
400    fn is_closed(&self) -> bool {
401        self.inner.channel().is_closed()
402    }
403    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
404        self.inner.channel().on_closed()
405    }
406
407    #[cfg(target_os = "fuchsia")]
408    fn signal_peer(
409        &self,
410        clear_mask: zx::Signals,
411        set_mask: zx::Signals,
412    ) -> Result<(), zx_status::Status> {
413        use fidl::Peered;
414        self.inner.channel().signal_peer(clear_mask, set_mask)
415    }
416}
417
418impl DetectControllerControlHandle {}
419
420#[must_use = "FIDL methods require a response to be sent"]
421#[derive(Debug)]
422pub struct DetectControllerEnterTestModeResponder {
423    control_handle: std::mem::ManuallyDrop<DetectControllerControlHandle>,
424    tx_id: u32,
425}
426
427/// Set the the channel to be shutdown (see [`DetectControllerControlHandle::shutdown`])
428/// if the responder is dropped without sending a response, so that the client
429/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
430impl std::ops::Drop for DetectControllerEnterTestModeResponder {
431    fn drop(&mut self) {
432        self.control_handle.shutdown();
433        // Safety: drops once, never accessed again
434        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
435    }
436}
437
438impl fidl::endpoints::Responder for DetectControllerEnterTestModeResponder {
439    type ControlHandle = DetectControllerControlHandle;
440
441    fn control_handle(&self) -> &DetectControllerControlHandle {
442        &self.control_handle
443    }
444
445    fn drop_without_shutdown(mut self) {
446        // Safety: drops once, never accessed again due to mem::forget
447        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
448        // Prevent Drop from running (which would shut down the channel)
449        std::mem::forget(self);
450    }
451}
452
453impl DetectControllerEnterTestModeResponder {
454    /// Sends a response to the FIDL transaction.
455    ///
456    /// Sets the channel to shutdown if an error occurs.
457    pub fn send(self) -> Result<(), fidl::Error> {
458        let _result = self.send_raw();
459        if _result.is_err() {
460            self.control_handle.shutdown();
461        }
462        self.drop_without_shutdown();
463        _result
464    }
465
466    /// Similar to "send" but does not shutdown the channel if an error occurs.
467    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
468        let _result = self.send_raw();
469        self.drop_without_shutdown();
470        _result
471    }
472
473    fn send_raw(&self) -> Result<(), fidl::Error> {
474        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
475            (),
476            self.tx_id,
477            0x6f4bb79cfba4f84,
478            fidl::encoding::DynamicFlags::empty(),
479        )
480    }
481}
482
483#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
484pub struct TestCaseControllerMarker;
485
486impl fidl::endpoints::ProtocolMarker for TestCaseControllerMarker {
487    type Proxy = TestCaseControllerProxy;
488    type RequestStream = TestCaseControllerRequestStream;
489    #[cfg(target_os = "fuchsia")]
490    type SynchronousProxy = TestCaseControllerSynchronousProxy;
491
492    const DEBUG_NAME: &'static str = "(anonymous) TestCaseController";
493}
494
495pub trait TestCaseControllerProxyInterface: Send + Sync {
496    type RunDefaultCycleResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
497    fn r#run_default_cycle(&self) -> Self::RunDefaultCycleResponseFut;
498}
499#[derive(Debug)]
500#[cfg(target_os = "fuchsia")]
501pub struct TestCaseControllerSynchronousProxy {
502    client: fidl::client::sync::Client,
503}
504
505#[cfg(target_os = "fuchsia")]
506impl fidl::endpoints::SynchronousProxy for TestCaseControllerSynchronousProxy {
507    type Proxy = TestCaseControllerProxy;
508    type Protocol = TestCaseControllerMarker;
509
510    fn from_channel(inner: fidl::Channel) -> Self {
511        Self::new(inner)
512    }
513
514    fn into_channel(self) -> fidl::Channel {
515        self.client.into_channel()
516    }
517
518    fn as_channel(&self) -> &fidl::Channel {
519        self.client.as_channel()
520    }
521}
522
523#[cfg(target_os = "fuchsia")]
524impl TestCaseControllerSynchronousProxy {
525    pub fn new(channel: fidl::Channel) -> Self {
526        let protocol_name =
527            <TestCaseControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
528        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
529    }
530
531    pub fn into_channel(self) -> fidl::Channel {
532        self.client.into_channel()
533    }
534
535    /// Waits until an event arrives and returns it. It is safe for other
536    /// threads to make concurrent requests while waiting for an event.
537    pub fn wait_for_event(
538        &self,
539        deadline: zx::MonotonicInstant,
540    ) -> Result<TestCaseControllerEvent, fidl::Error> {
541        TestCaseControllerEvent::decode(self.client.wait_for_event(deadline)?)
542    }
543
544    /// Run a single default test case. Returns when the test case completes.
545    /// Returns an error if the test case exits abnormally.
546    pub fn r#run_default_cycle(
547        &self,
548        ___deadline: zx::MonotonicInstant,
549    ) -> Result<(), fidl::Error> {
550        let _response =
551            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
552                (),
553                0x6f41c0399849aea2,
554                fidl::encoding::DynamicFlags::empty(),
555                ___deadline,
556            )?;
557        Ok(_response)
558    }
559}
560
561#[cfg(target_os = "fuchsia")]
562impl From<TestCaseControllerSynchronousProxy> for zx::Handle {
563    fn from(value: TestCaseControllerSynchronousProxy) -> Self {
564        value.into_channel().into()
565    }
566}
567
568#[cfg(target_os = "fuchsia")]
569impl From<fidl::Channel> for TestCaseControllerSynchronousProxy {
570    fn from(value: fidl::Channel) -> Self {
571        Self::new(value)
572    }
573}
574
575#[derive(Debug, Clone)]
576pub struct TestCaseControllerProxy {
577    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
578}
579
580impl fidl::endpoints::Proxy for TestCaseControllerProxy {
581    type Protocol = TestCaseControllerMarker;
582
583    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
584        Self::new(inner)
585    }
586
587    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
588        self.client.into_channel().map_err(|client| Self { client })
589    }
590
591    fn as_channel(&self) -> &::fidl::AsyncChannel {
592        self.client.as_channel()
593    }
594}
595
596impl TestCaseControllerProxy {
597    /// Create a new Proxy for fuchsia.diagnostics.test/TestCaseController.
598    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
599        let protocol_name =
600            <TestCaseControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
601        Self { client: fidl::client::Client::new(channel, protocol_name) }
602    }
603
604    /// Get a Stream of events from the remote end of the protocol.
605    ///
606    /// # Panics
607    ///
608    /// Panics if the event stream was already taken.
609    pub fn take_event_stream(&self) -> TestCaseControllerEventStream {
610        TestCaseControllerEventStream { event_receiver: self.client.take_event_receiver() }
611    }
612
613    /// Run a single default test case. Returns when the test case completes.
614    /// Returns an error if the test case exits abnormally.
615    pub fn r#run_default_cycle(
616        &self,
617    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
618        TestCaseControllerProxyInterface::r#run_default_cycle(self)
619    }
620}
621
622impl TestCaseControllerProxyInterface for TestCaseControllerProxy {
623    type RunDefaultCycleResponseFut =
624        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
625    fn r#run_default_cycle(&self) -> Self::RunDefaultCycleResponseFut {
626        fn _decode(
627            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
628        ) -> Result<(), fidl::Error> {
629            let _response = fidl::client::decode_transaction_body::<
630                fidl::encoding::EmptyPayload,
631                fidl::encoding::DefaultFuchsiaResourceDialect,
632                0x6f41c0399849aea2,
633            >(_buf?)?;
634            Ok(_response)
635        }
636        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
637            (),
638            0x6f41c0399849aea2,
639            fidl::encoding::DynamicFlags::empty(),
640            _decode,
641        )
642    }
643}
644
645pub struct TestCaseControllerEventStream {
646    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
647}
648
649impl std::marker::Unpin for TestCaseControllerEventStream {}
650
651impl futures::stream::FusedStream for TestCaseControllerEventStream {
652    fn is_terminated(&self) -> bool {
653        self.event_receiver.is_terminated()
654    }
655}
656
657impl futures::Stream for TestCaseControllerEventStream {
658    type Item = Result<TestCaseControllerEvent, fidl::Error>;
659
660    fn poll_next(
661        mut self: std::pin::Pin<&mut Self>,
662        cx: &mut std::task::Context<'_>,
663    ) -> std::task::Poll<Option<Self::Item>> {
664        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
665            &mut self.event_receiver,
666            cx
667        )?) {
668            Some(buf) => std::task::Poll::Ready(Some(TestCaseControllerEvent::decode(buf))),
669            None => std::task::Poll::Ready(None),
670        }
671    }
672}
673
674#[derive(Debug)]
675pub enum TestCaseControllerEvent {}
676
677impl TestCaseControllerEvent {
678    /// Decodes a message buffer as a [`TestCaseControllerEvent`].
679    fn decode(
680        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
681    ) -> Result<TestCaseControllerEvent, fidl::Error> {
682        let (bytes, _handles) = buf.split_mut();
683        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
684        debug_assert_eq!(tx_header.tx_id, 0);
685        match tx_header.ordinal {
686            _ => Err(fidl::Error::UnknownOrdinal {
687                ordinal: tx_header.ordinal,
688                protocol_name:
689                    <TestCaseControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
690            }),
691        }
692    }
693}
694
695/// A Stream of incoming requests for fuchsia.diagnostics.test/TestCaseController.
696pub struct TestCaseControllerRequestStream {
697    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
698    is_terminated: bool,
699}
700
701impl std::marker::Unpin for TestCaseControllerRequestStream {}
702
703impl futures::stream::FusedStream for TestCaseControllerRequestStream {
704    fn is_terminated(&self) -> bool {
705        self.is_terminated
706    }
707}
708
709impl fidl::endpoints::RequestStream for TestCaseControllerRequestStream {
710    type Protocol = TestCaseControllerMarker;
711    type ControlHandle = TestCaseControllerControlHandle;
712
713    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
714        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
715    }
716
717    fn control_handle(&self) -> Self::ControlHandle {
718        TestCaseControllerControlHandle { inner: self.inner.clone() }
719    }
720
721    fn into_inner(
722        self,
723    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
724    {
725        (self.inner, self.is_terminated)
726    }
727
728    fn from_inner(
729        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
730        is_terminated: bool,
731    ) -> Self {
732        Self { inner, is_terminated }
733    }
734}
735
736impl futures::Stream for TestCaseControllerRequestStream {
737    type Item = Result<TestCaseControllerRequest, fidl::Error>;
738
739    fn poll_next(
740        mut self: std::pin::Pin<&mut Self>,
741        cx: &mut std::task::Context<'_>,
742    ) -> std::task::Poll<Option<Self::Item>> {
743        let this = &mut *self;
744        if this.inner.check_shutdown(cx) {
745            this.is_terminated = true;
746            return std::task::Poll::Ready(None);
747        }
748        if this.is_terminated {
749            panic!("polled TestCaseControllerRequestStream after completion");
750        }
751        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
752            |bytes, handles| {
753                match this.inner.channel().read_etc(cx, bytes, handles) {
754                    std::task::Poll::Ready(Ok(())) => {}
755                    std::task::Poll::Pending => return std::task::Poll::Pending,
756                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
757                        this.is_terminated = true;
758                        return std::task::Poll::Ready(None);
759                    }
760                    std::task::Poll::Ready(Err(e)) => {
761                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
762                            e.into(),
763                        ))))
764                    }
765                }
766
767                // A message has been received from the channel
768                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
769
770                std::task::Poll::Ready(Some(match header.ordinal {
771                0x6f41c0399849aea2 => {
772                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
773                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
774                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
775                    let control_handle = TestCaseControllerControlHandle {
776                        inner: this.inner.clone(),
777                    };
778                    Ok(TestCaseControllerRequest::RunDefaultCycle {
779                        responder: TestCaseControllerRunDefaultCycleResponder {
780                            control_handle: std::mem::ManuallyDrop::new(control_handle),
781                            tx_id: header.tx_id,
782                        },
783                    })
784                }
785                _ => Err(fidl::Error::UnknownOrdinal {
786                    ordinal: header.ordinal,
787                    protocol_name: <TestCaseControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
788                }),
789            }))
790            },
791        )
792    }
793}
794
795/// Tell Detect when to run test cases. Close the protocol to exit test mode.
796/// Running a test case (for example, with RunDefaultCycle() does not exit test
797/// mode when the test case completes.
798#[derive(Debug)]
799pub enum TestCaseControllerRequest {
800    /// Run a single default test case. Returns when the test case completes.
801    /// Returns an error if the test case exits abnormally.
802    RunDefaultCycle { responder: TestCaseControllerRunDefaultCycleResponder },
803}
804
805impl TestCaseControllerRequest {
806    #[allow(irrefutable_let_patterns)]
807    pub fn into_run_default_cycle(self) -> Option<(TestCaseControllerRunDefaultCycleResponder)> {
808        if let TestCaseControllerRequest::RunDefaultCycle { responder } = self {
809            Some((responder))
810        } else {
811            None
812        }
813    }
814
815    /// Name of the method defined in FIDL
816    pub fn method_name(&self) -> &'static str {
817        match *self {
818            TestCaseControllerRequest::RunDefaultCycle { .. } => "run_default_cycle",
819        }
820    }
821}
822
823#[derive(Debug, Clone)]
824pub struct TestCaseControllerControlHandle {
825    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
826}
827
828impl fidl::endpoints::ControlHandle for TestCaseControllerControlHandle {
829    fn shutdown(&self) {
830        self.inner.shutdown()
831    }
832    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
833        self.inner.shutdown_with_epitaph(status)
834    }
835
836    fn is_closed(&self) -> bool {
837        self.inner.channel().is_closed()
838    }
839    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
840        self.inner.channel().on_closed()
841    }
842
843    #[cfg(target_os = "fuchsia")]
844    fn signal_peer(
845        &self,
846        clear_mask: zx::Signals,
847        set_mask: zx::Signals,
848    ) -> Result<(), zx_status::Status> {
849        use fidl::Peered;
850        self.inner.channel().signal_peer(clear_mask, set_mask)
851    }
852}
853
854impl TestCaseControllerControlHandle {}
855
856#[must_use = "FIDL methods require a response to be sent"]
857#[derive(Debug)]
858pub struct TestCaseControllerRunDefaultCycleResponder {
859    control_handle: std::mem::ManuallyDrop<TestCaseControllerControlHandle>,
860    tx_id: u32,
861}
862
863/// Set the the channel to be shutdown (see [`TestCaseControllerControlHandle::shutdown`])
864/// if the responder is dropped without sending a response, so that the client
865/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
866impl std::ops::Drop for TestCaseControllerRunDefaultCycleResponder {
867    fn drop(&mut self) {
868        self.control_handle.shutdown();
869        // Safety: drops once, never accessed again
870        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
871    }
872}
873
874impl fidl::endpoints::Responder for TestCaseControllerRunDefaultCycleResponder {
875    type ControlHandle = TestCaseControllerControlHandle;
876
877    fn control_handle(&self) -> &TestCaseControllerControlHandle {
878        &self.control_handle
879    }
880
881    fn drop_without_shutdown(mut self) {
882        // Safety: drops once, never accessed again due to mem::forget
883        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
884        // Prevent Drop from running (which would shut down the channel)
885        std::mem::forget(self);
886    }
887}
888
889impl TestCaseControllerRunDefaultCycleResponder {
890    /// Sends a response to the FIDL transaction.
891    ///
892    /// Sets the channel to shutdown if an error occurs.
893    pub fn send(self) -> Result<(), fidl::Error> {
894        let _result = self.send_raw();
895        if _result.is_err() {
896            self.control_handle.shutdown();
897        }
898        self.drop_without_shutdown();
899        _result
900    }
901
902    /// Similar to "send" but does not shutdown the channel if an error occurs.
903    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
904        let _result = self.send_raw();
905        self.drop_without_shutdown();
906        _result
907    }
908
909    fn send_raw(&self) -> Result<(), fidl::Error> {
910        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
911            (),
912            self.tx_id,
913            0x6f41c0399849aea2,
914            fidl::encoding::DynamicFlags::empty(),
915        )
916    }
917}
918
919mod internal {
920    use super::*;
921
922    impl fidl::encoding::ResourceTypeMarker for DetectControllerEnterTestModeRequest {
923        type Borrowed<'a> = &'a mut Self;
924        fn take_or_borrow<'a>(
925            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
926        ) -> Self::Borrowed<'a> {
927            value
928        }
929    }
930
931    unsafe impl fidl::encoding::TypeMarker for DetectControllerEnterTestModeRequest {
932        type Owned = Self;
933
934        #[inline(always)]
935        fn inline_align(_context: fidl::encoding::Context) -> usize {
936            4
937        }
938
939        #[inline(always)]
940        fn inline_size(_context: fidl::encoding::Context) -> usize {
941            4
942        }
943    }
944
945    unsafe impl
946        fidl::encoding::Encode<
947            DetectControllerEnterTestModeRequest,
948            fidl::encoding::DefaultFuchsiaResourceDialect,
949        > for &mut DetectControllerEnterTestModeRequest
950    {
951        #[inline]
952        unsafe fn encode(
953            self,
954            encoder: &mut fidl::encoding::Encoder<
955                '_,
956                fidl::encoding::DefaultFuchsiaResourceDialect,
957            >,
958            offset: usize,
959            _depth: fidl::encoding::Depth,
960        ) -> fidl::Result<()> {
961            encoder.debug_check_bounds::<DetectControllerEnterTestModeRequest>(offset);
962            // Delegate to tuple encoding.
963            fidl::encoding::Encode::<DetectControllerEnterTestModeRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
964                (
965                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<TestCaseControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.test_controller),
966                ),
967                encoder, offset, _depth
968            )
969        }
970    }
971    unsafe impl<
972            T0: fidl::encoding::Encode<
973                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<TestCaseControllerMarker>>,
974                fidl::encoding::DefaultFuchsiaResourceDialect,
975            >,
976        >
977        fidl::encoding::Encode<
978            DetectControllerEnterTestModeRequest,
979            fidl::encoding::DefaultFuchsiaResourceDialect,
980        > for (T0,)
981    {
982        #[inline]
983        unsafe fn encode(
984            self,
985            encoder: &mut fidl::encoding::Encoder<
986                '_,
987                fidl::encoding::DefaultFuchsiaResourceDialect,
988            >,
989            offset: usize,
990            depth: fidl::encoding::Depth,
991        ) -> fidl::Result<()> {
992            encoder.debug_check_bounds::<DetectControllerEnterTestModeRequest>(offset);
993            // Zero out padding regions. There's no need to apply masks
994            // because the unmasked parts will be overwritten by fields.
995            // Write the fields.
996            self.0.encode(encoder, offset + 0, depth)?;
997            Ok(())
998        }
999    }
1000
1001    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1002        for DetectControllerEnterTestModeRequest
1003    {
1004        #[inline(always)]
1005        fn new_empty() -> Self {
1006            Self {
1007                test_controller: fidl::new_empty!(
1008                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<TestCaseControllerMarker>>,
1009                    fidl::encoding::DefaultFuchsiaResourceDialect
1010                ),
1011            }
1012        }
1013
1014        #[inline]
1015        unsafe fn decode(
1016            &mut self,
1017            decoder: &mut fidl::encoding::Decoder<
1018                '_,
1019                fidl::encoding::DefaultFuchsiaResourceDialect,
1020            >,
1021            offset: usize,
1022            _depth: fidl::encoding::Depth,
1023        ) -> fidl::Result<()> {
1024            decoder.debug_check_bounds::<Self>(offset);
1025            // Verify that padding bytes are zero.
1026            fidl::decode!(
1027                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<TestCaseControllerMarker>>,
1028                fidl::encoding::DefaultFuchsiaResourceDialect,
1029                &mut self.test_controller,
1030                decoder,
1031                offset + 0,
1032                _depth
1033            )?;
1034            Ok(())
1035        }
1036    }
1037}
fidl_fuchsia_diagnostics_test/fidl_fuchsia_diagnostics_test.rs

fidl_fuchsia_diagnostics_test/
fidl_fuchsia_diagnostics_test.rs
