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::Handle {
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    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
385        self.inner.shutdown_with_epitaph(status)
386    }
387
388    fn is_closed(&self) -> bool {
389        self.inner.channel().is_closed()
390    }
391    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
392        self.inner.channel().on_closed()
393    }
394
395    #[cfg(target_os = "fuchsia")]
396    fn signal_peer(
397        &self,
398        clear_mask: zx::Signals,
399        set_mask: zx::Signals,
400    ) -> Result<(), zx_status::Status> {
401        use fidl::Peered;
402        self.inner.channel().signal_peer(clear_mask, set_mask)
403    }
404}
405
406impl LibraryLoaderCacheControlHandle {}
407
408#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
409pub struct LibraryLoaderCacheBuilderMarker;
410
411impl fidl::endpoints::ProtocolMarker for LibraryLoaderCacheBuilderMarker {
412    type Proxy = LibraryLoaderCacheBuilderProxy;
413    type RequestStream = LibraryLoaderCacheBuilderRequestStream;
414    #[cfg(target_os = "fuchsia")]
415    type SynchronousProxy = LibraryLoaderCacheBuilderSynchronousProxy;
416
417    const DEBUG_NAME: &'static str = "fuchsia.test.runner.LibraryLoaderCacheBuilder";
418}
419impl fidl::endpoints::DiscoverableProtocolMarker for LibraryLoaderCacheBuilderMarker {}
420
421pub trait LibraryLoaderCacheBuilderProxyInterface: Send + Sync {
422    fn r#create(
423        &self,
424        lib_directory: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
425        cache: fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>,
426    ) -> Result<(), fidl::Error>;
427}
428#[derive(Debug)]
429#[cfg(target_os = "fuchsia")]
430pub struct LibraryLoaderCacheBuilderSynchronousProxy {
431    client: fidl::client::sync::Client,
432}
433
434#[cfg(target_os = "fuchsia")]
435impl fidl::endpoints::SynchronousProxy for LibraryLoaderCacheBuilderSynchronousProxy {
436    type Proxy = LibraryLoaderCacheBuilderProxy;
437    type Protocol = LibraryLoaderCacheBuilderMarker;
438
439    fn from_channel(inner: fidl::Channel) -> Self {
440        Self::new(inner)
441    }
442
443    fn into_channel(self) -> fidl::Channel {
444        self.client.into_channel()
445    }
446
447    fn as_channel(&self) -> &fidl::Channel {
448        self.client.as_channel()
449    }
450}
451
452#[cfg(target_os = "fuchsia")]
453impl LibraryLoaderCacheBuilderSynchronousProxy {
454    pub fn new(channel: fidl::Channel) -> Self {
455        let protocol_name =
456            <LibraryLoaderCacheBuilderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
457        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
458    }
459
460    pub fn into_channel(self) -> fidl::Channel {
461        self.client.into_channel()
462    }
463
464    /// Waits until an event arrives and returns it. It is safe for other
465    /// threads to make concurrent requests while waiting for an event.
466    pub fn wait_for_event(
467        &self,
468        deadline: zx::MonotonicInstant,
469    ) -> Result<LibraryLoaderCacheBuilderEvent, fidl::Error> {
470        LibraryLoaderCacheBuilderEvent::decode(self.client.wait_for_event(deadline)?)
471    }
472
473    /// Create a new LibraryLoaderCache backed by `lib_directory`.
474    /// `lib_directory`: Handle to /pkg/lib of the component which needs
475    ///                  to be launched.
476    /// `cache`: The handle which will serve |LibraryLoaderCache|.
477    pub fn r#create(
478        &self,
479        mut lib_directory: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
480        mut cache: fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>,
481    ) -> Result<(), fidl::Error> {
482        self.client.send::<LibraryLoaderCacheBuilderCreateRequest>(
483            (lib_directory, cache),
484            0x5f1be6b603264b0c,
485            fidl::encoding::DynamicFlags::empty(),
486        )
487    }
488}
489
490#[cfg(target_os = "fuchsia")]
491impl From<LibraryLoaderCacheBuilderSynchronousProxy> for zx::Handle {
492    fn from(value: LibraryLoaderCacheBuilderSynchronousProxy) -> Self {
493        value.into_channel().into()
494    }
495}
496
497#[cfg(target_os = "fuchsia")]
498impl From<fidl::Channel> for LibraryLoaderCacheBuilderSynchronousProxy {
499    fn from(value: fidl::Channel) -> Self {
500        Self::new(value)
501    }
502}
503
504#[cfg(target_os = "fuchsia")]
505impl fidl::endpoints::FromClient for LibraryLoaderCacheBuilderSynchronousProxy {
506    type Protocol = LibraryLoaderCacheBuilderMarker;
507
508    fn from_client(value: fidl::endpoints::ClientEnd<LibraryLoaderCacheBuilderMarker>) -> Self {
509        Self::new(value.into_channel())
510    }
511}
512
513#[derive(Debug, Clone)]
514pub struct LibraryLoaderCacheBuilderProxy {
515    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
516}
517
518impl fidl::endpoints::Proxy for LibraryLoaderCacheBuilderProxy {
519    type Protocol = LibraryLoaderCacheBuilderMarker;
520
521    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
522        Self::new(inner)
523    }
524
525    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
526        self.client.into_channel().map_err(|client| Self { client })
527    }
528
529    fn as_channel(&self) -> &::fidl::AsyncChannel {
530        self.client.as_channel()
531    }
532}
533
534impl LibraryLoaderCacheBuilderProxy {
535    /// Create a new Proxy for fuchsia.test.runner/LibraryLoaderCacheBuilder.
536    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
537        let protocol_name =
538            <LibraryLoaderCacheBuilderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
539        Self { client: fidl::client::Client::new(channel, protocol_name) }
540    }
541
542    /// Get a Stream of events from the remote end of the protocol.
543    ///
544    /// # Panics
545    ///
546    /// Panics if the event stream was already taken.
547    pub fn take_event_stream(&self) -> LibraryLoaderCacheBuilderEventStream {
548        LibraryLoaderCacheBuilderEventStream { event_receiver: self.client.take_event_receiver() }
549    }
550
551    /// Create a new LibraryLoaderCache backed by `lib_directory`.
552    /// `lib_directory`: Handle to /pkg/lib of the component which needs
553    ///                  to be launched.
554    /// `cache`: The handle which will serve |LibraryLoaderCache|.
555    pub fn r#create(
556        &self,
557        mut lib_directory: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
558        mut cache: fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>,
559    ) -> Result<(), fidl::Error> {
560        LibraryLoaderCacheBuilderProxyInterface::r#create(self, lib_directory, cache)
561    }
562}
563
564impl LibraryLoaderCacheBuilderProxyInterface for LibraryLoaderCacheBuilderProxy {
565    fn r#create(
566        &self,
567        mut lib_directory: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
568        mut cache: fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>,
569    ) -> Result<(), fidl::Error> {
570        self.client.send::<LibraryLoaderCacheBuilderCreateRequest>(
571            (lib_directory, cache),
572            0x5f1be6b603264b0c,
573            fidl::encoding::DynamicFlags::empty(),
574        )
575    }
576}
577
578pub struct LibraryLoaderCacheBuilderEventStream {
579    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
580}
581
582impl std::marker::Unpin for LibraryLoaderCacheBuilderEventStream {}
583
584impl futures::stream::FusedStream for LibraryLoaderCacheBuilderEventStream {
585    fn is_terminated(&self) -> bool {
586        self.event_receiver.is_terminated()
587    }
588}
589
590impl futures::Stream for LibraryLoaderCacheBuilderEventStream {
591    type Item = Result<LibraryLoaderCacheBuilderEvent, fidl::Error>;
592
593    fn poll_next(
594        mut self: std::pin::Pin<&mut Self>,
595        cx: &mut std::task::Context<'_>,
596    ) -> std::task::Poll<Option<Self::Item>> {
597        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
598            &mut self.event_receiver,
599            cx
600        )?) {
601            Some(buf) => std::task::Poll::Ready(Some(LibraryLoaderCacheBuilderEvent::decode(buf))),
602            None => std::task::Poll::Ready(None),
603        }
604    }
605}
606
607#[derive(Debug)]
608pub enum LibraryLoaderCacheBuilderEvent {}
609
610impl LibraryLoaderCacheBuilderEvent {
611    /// Decodes a message buffer as a [`LibraryLoaderCacheBuilderEvent`].
612    fn decode(
613        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
614    ) -> Result<LibraryLoaderCacheBuilderEvent, fidl::Error> {
615        let (bytes, _handles) = buf.split_mut();
616        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
617        debug_assert_eq!(tx_header.tx_id, 0);
618        match tx_header.ordinal {
619            _ => Err(fidl::Error::UnknownOrdinal {
620                ordinal: tx_header.ordinal,
621                protocol_name:
622                    <LibraryLoaderCacheBuilderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
623            }),
624        }
625    }
626}
627
628/// A Stream of incoming requests for fuchsia.test.runner/LibraryLoaderCacheBuilder.
629pub struct LibraryLoaderCacheBuilderRequestStream {
630    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
631    is_terminated: bool,
632}
633
634impl std::marker::Unpin for LibraryLoaderCacheBuilderRequestStream {}
635
636impl futures::stream::FusedStream for LibraryLoaderCacheBuilderRequestStream {
637    fn is_terminated(&self) -> bool {
638        self.is_terminated
639    }
640}
641
642impl fidl::endpoints::RequestStream for LibraryLoaderCacheBuilderRequestStream {
643    type Protocol = LibraryLoaderCacheBuilderMarker;
644    type ControlHandle = LibraryLoaderCacheBuilderControlHandle;
645
646    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
647        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
648    }
649
650    fn control_handle(&self) -> Self::ControlHandle {
651        LibraryLoaderCacheBuilderControlHandle { inner: self.inner.clone() }
652    }
653
654    fn into_inner(
655        self,
656    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
657    {
658        (self.inner, self.is_terminated)
659    }
660
661    fn from_inner(
662        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
663        is_terminated: bool,
664    ) -> Self {
665        Self { inner, is_terminated }
666    }
667}
668
669impl futures::Stream for LibraryLoaderCacheBuilderRequestStream {
670    type Item = Result<LibraryLoaderCacheBuilderRequest, fidl::Error>;
671
672    fn poll_next(
673        mut self: std::pin::Pin<&mut Self>,
674        cx: &mut std::task::Context<'_>,
675    ) -> std::task::Poll<Option<Self::Item>> {
676        let this = &mut *self;
677        if this.inner.check_shutdown(cx) {
678            this.is_terminated = true;
679            return std::task::Poll::Ready(None);
680        }
681        if this.is_terminated {
682            panic!("polled LibraryLoaderCacheBuilderRequestStream after completion");
683        }
684        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
685            |bytes, handles| {
686                match this.inner.channel().read_etc(cx, bytes, handles) {
687                    std::task::Poll::Ready(Ok(())) => {}
688                    std::task::Poll::Pending => return std::task::Poll::Pending,
689                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
690                        this.is_terminated = true;
691                        return std::task::Poll::Ready(None);
692                    }
693                    std::task::Poll::Ready(Err(e)) => {
694                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
695                            e.into(),
696                        ))))
697                    }
698                }
699
700                // A message has been received from the channel
701                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
702
703                std::task::Poll::Ready(Some(match header.ordinal {
704                0x5f1be6b603264b0c => {
705                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
706                    let mut req = fidl::new_empty!(LibraryLoaderCacheBuilderCreateRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
707                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LibraryLoaderCacheBuilderCreateRequest>(&header, _body_bytes, handles, &mut req)?;
708                    let control_handle = LibraryLoaderCacheBuilderControlHandle {
709                        inner: this.inner.clone(),
710                    };
711                    Ok(LibraryLoaderCacheBuilderRequest::Create {lib_directory: req.lib_directory,
712cache: req.cache,
713
714                        control_handle,
715                    })
716                }
717                _ => Err(fidl::Error::UnknownOrdinal {
718                    ordinal: header.ordinal,
719                    protocol_name: <LibraryLoaderCacheBuilderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
720                }),
721            }))
722            },
723        )
724    }
725}
726
727/// Provides an API to create LibraryLoaderCache. This is used by test runners
728/// to make test execution faster when launching same process in a package
729/// multiple times.
730#[derive(Debug)]
731pub enum LibraryLoaderCacheBuilderRequest {
732    /// Create a new LibraryLoaderCache backed by `lib_directory`.
733    /// `lib_directory`: Handle to /pkg/lib of the component which needs
734    ///                  to be launched.
735    /// `cache`: The handle which will serve |LibraryLoaderCache|.
736    Create {
737        lib_directory: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
738        cache: fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>,
739        control_handle: LibraryLoaderCacheBuilderControlHandle,
740    },
741}
742
743impl LibraryLoaderCacheBuilderRequest {
744    #[allow(irrefutable_let_patterns)]
745    pub fn into_create(
746        self,
747    ) -> Option<(
748        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
749        fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>,
750        LibraryLoaderCacheBuilderControlHandle,
751    )> {
752        if let LibraryLoaderCacheBuilderRequest::Create { lib_directory, cache, control_handle } =
753            self
754        {
755            Some((lib_directory, cache, control_handle))
756        } else {
757            None
758        }
759    }
760
761    /// Name of the method defined in FIDL
762    pub fn method_name(&self) -> &'static str {
763        match *self {
764            LibraryLoaderCacheBuilderRequest::Create { .. } => "create",
765        }
766    }
767}
768
769#[derive(Debug, Clone)]
770pub struct LibraryLoaderCacheBuilderControlHandle {
771    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
772}
773
774impl fidl::endpoints::ControlHandle for LibraryLoaderCacheBuilderControlHandle {
775    fn shutdown(&self) {
776        self.inner.shutdown()
777    }
778    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
779        self.inner.shutdown_with_epitaph(status)
780    }
781
782    fn is_closed(&self) -> bool {
783        self.inner.channel().is_closed()
784    }
785    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
786        self.inner.channel().on_closed()
787    }
788
789    #[cfg(target_os = "fuchsia")]
790    fn signal_peer(
791        &self,
792        clear_mask: zx::Signals,
793        set_mask: zx::Signals,
794    ) -> Result<(), zx_status::Status> {
795        use fidl::Peered;
796        self.inner.channel().signal_peer(clear_mask, set_mask)
797    }
798}
799
800impl LibraryLoaderCacheBuilderControlHandle {}
801
802mod internal {
803    use super::*;
804
805    impl fidl::encoding::ResourceTypeMarker for LibraryLoaderCacheBuilderCreateRequest {
806        type Borrowed<'a> = &'a mut Self;
807        fn take_or_borrow<'a>(
808            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
809        ) -> Self::Borrowed<'a> {
810            value
811        }
812    }
813
814    unsafe impl fidl::encoding::TypeMarker for LibraryLoaderCacheBuilderCreateRequest {
815        type Owned = Self;
816
817        #[inline(always)]
818        fn inline_align(_context: fidl::encoding::Context) -> usize {
819            4
820        }
821
822        #[inline(always)]
823        fn inline_size(_context: fidl::encoding::Context) -> usize {
824            8
825        }
826    }
827
828    unsafe impl
829        fidl::encoding::Encode<
830            LibraryLoaderCacheBuilderCreateRequest,
831            fidl::encoding::DefaultFuchsiaResourceDialect,
832        > for &mut LibraryLoaderCacheBuilderCreateRequest
833    {
834        #[inline]
835        unsafe fn encode(
836            self,
837            encoder: &mut fidl::encoding::Encoder<
838                '_,
839                fidl::encoding::DefaultFuchsiaResourceDialect,
840            >,
841            offset: usize,
842            _depth: fidl::encoding::Depth,
843        ) -> fidl::Result<()> {
844            encoder.debug_check_bounds::<LibraryLoaderCacheBuilderCreateRequest>(offset);
845            // Delegate to tuple encoding.
846            fidl::encoding::Encode::<LibraryLoaderCacheBuilderCreateRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
847                (
848                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.lib_directory),
849                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.cache),
850                ),
851                encoder, offset, _depth
852            )
853        }
854    }
855    unsafe impl<
856            T0: fidl::encoding::Encode<
857                fidl::encoding::Endpoint<
858                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
859                >,
860                fidl::encoding::DefaultFuchsiaResourceDialect,
861            >,
862            T1: fidl::encoding::Encode<
863                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>>,
864                fidl::encoding::DefaultFuchsiaResourceDialect,
865            >,
866        >
867        fidl::encoding::Encode<
868            LibraryLoaderCacheBuilderCreateRequest,
869            fidl::encoding::DefaultFuchsiaResourceDialect,
870        > for (T0, T1)
871    {
872        #[inline]
873        unsafe fn encode(
874            self,
875            encoder: &mut fidl::encoding::Encoder<
876                '_,
877                fidl::encoding::DefaultFuchsiaResourceDialect,
878            >,
879            offset: usize,
880            depth: fidl::encoding::Depth,
881        ) -> fidl::Result<()> {
882            encoder.debug_check_bounds::<LibraryLoaderCacheBuilderCreateRequest>(offset);
883            // Zero out padding regions. There's no need to apply masks
884            // because the unmasked parts will be overwritten by fields.
885            // Write the fields.
886            self.0.encode(encoder, offset + 0, depth)?;
887            self.1.encode(encoder, offset + 4, depth)?;
888            Ok(())
889        }
890    }
891
892    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
893        for LibraryLoaderCacheBuilderCreateRequest
894    {
895        #[inline(always)]
896        fn new_empty() -> Self {
897            Self {
898                lib_directory: fidl::new_empty!(
899                    fidl::encoding::Endpoint<
900                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
901                    >,
902                    fidl::encoding::DefaultFuchsiaResourceDialect
903                ),
904                cache: fidl::new_empty!(
905                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>>,
906                    fidl::encoding::DefaultFuchsiaResourceDialect
907                ),
908            }
909        }
910
911        #[inline]
912        unsafe fn decode(
913            &mut self,
914            decoder: &mut fidl::encoding::Decoder<
915                '_,
916                fidl::encoding::DefaultFuchsiaResourceDialect,
917            >,
918            offset: usize,
919            _depth: fidl::encoding::Depth,
920        ) -> fidl::Result<()> {
921            decoder.debug_check_bounds::<Self>(offset);
922            // Verify that padding bytes are zero.
923            fidl::decode!(
924                fidl::encoding::Endpoint<
925                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
926                >,
927                fidl::encoding::DefaultFuchsiaResourceDialect,
928                &mut self.lib_directory,
929                decoder,
930                offset + 0,
931                _depth
932            )?;
933            fidl::decode!(
934                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<LibraryLoaderCacheMarker>>,
935                fidl::encoding::DefaultFuchsiaResourceDialect,
936                &mut self.cache,
937                decoder,
938                offset + 4,
939                _depth
940            )?;
941            Ok(())
942        }
943    }
944
945    impl fidl::encoding::ResourceTypeMarker for LibraryLoaderCacheServeRequest {
946        type Borrowed<'a> = &'a mut Self;
947        fn take_or_borrow<'a>(
948            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
949        ) -> Self::Borrowed<'a> {
950            value
951        }
952    }
953
954    unsafe impl fidl::encoding::TypeMarker for LibraryLoaderCacheServeRequest {
955        type Owned = Self;
956
957        #[inline(always)]
958        fn inline_align(_context: fidl::encoding::Context) -> usize {
959            4
960        }
961
962        #[inline(always)]
963        fn inline_size(_context: fidl::encoding::Context) -> usize {
964            4
965        }
966    }
967
968    unsafe impl
969        fidl::encoding::Encode<
970            LibraryLoaderCacheServeRequest,
971            fidl::encoding::DefaultFuchsiaResourceDialect,
972        > for &mut LibraryLoaderCacheServeRequest
973    {
974        #[inline]
975        unsafe fn encode(
976            self,
977            encoder: &mut fidl::encoding::Encoder<
978                '_,
979                fidl::encoding::DefaultFuchsiaResourceDialect,
980            >,
981            offset: usize,
982            _depth: fidl::encoding::Depth,
983        ) -> fidl::Result<()> {
984            encoder.debug_check_bounds::<LibraryLoaderCacheServeRequest>(offset);
985            // Delegate to tuple encoding.
986            fidl::encoding::Encode::<
987                LibraryLoaderCacheServeRequest,
988                fidl::encoding::DefaultFuchsiaResourceDialect,
989            >::encode(
990                (<fidl::encoding::Endpoint<
991                    fidl::endpoints::ServerEnd<fidl_fuchsia_ldsvc::LoaderMarker>,
992                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
993                    &mut self.loader
994                ),),
995                encoder,
996                offset,
997                _depth,
998            )
999        }
1000    }
1001    unsafe impl<
1002            T0: fidl::encoding::Encode<
1003                fidl::encoding::Endpoint<
1004                    fidl::endpoints::ServerEnd<fidl_fuchsia_ldsvc::LoaderMarker>,
1005                >,
1006                fidl::encoding::DefaultFuchsiaResourceDialect,
1007            >,
1008        >
1009        fidl::encoding::Encode<
1010            LibraryLoaderCacheServeRequest,
1011            fidl::encoding::DefaultFuchsiaResourceDialect,
1012        > for (T0,)
1013    {
1014        #[inline]
1015        unsafe fn encode(
1016            self,
1017            encoder: &mut fidl::encoding::Encoder<
1018                '_,
1019                fidl::encoding::DefaultFuchsiaResourceDialect,
1020            >,
1021            offset: usize,
1022            depth: fidl::encoding::Depth,
1023        ) -> fidl::Result<()> {
1024            encoder.debug_check_bounds::<LibraryLoaderCacheServeRequest>(offset);
1025            // Zero out padding regions. There's no need to apply masks
1026            // because the unmasked parts will be overwritten by fields.
1027            // Write the fields.
1028            self.0.encode(encoder, offset + 0, depth)?;
1029            Ok(())
1030        }
1031    }
1032
1033    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1034        for LibraryLoaderCacheServeRequest
1035    {
1036        #[inline(always)]
1037        fn new_empty() -> Self {
1038            Self {
1039                loader: fidl::new_empty!(
1040                    fidl::encoding::Endpoint<
1041                        fidl::endpoints::ServerEnd<fidl_fuchsia_ldsvc::LoaderMarker>,
1042                    >,
1043                    fidl::encoding::DefaultFuchsiaResourceDialect
1044                ),
1045            }
1046        }
1047
1048        #[inline]
1049        unsafe fn decode(
1050            &mut self,
1051            decoder: &mut fidl::encoding::Decoder<
1052                '_,
1053                fidl::encoding::DefaultFuchsiaResourceDialect,
1054            >,
1055            offset: usize,
1056            _depth: fidl::encoding::Depth,
1057        ) -> fidl::Result<()> {
1058            decoder.debug_check_bounds::<Self>(offset);
1059            // Verify that padding bytes are zero.
1060            fidl::decode!(
1061                fidl::encoding::Endpoint<
1062                    fidl::endpoints::ServerEnd<fidl_fuchsia_ldsvc::LoaderMarker>,
1063                >,
1064                fidl::encoding::DefaultFuchsiaResourceDialect,
1065                &mut self.loader,
1066                decoder,
1067                offset + 0,
1068                _depth
1069            )?;
1070            Ok(())
1071        }
1072    }
1073}
fidl_fuchsia_test_runner/fidl_fuchsia_test_runner.rs

fidl_fuchsia_test_runner/
fidl_fuchsia_test_runner.rs
