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

fidl_fuchsia_test_runner/
fidl_fuchsia_test_runner.rs
