1 mod bindings {
2     wit_bindgen::generate!({
3         path: "../misc/component-async-tests/wit",
4         world: "transmit-callee",
5     });
6 
7     use super::Component;
8     export!(Component);
9 }
10 
11 use {
12     bindings::{
13         exports::local::local::transmit::{Control, Guest},
14         wit_future, wit_stream,
15     },
16     std::future::IntoFuture,
17     wit_bindgen::{FutureReader, StreamReader, StreamResult},
18 };
19 
20 struct Component;
21 
22 impl Guest for Component {
23     async fn exchange(
24         mut control_rx: StreamReader<Control>,
25         mut caller_stream_rx: StreamReader<String>,
26         caller_future_rx1: FutureReader<String>,
27         caller_future_rx2: FutureReader<String>,
28     ) -> (
29         StreamReader<String>,
30         FutureReader<String>,
31         FutureReader<String>,
32     ) {
33         let (mut callee_stream_tx, callee_stream_rx) = wit_stream::new();
34         let (callee_future_tx1, callee_future_rx1) = wit_future::new(|| todo!());
35         let (callee_future_tx2, callee_future_rx2) = wit_future::new(|| String::new());
36 
37         wit_bindgen::spawn(async move {
38             let mut caller_future_rx1 = Some(caller_future_rx1);
39             let mut callee_future_tx1 = Some(callee_future_tx1);
40 
41             while let Some(message) = control_rx.next().await {
42                 match message {
43                     Control::ReadStream(value) => {
44                         assert_eq!(caller_stream_rx.next().await, Some(value));
45                     }
46                     Control::ReadStreamZero => {
47                         assert_eq!(
48                             caller_stream_rx.read(Vec::new()).await.0,
49                             StreamResult::Complete(0)
50                         );
51                     }
52                     Control::ReadFuture(value) => {
53                         assert_eq!(caller_future_rx1.take().unwrap().into_future().await, value);
54                     }
55                     Control::WriteStream(value) => {
56                         assert!(callee_stream_tx.write_one(value).await.is_none());
57                     }
58                     Control::WriteStreamZero => {
59                         assert_eq!(
60                             callee_stream_tx.write(Vec::new()).await.0,
61                             StreamResult::Complete(0)
62                         );
63                     }
64                     Control::WriteFuture(value) => {
65                         callee_future_tx1
66                             .take()
67                             .unwrap()
68                             .write(value)
69                             .await
70                             .unwrap();
71                     }
72                 }
73             }
74 
75             drop((caller_future_rx2, callee_future_tx2));
76         });
77 
78         (callee_stream_rx, callee_future_rx1, callee_future_rx2)
79     }
80 }
81 
82 // Unused function; required since this file is built as a `bin`:
83 fn main() {}
84