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

fidl_fuchsia_test_runner/
fidl_fuchsia_test_runner.rs
