fidl_fuchsia_component_client_test/
fidl_fuchsia_component_client_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_component_client_test_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct EmptyProtocolMarker;
16
17impl fidl::endpoints::ProtocolMarker for EmptyProtocolMarker {
18    type Proxy = EmptyProtocolProxy;
19    type RequestStream = EmptyProtocolRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = EmptyProtocolSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "fuchsia.component.client.test.EmptyProtocol";
24}
25impl fidl::endpoints::DiscoverableProtocolMarker for EmptyProtocolMarker {}
26
27pub trait EmptyProtocolProxyInterface: Send + Sync {}
28#[derive(Debug)]
29#[cfg(target_os = "fuchsia")]
30pub struct EmptyProtocolSynchronousProxy {
31    client: fidl::client::sync::Client,
32}
33
34#[cfg(target_os = "fuchsia")]
35impl fidl::endpoints::SynchronousProxy for EmptyProtocolSynchronousProxy {
36    type Proxy = EmptyProtocolProxy;
37    type Protocol = EmptyProtocolMarker;
38
39    fn from_channel(inner: fidl::Channel) -> Self {
40        Self::new(inner)
41    }
42
43    fn into_channel(self) -> fidl::Channel {
44        self.client.into_channel()
45    }
46
47    fn as_channel(&self) -> &fidl::Channel {
48        self.client.as_channel()
49    }
50}
51
52#[cfg(target_os = "fuchsia")]
53impl EmptyProtocolSynchronousProxy {
54    pub fn new(channel: fidl::Channel) -> Self {
55        let protocol_name = <EmptyProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
56        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
57    }
58
59    pub fn into_channel(self) -> fidl::Channel {
60        self.client.into_channel()
61    }
62
63    /// Waits until an event arrives and returns it. It is safe for other
64    /// threads to make concurrent requests while waiting for an event.
65    pub fn wait_for_event(
66        &self,
67        deadline: zx::MonotonicInstant,
68    ) -> Result<EmptyProtocolEvent, fidl::Error> {
69        EmptyProtocolEvent::decode(self.client.wait_for_event(deadline)?)
70    }
71}
72
73#[cfg(target_os = "fuchsia")]
74impl From<EmptyProtocolSynchronousProxy> for zx::Handle {
75    fn from(value: EmptyProtocolSynchronousProxy) -> Self {
76        value.into_channel().into()
77    }
78}
79
80#[cfg(target_os = "fuchsia")]
81impl From<fidl::Channel> for EmptyProtocolSynchronousProxy {
82    fn from(value: fidl::Channel) -> Self {
83        Self::new(value)
84    }
85}
86
87#[derive(Debug, Clone)]
88pub struct EmptyProtocolProxy {
89    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
90}
91
92impl fidl::endpoints::Proxy for EmptyProtocolProxy {
93    type Protocol = EmptyProtocolMarker;
94
95    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
96        Self::new(inner)
97    }
98
99    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
100        self.client.into_channel().map_err(|client| Self { client })
101    }
102
103    fn as_channel(&self) -> &::fidl::AsyncChannel {
104        self.client.as_channel()
105    }
106}
107
108impl EmptyProtocolProxy {
109    /// Create a new Proxy for fuchsia.component.client.test/EmptyProtocol.
110    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
111        let protocol_name = <EmptyProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
112        Self { client: fidl::client::Client::new(channel, protocol_name) }
113    }
114
115    /// Get a Stream of events from the remote end of the protocol.
116    ///
117    /// # Panics
118    ///
119    /// Panics if the event stream was already taken.
120    pub fn take_event_stream(&self) -> EmptyProtocolEventStream {
121        EmptyProtocolEventStream { event_receiver: self.client.take_event_receiver() }
122    }
123}
124
125impl EmptyProtocolProxyInterface for EmptyProtocolProxy {}
126
127pub struct EmptyProtocolEventStream {
128    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
129}
130
131impl std::marker::Unpin for EmptyProtocolEventStream {}
132
133impl futures::stream::FusedStream for EmptyProtocolEventStream {
134    fn is_terminated(&self) -> bool {
135        self.event_receiver.is_terminated()
136    }
137}
138
139impl futures::Stream for EmptyProtocolEventStream {
140    type Item = Result<EmptyProtocolEvent, fidl::Error>;
141
142    fn poll_next(
143        mut self: std::pin::Pin<&mut Self>,
144        cx: &mut std::task::Context<'_>,
145    ) -> std::task::Poll<Option<Self::Item>> {
146        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
147            &mut self.event_receiver,
148            cx
149        )?) {
150            Some(buf) => std::task::Poll::Ready(Some(EmptyProtocolEvent::decode(buf))),
151            None => std::task::Poll::Ready(None),
152        }
153    }
154}
155
156#[derive(Debug)]
157pub enum EmptyProtocolEvent {}
158
159impl EmptyProtocolEvent {
160    /// Decodes a message buffer as a [`EmptyProtocolEvent`].
161    fn decode(
162        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
163    ) -> Result<EmptyProtocolEvent, fidl::Error> {
164        let (bytes, _handles) = buf.split_mut();
165        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
166        debug_assert_eq!(tx_header.tx_id, 0);
167        match tx_header.ordinal {
168            _ => Err(fidl::Error::UnknownOrdinal {
169                ordinal: tx_header.ordinal,
170                protocol_name: <EmptyProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
171            }),
172        }
173    }
174}
175
176/// A Stream of incoming requests for fuchsia.component.client.test/EmptyProtocol.
177pub struct EmptyProtocolRequestStream {
178    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
179    is_terminated: bool,
180}
181
182impl std::marker::Unpin for EmptyProtocolRequestStream {}
183
184impl futures::stream::FusedStream for EmptyProtocolRequestStream {
185    fn is_terminated(&self) -> bool {
186        self.is_terminated
187    }
188}
189
190impl fidl::endpoints::RequestStream for EmptyProtocolRequestStream {
191    type Protocol = EmptyProtocolMarker;
192    type ControlHandle = EmptyProtocolControlHandle;
193
194    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
195        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
196    }
197
198    fn control_handle(&self) -> Self::ControlHandle {
199        EmptyProtocolControlHandle { inner: self.inner.clone() }
200    }
201
202    fn into_inner(
203        self,
204    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
205    {
206        (self.inner, self.is_terminated)
207    }
208
209    fn from_inner(
210        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
211        is_terminated: bool,
212    ) -> Self {
213        Self { inner, is_terminated }
214    }
215}
216
217impl futures::Stream for EmptyProtocolRequestStream {
218    type Item = Result<EmptyProtocolRequest, fidl::Error>;
219
220    fn poll_next(
221        mut self: std::pin::Pin<&mut Self>,
222        cx: &mut std::task::Context<'_>,
223    ) -> std::task::Poll<Option<Self::Item>> {
224        let this = &mut *self;
225        if this.inner.check_shutdown(cx) {
226            this.is_terminated = true;
227            return std::task::Poll::Ready(None);
228        }
229        if this.is_terminated {
230            panic!("polled EmptyProtocolRequestStream after completion");
231        }
232        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
233            |bytes, handles| {
234                match this.inner.channel().read_etc(cx, bytes, handles) {
235                    std::task::Poll::Ready(Ok(())) => {}
236                    std::task::Poll::Pending => return std::task::Poll::Pending,
237                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
238                        this.is_terminated = true;
239                        return std::task::Poll::Ready(None);
240                    }
241                    std::task::Poll::Ready(Err(e)) => {
242                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
243                            e.into(),
244                        ))))
245                    }
246                }
247
248                // A message has been received from the channel
249                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
250
251                std::task::Poll::Ready(Some(match header.ordinal {
252                    _ => Err(fidl::Error::UnknownOrdinal {
253                        ordinal: header.ordinal,
254                        protocol_name:
255                            <EmptyProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
256                    }),
257                }))
258            },
259        )
260    }
261}
262
263/// An empty protocol.
264#[derive(Debug)]
265pub enum EmptyProtocolRequest {}
266
267impl EmptyProtocolRequest {
268    /// Name of the method defined in FIDL
269    pub fn method_name(&self) -> &'static str {
270        match *self {}
271    }
272}
273
274#[derive(Debug, Clone)]
275pub struct EmptyProtocolControlHandle {
276    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
277}
278
279impl fidl::endpoints::ControlHandle for EmptyProtocolControlHandle {
280    fn shutdown(&self) {
281        self.inner.shutdown()
282    }
283    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
284        self.inner.shutdown_with_epitaph(status)
285    }
286
287    fn is_closed(&self) -> bool {
288        self.inner.channel().is_closed()
289    }
290    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
291        self.inner.channel().on_closed()
292    }
293
294    #[cfg(target_os = "fuchsia")]
295    fn signal_peer(
296        &self,
297        clear_mask: zx::Signals,
298        set_mask: zx::Signals,
299    ) -> Result<(), zx_status::Status> {
300        use fidl::Peered;
301        self.inner.channel().signal_peer(clear_mask, set_mask)
302    }
303}
304
305impl EmptyProtocolControlHandle {}
306
307#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
308pub struct ProtocolAMarker;
309
310impl fidl::endpoints::ProtocolMarker for ProtocolAMarker {
311    type Proxy = ProtocolAProxy;
312    type RequestStream = ProtocolARequestStream;
313    #[cfg(target_os = "fuchsia")]
314    type SynchronousProxy = ProtocolASynchronousProxy;
315
316    const DEBUG_NAME: &'static str = "fuchsia.component.client.test.ProtocolA";
317}
318impl fidl::endpoints::DiscoverableProtocolMarker for ProtocolAMarker {}
319
320pub trait ProtocolAProxyInterface: Send + Sync {
321    type FooResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
322    fn r#foo(&self) -> Self::FooResponseFut;
323}
324#[derive(Debug)]
325#[cfg(target_os = "fuchsia")]
326pub struct ProtocolASynchronousProxy {
327    client: fidl::client::sync::Client,
328}
329
330#[cfg(target_os = "fuchsia")]
331impl fidl::endpoints::SynchronousProxy for ProtocolASynchronousProxy {
332    type Proxy = ProtocolAProxy;
333    type Protocol = ProtocolAMarker;
334
335    fn from_channel(inner: fidl::Channel) -> Self {
336        Self::new(inner)
337    }
338
339    fn into_channel(self) -> fidl::Channel {
340        self.client.into_channel()
341    }
342
343    fn as_channel(&self) -> &fidl::Channel {
344        self.client.as_channel()
345    }
346}
347
348#[cfg(target_os = "fuchsia")]
349impl ProtocolASynchronousProxy {
350    pub fn new(channel: fidl::Channel) -> Self {
351        let protocol_name = <ProtocolAMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
352        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
353    }
354
355    pub fn into_channel(self) -> fidl::Channel {
356        self.client.into_channel()
357    }
358
359    /// Waits until an event arrives and returns it. It is safe for other
360    /// threads to make concurrent requests while waiting for an event.
361    pub fn wait_for_event(
362        &self,
363        deadline: zx::MonotonicInstant,
364    ) -> Result<ProtocolAEvent, fidl::Error> {
365        ProtocolAEvent::decode(self.client.wait_for_event(deadline)?)
366    }
367
368    /// Does nothing.
369    pub fn r#foo(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
370        let _response =
371            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
372                (),
373                0x5acb5937e9c47126,
374                fidl::encoding::DynamicFlags::empty(),
375                ___deadline,
376            )?;
377        Ok(_response)
378    }
379}
380
381#[cfg(target_os = "fuchsia")]
382impl From<ProtocolASynchronousProxy> for zx::Handle {
383    fn from(value: ProtocolASynchronousProxy) -> Self {
384        value.into_channel().into()
385    }
386}
387
388#[cfg(target_os = "fuchsia")]
389impl From<fidl::Channel> for ProtocolASynchronousProxy {
390    fn from(value: fidl::Channel) -> Self {
391        Self::new(value)
392    }
393}
394
395#[derive(Debug, Clone)]
396pub struct ProtocolAProxy {
397    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
398}
399
400impl fidl::endpoints::Proxy for ProtocolAProxy {
401    type Protocol = ProtocolAMarker;
402
403    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
404        Self::new(inner)
405    }
406
407    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
408        self.client.into_channel().map_err(|client| Self { client })
409    }
410
411    fn as_channel(&self) -> &::fidl::AsyncChannel {
412        self.client.as_channel()
413    }
414}
415
416impl ProtocolAProxy {
417    /// Create a new Proxy for fuchsia.component.client.test/ProtocolA.
418    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
419        let protocol_name = <ProtocolAMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
420        Self { client: fidl::client::Client::new(channel, protocol_name) }
421    }
422
423    /// Get a Stream of events from the remote end of the protocol.
424    ///
425    /// # Panics
426    ///
427    /// Panics if the event stream was already taken.
428    pub fn take_event_stream(&self) -> ProtocolAEventStream {
429        ProtocolAEventStream { event_receiver: self.client.take_event_receiver() }
430    }
431
432    /// Does nothing.
433    pub fn r#foo(
434        &self,
435    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
436        ProtocolAProxyInterface::r#foo(self)
437    }
438}
439
440impl ProtocolAProxyInterface for ProtocolAProxy {
441    type FooResponseFut =
442        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
443    fn r#foo(&self) -> Self::FooResponseFut {
444        fn _decode(
445            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
446        ) -> Result<(), fidl::Error> {
447            let _response = fidl::client::decode_transaction_body::<
448                fidl::encoding::EmptyPayload,
449                fidl::encoding::DefaultFuchsiaResourceDialect,
450                0x5acb5937e9c47126,
451            >(_buf?)?;
452            Ok(_response)
453        }
454        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
455            (),
456            0x5acb5937e9c47126,
457            fidl::encoding::DynamicFlags::empty(),
458            _decode,
459        )
460    }
461}
462
463pub struct ProtocolAEventStream {
464    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
465}
466
467impl std::marker::Unpin for ProtocolAEventStream {}
468
469impl futures::stream::FusedStream for ProtocolAEventStream {
470    fn is_terminated(&self) -> bool {
471        self.event_receiver.is_terminated()
472    }
473}
474
475impl futures::Stream for ProtocolAEventStream {
476    type Item = Result<ProtocolAEvent, fidl::Error>;
477
478    fn poll_next(
479        mut self: std::pin::Pin<&mut Self>,
480        cx: &mut std::task::Context<'_>,
481    ) -> std::task::Poll<Option<Self::Item>> {
482        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
483            &mut self.event_receiver,
484            cx
485        )?) {
486            Some(buf) => std::task::Poll::Ready(Some(ProtocolAEvent::decode(buf))),
487            None => std::task::Poll::Ready(None),
488        }
489    }
490}
491
492#[derive(Debug)]
493pub enum ProtocolAEvent {}
494
495impl ProtocolAEvent {
496    /// Decodes a message buffer as a [`ProtocolAEvent`].
497    fn decode(
498        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
499    ) -> Result<ProtocolAEvent, fidl::Error> {
500        let (bytes, _handles) = buf.split_mut();
501        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
502        debug_assert_eq!(tx_header.tx_id, 0);
503        match tx_header.ordinal {
504            _ => Err(fidl::Error::UnknownOrdinal {
505                ordinal: tx_header.ordinal,
506                protocol_name: <ProtocolAMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
507            }),
508        }
509    }
510}
511
512/// A Stream of incoming requests for fuchsia.component.client.test/ProtocolA.
513pub struct ProtocolARequestStream {
514    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
515    is_terminated: bool,
516}
517
518impl std::marker::Unpin for ProtocolARequestStream {}
519
520impl futures::stream::FusedStream for ProtocolARequestStream {
521    fn is_terminated(&self) -> bool {
522        self.is_terminated
523    }
524}
525
526impl fidl::endpoints::RequestStream for ProtocolARequestStream {
527    type Protocol = ProtocolAMarker;
528    type ControlHandle = ProtocolAControlHandle;
529
530    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
531        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
532    }
533
534    fn control_handle(&self) -> Self::ControlHandle {
535        ProtocolAControlHandle { inner: self.inner.clone() }
536    }
537
538    fn into_inner(
539        self,
540    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
541    {
542        (self.inner, self.is_terminated)
543    }
544
545    fn from_inner(
546        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
547        is_terminated: bool,
548    ) -> Self {
549        Self { inner, is_terminated }
550    }
551}
552
553impl futures::Stream for ProtocolARequestStream {
554    type Item = Result<ProtocolARequest, fidl::Error>;
555
556    fn poll_next(
557        mut self: std::pin::Pin<&mut Self>,
558        cx: &mut std::task::Context<'_>,
559    ) -> std::task::Poll<Option<Self::Item>> {
560        let this = &mut *self;
561        if this.inner.check_shutdown(cx) {
562            this.is_terminated = true;
563            return std::task::Poll::Ready(None);
564        }
565        if this.is_terminated {
566            panic!("polled ProtocolARequestStream after completion");
567        }
568        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
569            |bytes, handles| {
570                match this.inner.channel().read_etc(cx, bytes, handles) {
571                    std::task::Poll::Ready(Ok(())) => {}
572                    std::task::Poll::Pending => return std::task::Poll::Pending,
573                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
574                        this.is_terminated = true;
575                        return std::task::Poll::Ready(None);
576                    }
577                    std::task::Poll::Ready(Err(e)) => {
578                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
579                            e.into(),
580                        ))))
581                    }
582                }
583
584                // A message has been received from the channel
585                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
586
587                std::task::Poll::Ready(Some(match header.ordinal {
588                    0x5acb5937e9c47126 => {
589                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
590                        let mut req = fidl::new_empty!(
591                            fidl::encoding::EmptyPayload,
592                            fidl::encoding::DefaultFuchsiaResourceDialect
593                        );
594                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
595                        let control_handle = ProtocolAControlHandle { inner: this.inner.clone() };
596                        Ok(ProtocolARequest::Foo {
597                            responder: ProtocolAFooResponder {
598                                control_handle: std::mem::ManuallyDrop::new(control_handle),
599                                tx_id: header.tx_id,
600                            },
601                        })
602                    }
603                    _ => Err(fidl::Error::UnknownOrdinal {
604                        ordinal: header.ordinal,
605                        protocol_name:
606                            <ProtocolAMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
607                    }),
608                }))
609            },
610        )
611    }
612}
613
614/// A discoverable protocol.
615#[derive(Debug)]
616pub enum ProtocolARequest {
617    /// Does nothing.
618    Foo { responder: ProtocolAFooResponder },
619}
620
621impl ProtocolARequest {
622    #[allow(irrefutable_let_patterns)]
623    pub fn into_foo(self) -> Option<(ProtocolAFooResponder)> {
624        if let ProtocolARequest::Foo { responder } = self {
625            Some((responder))
626        } else {
627            None
628        }
629    }
630
631    /// Name of the method defined in FIDL
632    pub fn method_name(&self) -> &'static str {
633        match *self {
634            ProtocolARequest::Foo { .. } => "foo",
635        }
636    }
637}
638
639#[derive(Debug, Clone)]
640pub struct ProtocolAControlHandle {
641    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
642}
643
644impl fidl::endpoints::ControlHandle for ProtocolAControlHandle {
645    fn shutdown(&self) {
646        self.inner.shutdown()
647    }
648    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
649        self.inner.shutdown_with_epitaph(status)
650    }
651
652    fn is_closed(&self) -> bool {
653        self.inner.channel().is_closed()
654    }
655    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
656        self.inner.channel().on_closed()
657    }
658
659    #[cfg(target_os = "fuchsia")]
660    fn signal_peer(
661        &self,
662        clear_mask: zx::Signals,
663        set_mask: zx::Signals,
664    ) -> Result<(), zx_status::Status> {
665        use fidl::Peered;
666        self.inner.channel().signal_peer(clear_mask, set_mask)
667    }
668}
669
670impl ProtocolAControlHandle {}
671
672#[must_use = "FIDL methods require a response to be sent"]
673#[derive(Debug)]
674pub struct ProtocolAFooResponder {
675    control_handle: std::mem::ManuallyDrop<ProtocolAControlHandle>,
676    tx_id: u32,
677}
678
679/// Set the the channel to be shutdown (see [`ProtocolAControlHandle::shutdown`])
680/// if the responder is dropped without sending a response, so that the client
681/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
682impl std::ops::Drop for ProtocolAFooResponder {
683    fn drop(&mut self) {
684        self.control_handle.shutdown();
685        // Safety: drops once, never accessed again
686        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
687    }
688}
689
690impl fidl::endpoints::Responder for ProtocolAFooResponder {
691    type ControlHandle = ProtocolAControlHandle;
692
693    fn control_handle(&self) -> &ProtocolAControlHandle {
694        &self.control_handle
695    }
696
697    fn drop_without_shutdown(mut self) {
698        // Safety: drops once, never accessed again due to mem::forget
699        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
700        // Prevent Drop from running (which would shut down the channel)
701        std::mem::forget(self);
702    }
703}
704
705impl ProtocolAFooResponder {
706    /// Sends a response to the FIDL transaction.
707    ///
708    /// Sets the channel to shutdown if an error occurs.
709    pub fn send(self) -> Result<(), fidl::Error> {
710        let _result = self.send_raw();
711        if _result.is_err() {
712            self.control_handle.shutdown();
713        }
714        self.drop_without_shutdown();
715        _result
716    }
717
718    /// Similar to "send" but does not shutdown the channel if an error occurs.
719    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
720        let _result = self.send_raw();
721        self.drop_without_shutdown();
722        _result
723    }
724
725    fn send_raw(&self) -> Result<(), fidl::Error> {
726        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
727            (),
728            self.tx_id,
729            0x5acb5937e9c47126,
730            fidl::encoding::DynamicFlags::empty(),
731        )
732    }
733}
734
735#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
736pub struct ProtocolBMarker;
737
738impl fidl::endpoints::ProtocolMarker for ProtocolBMarker {
739    type Proxy = ProtocolBProxy;
740    type RequestStream = ProtocolBRequestStream;
741    #[cfg(target_os = "fuchsia")]
742    type SynchronousProxy = ProtocolBSynchronousProxy;
743
744    const DEBUG_NAME: &'static str = "fuchsia.component.client.test.ProtocolB";
745}
746impl fidl::endpoints::DiscoverableProtocolMarker for ProtocolBMarker {}
747
748pub trait ProtocolBProxyInterface: Send + Sync {
749    type FooResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
750    fn r#foo(&self) -> Self::FooResponseFut;
751}
752#[derive(Debug)]
753#[cfg(target_os = "fuchsia")]
754pub struct ProtocolBSynchronousProxy {
755    client: fidl::client::sync::Client,
756}
757
758#[cfg(target_os = "fuchsia")]
759impl fidl::endpoints::SynchronousProxy for ProtocolBSynchronousProxy {
760    type Proxy = ProtocolBProxy;
761    type Protocol = ProtocolBMarker;
762
763    fn from_channel(inner: fidl::Channel) -> Self {
764        Self::new(inner)
765    }
766
767    fn into_channel(self) -> fidl::Channel {
768        self.client.into_channel()
769    }
770
771    fn as_channel(&self) -> &fidl::Channel {
772        self.client.as_channel()
773    }
774}
775
776#[cfg(target_os = "fuchsia")]
777impl ProtocolBSynchronousProxy {
778    pub fn new(channel: fidl::Channel) -> Self {
779        let protocol_name = <ProtocolBMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
780        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
781    }
782
783    pub fn into_channel(self) -> fidl::Channel {
784        self.client.into_channel()
785    }
786
787    /// Waits until an event arrives and returns it. It is safe for other
788    /// threads to make concurrent requests while waiting for an event.
789    pub fn wait_for_event(
790        &self,
791        deadline: zx::MonotonicInstant,
792    ) -> Result<ProtocolBEvent, fidl::Error> {
793        ProtocolBEvent::decode(self.client.wait_for_event(deadline)?)
794    }
795
796    /// Does nothing.
797    pub fn r#foo(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
798        let _response =
799            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
800                (),
801                0x26550949f1431acf,
802                fidl::encoding::DynamicFlags::empty(),
803                ___deadline,
804            )?;
805        Ok(_response)
806    }
807}
808
809#[cfg(target_os = "fuchsia")]
810impl From<ProtocolBSynchronousProxy> for zx::Handle {
811    fn from(value: ProtocolBSynchronousProxy) -> Self {
812        value.into_channel().into()
813    }
814}
815
816#[cfg(target_os = "fuchsia")]
817impl From<fidl::Channel> for ProtocolBSynchronousProxy {
818    fn from(value: fidl::Channel) -> Self {
819        Self::new(value)
820    }
821}
822
823#[derive(Debug, Clone)]
824pub struct ProtocolBProxy {
825    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
826}
827
828impl fidl::endpoints::Proxy for ProtocolBProxy {
829    type Protocol = ProtocolBMarker;
830
831    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
832        Self::new(inner)
833    }
834
835    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
836        self.client.into_channel().map_err(|client| Self { client })
837    }
838
839    fn as_channel(&self) -> &::fidl::AsyncChannel {
840        self.client.as_channel()
841    }
842}
843
844impl ProtocolBProxy {
845    /// Create a new Proxy for fuchsia.component.client.test/ProtocolB.
846    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
847        let protocol_name = <ProtocolBMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
848        Self { client: fidl::client::Client::new(channel, protocol_name) }
849    }
850
851    /// Get a Stream of events from the remote end of the protocol.
852    ///
853    /// # Panics
854    ///
855    /// Panics if the event stream was already taken.
856    pub fn take_event_stream(&self) -> ProtocolBEventStream {
857        ProtocolBEventStream { event_receiver: self.client.take_event_receiver() }
858    }
859
860    /// Does nothing.
861    pub fn r#foo(
862        &self,
863    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
864        ProtocolBProxyInterface::r#foo(self)
865    }
866}
867
868impl ProtocolBProxyInterface for ProtocolBProxy {
869    type FooResponseFut =
870        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
871    fn r#foo(&self) -> Self::FooResponseFut {
872        fn _decode(
873            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
874        ) -> Result<(), fidl::Error> {
875            let _response = fidl::client::decode_transaction_body::<
876                fidl::encoding::EmptyPayload,
877                fidl::encoding::DefaultFuchsiaResourceDialect,
878                0x26550949f1431acf,
879            >(_buf?)?;
880            Ok(_response)
881        }
882        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
883            (),
884            0x26550949f1431acf,
885            fidl::encoding::DynamicFlags::empty(),
886            _decode,
887        )
888    }
889}
890
891pub struct ProtocolBEventStream {
892    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
893}
894
895impl std::marker::Unpin for ProtocolBEventStream {}
896
897impl futures::stream::FusedStream for ProtocolBEventStream {
898    fn is_terminated(&self) -> bool {
899        self.event_receiver.is_terminated()
900    }
901}
902
903impl futures::Stream for ProtocolBEventStream {
904    type Item = Result<ProtocolBEvent, fidl::Error>;
905
906    fn poll_next(
907        mut self: std::pin::Pin<&mut Self>,
908        cx: &mut std::task::Context<'_>,
909    ) -> std::task::Poll<Option<Self::Item>> {
910        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
911            &mut self.event_receiver,
912            cx
913        )?) {
914            Some(buf) => std::task::Poll::Ready(Some(ProtocolBEvent::decode(buf))),
915            None => std::task::Poll::Ready(None),
916        }
917    }
918}
919
920#[derive(Debug)]
921pub enum ProtocolBEvent {}
922
923impl ProtocolBEvent {
924    /// Decodes a message buffer as a [`ProtocolBEvent`].
925    fn decode(
926        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
927    ) -> Result<ProtocolBEvent, fidl::Error> {
928        let (bytes, _handles) = buf.split_mut();
929        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
930        debug_assert_eq!(tx_header.tx_id, 0);
931        match tx_header.ordinal {
932            _ => Err(fidl::Error::UnknownOrdinal {
933                ordinal: tx_header.ordinal,
934                protocol_name: <ProtocolBMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
935            }),
936        }
937    }
938}
939
940/// A Stream of incoming requests for fuchsia.component.client.test/ProtocolB.
941pub struct ProtocolBRequestStream {
942    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
943    is_terminated: bool,
944}
945
946impl std::marker::Unpin for ProtocolBRequestStream {}
947
948impl futures::stream::FusedStream for ProtocolBRequestStream {
949    fn is_terminated(&self) -> bool {
950        self.is_terminated
951    }
952}
953
954impl fidl::endpoints::RequestStream for ProtocolBRequestStream {
955    type Protocol = ProtocolBMarker;
956    type ControlHandle = ProtocolBControlHandle;
957
958    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
959        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
960    }
961
962    fn control_handle(&self) -> Self::ControlHandle {
963        ProtocolBControlHandle { inner: self.inner.clone() }
964    }
965
966    fn into_inner(
967        self,
968    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
969    {
970        (self.inner, self.is_terminated)
971    }
972
973    fn from_inner(
974        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
975        is_terminated: bool,
976    ) -> Self {
977        Self { inner, is_terminated }
978    }
979}
980
981impl futures::Stream for ProtocolBRequestStream {
982    type Item = Result<ProtocolBRequest, fidl::Error>;
983
984    fn poll_next(
985        mut self: std::pin::Pin<&mut Self>,
986        cx: &mut std::task::Context<'_>,
987    ) -> std::task::Poll<Option<Self::Item>> {
988        let this = &mut *self;
989        if this.inner.check_shutdown(cx) {
990            this.is_terminated = true;
991            return std::task::Poll::Ready(None);
992        }
993        if this.is_terminated {
994            panic!("polled ProtocolBRequestStream after completion");
995        }
996        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
997            |bytes, handles| {
998                match this.inner.channel().read_etc(cx, bytes, handles) {
999                    std::task::Poll::Ready(Ok(())) => {}
1000                    std::task::Poll::Pending => return std::task::Poll::Pending,
1001                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1002                        this.is_terminated = true;
1003                        return std::task::Poll::Ready(None);
1004                    }
1005                    std::task::Poll::Ready(Err(e)) => {
1006                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1007                            e.into(),
1008                        ))))
1009                    }
1010                }
1011
1012                // A message has been received from the channel
1013                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1014
1015                std::task::Poll::Ready(Some(match header.ordinal {
1016                    0x26550949f1431acf => {
1017                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1018                        let mut req = fidl::new_empty!(
1019                            fidl::encoding::EmptyPayload,
1020                            fidl::encoding::DefaultFuchsiaResourceDialect
1021                        );
1022                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1023                        let control_handle = ProtocolBControlHandle { inner: this.inner.clone() };
1024                        Ok(ProtocolBRequest::Foo {
1025                            responder: ProtocolBFooResponder {
1026                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1027                                tx_id: header.tx_id,
1028                            },
1029                        })
1030                    }
1031                    _ => Err(fidl::Error::UnknownOrdinal {
1032                        ordinal: header.ordinal,
1033                        protocol_name:
1034                            <ProtocolBMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1035                    }),
1036                }))
1037            },
1038        )
1039    }
1040}
1041
1042/// Yet another discoverable protocol.
1043#[derive(Debug)]
1044pub enum ProtocolBRequest {
1045    /// Does nothing.
1046    Foo { responder: ProtocolBFooResponder },
1047}
1048
1049impl ProtocolBRequest {
1050    #[allow(irrefutable_let_patterns)]
1051    pub fn into_foo(self) -> Option<(ProtocolBFooResponder)> {
1052        if let ProtocolBRequest::Foo { responder } = self {
1053            Some((responder))
1054        } else {
1055            None
1056        }
1057    }
1058
1059    /// Name of the method defined in FIDL
1060    pub fn method_name(&self) -> &'static str {
1061        match *self {
1062            ProtocolBRequest::Foo { .. } => "foo",
1063        }
1064    }
1065}
1066
1067#[derive(Debug, Clone)]
1068pub struct ProtocolBControlHandle {
1069    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1070}
1071
1072impl fidl::endpoints::ControlHandle for ProtocolBControlHandle {
1073    fn shutdown(&self) {
1074        self.inner.shutdown()
1075    }
1076    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1077        self.inner.shutdown_with_epitaph(status)
1078    }
1079
1080    fn is_closed(&self) -> bool {
1081        self.inner.channel().is_closed()
1082    }
1083    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1084        self.inner.channel().on_closed()
1085    }
1086
1087    #[cfg(target_os = "fuchsia")]
1088    fn signal_peer(
1089        &self,
1090        clear_mask: zx::Signals,
1091        set_mask: zx::Signals,
1092    ) -> Result<(), zx_status::Status> {
1093        use fidl::Peered;
1094        self.inner.channel().signal_peer(clear_mask, set_mask)
1095    }
1096}
1097
1098impl ProtocolBControlHandle {}
1099
1100#[must_use = "FIDL methods require a response to be sent"]
1101#[derive(Debug)]
1102pub struct ProtocolBFooResponder {
1103    control_handle: std::mem::ManuallyDrop<ProtocolBControlHandle>,
1104    tx_id: u32,
1105}
1106
1107/// Set the the channel to be shutdown (see [`ProtocolBControlHandle::shutdown`])
1108/// if the responder is dropped without sending a response, so that the client
1109/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1110impl std::ops::Drop for ProtocolBFooResponder {
1111    fn drop(&mut self) {
1112        self.control_handle.shutdown();
1113        // Safety: drops once, never accessed again
1114        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1115    }
1116}
1117
1118impl fidl::endpoints::Responder for ProtocolBFooResponder {
1119    type ControlHandle = ProtocolBControlHandle;
1120
1121    fn control_handle(&self) -> &ProtocolBControlHandle {
1122        &self.control_handle
1123    }
1124
1125    fn drop_without_shutdown(mut self) {
1126        // Safety: drops once, never accessed again due to mem::forget
1127        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1128        // Prevent Drop from running (which would shut down the channel)
1129        std::mem::forget(self);
1130    }
1131}
1132
1133impl ProtocolBFooResponder {
1134    /// Sends a response to the FIDL transaction.
1135    ///
1136    /// Sets the channel to shutdown if an error occurs.
1137    pub fn send(self) -> Result<(), fidl::Error> {
1138        let _result = self.send_raw();
1139        if _result.is_err() {
1140            self.control_handle.shutdown();
1141        }
1142        self.drop_without_shutdown();
1143        _result
1144    }
1145
1146    /// Similar to "send" but does not shutdown the channel if an error occurs.
1147    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
1148        let _result = self.send_raw();
1149        self.drop_without_shutdown();
1150        _result
1151    }
1152
1153    fn send_raw(&self) -> Result<(), fidl::Error> {
1154        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
1155            (),
1156            self.tx_id,
1157            0x26550949f1431acf,
1158            fidl::encoding::DynamicFlags::empty(),
1159        )
1160    }
1161}
1162
1163#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1164pub struct ServiceMarker;
1165
1166#[cfg(target_os = "fuchsia")]
1167impl fidl::endpoints::ServiceMarker for ServiceMarker {
1168    type Proxy = ServiceProxy;
1169    type Request = ServiceRequest;
1170    const SERVICE_NAME: &'static str = "fuchsia.component.client.test.Service";
1171}
1172
1173/// A request for one of the member protocols of Service.
1174///
1175/// A service with protocols in it
1176#[cfg(target_os = "fuchsia")]
1177pub enum ServiceRequest {
1178    First(ProtocolARequestStream),
1179    Second(ProtocolBRequestStream),
1180}
1181
1182#[cfg(target_os = "fuchsia")]
1183impl fidl::endpoints::ServiceRequest for ServiceRequest {
1184    type Service = ServiceMarker;
1185
1186    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
1187        match name {
1188            "first" => Self::First(
1189                <ProtocolARequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
1190            ),
1191            "second" => Self::Second(
1192                <ProtocolBRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
1193            ),
1194            _ => panic!("no such member protocol name for service Service"),
1195        }
1196    }
1197
1198    fn member_names() -> &'static [&'static str] {
1199        &["first", "second"]
1200    }
1201}
1202/// A service with protocols in it
1203#[cfg(target_os = "fuchsia")]
1204pub struct ServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);
1205
1206#[cfg(target_os = "fuchsia")]
1207impl fidl::endpoints::ServiceProxy for ServiceProxy {
1208    type Service = ServiceMarker;
1209
1210    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
1211        Self(opener)
1212    }
1213}
1214
1215#[cfg(target_os = "fuchsia")]
1216impl ServiceProxy {
1217    pub fn connect_to_first(&self) -> Result<ProtocolAProxy, fidl::Error> {
1218        let (proxy, server_end) = fidl::endpoints::create_proxy::<ProtocolAMarker>();
1219        self.connect_channel_to_first(server_end)?;
1220        Ok(proxy)
1221    }
1222
1223    /// Like `connect_to_first`, but returns a sync proxy.
1224    /// See [`Self::connect_to_first`] for more details.
1225    pub fn connect_to_first_sync(&self) -> Result<ProtocolASynchronousProxy, fidl::Error> {
1226        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<ProtocolAMarker>();
1227        self.connect_channel_to_first(server_end)?;
1228        Ok(proxy)
1229    }
1230
1231    /// Like `connect_to_first`, but accepts a server end.
1232    /// See [`Self::connect_to_first`] for more details.
1233    pub fn connect_channel_to_first(
1234        &self,
1235        server_end: fidl::endpoints::ServerEnd<ProtocolAMarker>,
1236    ) -> Result<(), fidl::Error> {
1237        self.0.open_member("first", server_end.into_channel())
1238    }
1239    pub fn connect_to_second(&self) -> Result<ProtocolBProxy, fidl::Error> {
1240        let (proxy, server_end) = fidl::endpoints::create_proxy::<ProtocolBMarker>();
1241        self.connect_channel_to_second(server_end)?;
1242        Ok(proxy)
1243    }
1244
1245    /// Like `connect_to_second`, but returns a sync proxy.
1246    /// See [`Self::connect_to_second`] for more details.
1247    pub fn connect_to_second_sync(&self) -> Result<ProtocolBSynchronousProxy, fidl::Error> {
1248        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<ProtocolBMarker>();
1249        self.connect_channel_to_second(server_end)?;
1250        Ok(proxy)
1251    }
1252
1253    /// Like `connect_to_second`, but accepts a server end.
1254    /// See [`Self::connect_to_second`] for more details.
1255    pub fn connect_channel_to_second(
1256        &self,
1257        server_end: fidl::endpoints::ServerEnd<ProtocolBMarker>,
1258    ) -> Result<(), fidl::Error> {
1259        self.0.open_member("second", server_end.into_channel())
1260    }
1261
1262    pub fn instance_name(&self) -> &str {
1263        self.0.instance_name()
1264    }
1265}
1266
1267mod internal {
1268    use super::*;
1269}
fidl_fuchsia_component_client_test/fidl_fuchsia_component_client_test.rs

fidl_fuchsia_component_client_test/
fidl_fuchsia_component_client_test.rs
