1pub mod utils;
5
6pub mod typed_array;
7
8use std::{
9 cell::RefCell,
10 fmt::{Debug, Display},
11 marker::PhantomData,
12 pin::Pin,
13 rc::Rc,
14 task::{self, Poll},
15};
16
17use futures::{channel::oneshot, stream::FusedStream, Sink, Stream};
18use js_sys::{Array, JsString};
19use js_utils::{
20 event::{EventListener, When},
21 JsError,
22};
23use wasm_bindgen::{JsCast, JsValue};
24use web_sys::{Event, EventTarget, MessageEvent};
25
26use crate::transferable::utils::{
27 construct_message_object, is_transport_message, message_payload, transport_name_matches,
28 Payload,
29};
30
31use super::{state::State, PostMessage};
32
33pub struct WithTransferable {
35 pub data: JsValue,
37
38 pub transfer: Array,
40}
41
42pub trait Transferable {
45 type Context;
47
48 type Error;
50
51 fn prepare_for_transfer(
53 self,
54 context: &mut Self::Context,
55 ) -> Result<WithTransferable, Self::Error>;
56
57 fn reconstruct(object: JsValue, context: &mut Self::Context) -> Result<Self, Self::Error>
59 where
60 Self: Sized;
61}
62
63pub trait IntoTransferable<Context, Error> {
65 type Output: Transferable<Context = Context, Error = Error>;
67
68 fn into_transferable(self) -> Self::Output;
70}
71
72pub trait FromTransferable<Context, Error> {
74 type Input: Transferable<Context = Context, Error = Error>;
76
77 fn from_transferable(input: Self::Input) -> Self;
79}
80
81#[derive(Debug)]
83pub enum Error<TransferableError> {
84 NotInWorker,
86
87 SendingError(JsError),
89
90 MalformedMessage,
92
93 TransferableError(TransferableError),
95
96 WorkerError(Event),
98
99 MessageError(MessageEvent),
101
102 Other(JsError),
104}
105
106impl<TransferableError> Display for Error<TransferableError>
107where
108 TransferableError: Display,
109{
110 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
111 match self {
112 Error::NotInWorker => write!(f, "not inside a (right type of) worker"),
113 Error::SendingError(error) => write!(f, "failed to send message: {error}"),
114 Error::MalformedMessage => write!(f, "malformed message received"),
115 Error::TransferableError(error) => {
116 write!(f, "error occurred while converting transferable: {error}")
117 }
118 Error::WorkerError(error) => write!(f, "error occurred in worker: {error:?}"),
119 Error::MessageError(error) => write!(f, "message error occurred: {error:?}"),
120 Error::Other(error) => write!(f, "other error occurred: {error}"),
121 }
122 }
123}
124
125impl<TransferableError> std::error::Error for Error<TransferableError> where
126 TransferableError: Debug + Display
127{
128}
129
130pub struct TransferableTransport<T, Context, Incoming, Outgoing, Error>
133where
134 T: JsCast + AsRef<EventTarget> + PostMessage,
135 Incoming: FromTransferable<Context, Error>,
136 Outgoing: IntoTransferable<Context, Error>,
137 Error: std::error::Error + 'static,
138{
139 target: Rc<T>,
140 name: Option<String>,
141 name_js: Option<JsString>,
142 state: Rc<RefCell<State<JsValue, self::Error<Error>>>>,
143 context: RefCell<Context>,
144 open_receiver: Option<oneshot::Receiver<()>>,
145
146 #[cfg(feature = "logging")]
147 logger: Rc<RefCell<dnet_base::Logger>>,
148
149 _message_listener: EventListener<T, MessageEvent>,
150 _error_listener: EventListener<T, Event>,
151 _message_error_listener: EventListener<T, MessageEvent>,
152 _incoming: PhantomData<Incoming>,
153 _outgoing: PhantomData<Outgoing>,
154}
155
156impl<T, Context, Incoming, Outgoing, Error>
157 TransferableTransport<T, Context, Incoming, Outgoing, Error>
158where
159 T: JsCast + AsRef<EventTarget> + PostMessage,
160 Incoming: FromTransferable<Context, Error>,
161 Outgoing: IntoTransferable<Context, Error>,
162 Error: std::error::Error + 'static,
163{
164 pub async fn new(
166 target: &Rc<T>,
167 name: Option<String>,
168 context: Context,
169 wait_for_open: bool,
170 ) -> Result<Self, self::Error<Error>> {
171 let (open_sender, open_receiver) = oneshot::channel();
172 let open_sender = Rc::new(RefCell::new(Some(open_sender)));
173
174 let state = Rc::new(RefCell::new(State::new()));
175
176 #[cfg(feature = "logging")]
177 let logger = Rc::new(RefCell::new(if let Some(name) = name.as_ref() {
178 dnet_base::Logger::new_for_already_named::<Self>(&name)
179 } else {
180 dnet_base::Logger::new::<Self>()
181 }));
182
183 let target = target.clone();
184
185 #[cfg(feature = "logging")]
186 let logger_clone = logger.clone();
187
188 let state_clone = state.clone();
189 let name_js = name.clone().map(JsString::from);
190 let name_js_clone = name_js.clone();
191 let open_sender_clone = open_sender.clone();
192
193 let message_listener = target
194 .when("message", move |event: MessageEvent| {
195 let data = event.data();
196 if !(is_transport_message(&data)
197 && transport_name_matches(&data, name_js_clone.as_ref()))
198 {
199 return;
200 }
201
202 if let Some(payload) = message_payload(&data) {
203 match payload {
204 Payload::Open => {
205 if let Some(notifier) = open_sender_clone.take() {
206 let _ = notifier.send(());
207 } else {
208 unreachable!("open message received twice!")
209 }
210 }
211 Payload::Close => {
212 state_clone.borrow_mut().close();
213 }
214 Payload::Object(js_value) => {
215 #[cfg(feature = "logging")]
216 logger_clone.borrow().log_message_arrived_unknown(None);
217
218 state_clone.borrow_mut().message(js_value);
219 }
220 }
221 } else {
222 let error = self::Error::MalformedMessage;
223
224 #[cfg(feature = "logging")]
225 logger_clone.borrow().log_message_arrived_failure(&error);
226
227 state_clone.borrow_mut().error(error);
228 }
229 })
230 .map_err(self::Error::Other)?;
231
232 let state_clone = state.clone();
233 let error_listener = target
234 .when("error", move |event: Event| {
235 state_clone
236 .borrow_mut()
237 .error(self::Error::WorkerError(event));
238 })
239 .map_err(self::Error::Other)?;
240
241 let state_clone = state.clone();
242 let message_error_listener = target
243 .when("messageerror", move |event: MessageEvent| {
244 state_clone
245 .borrow_mut()
246 .error(self::Error::MessageError(event));
247 })
248 .map_err(self::Error::Other)?;
249
250 let context = RefCell::new(context);
251
252 let mut transport = TransferableTransport {
253 target,
254 name,
255 name_js,
256 state,
257 context,
258 open_receiver: Some(open_receiver),
259
260 #[cfg(feature = "logging")]
261 logger,
262
263 _message_listener: message_listener,
264 _error_listener: error_listener,
265 _message_error_listener: message_error_listener,
266 _incoming: PhantomData,
267 _outgoing: PhantomData,
268 };
269 transport.send_open();
270 if wait_for_open {
271 transport.wait_for_open().await;
272 }
273
274 Ok(transport)
275 }
276
277 pub fn name(&self) -> Option<&str> {
279 self.name.as_deref()
280 }
281
282 pub async fn wait_for_open(&mut self) {
284 if let Some(open_receiver) = self.open_receiver.take() {
285 let _ = open_receiver.await;
286
287 #[cfg(feature = "logging")]
288 self.logger.borrow().log_open_success();
289 }
290 }
291
292 fn send_message(&self, message: Outgoing) -> Result<(), self::Error<Error>> {
293 let WithTransferable { data, transfer } = message
294 .into_transferable()
295 .prepare_for_transfer(&mut self.context.borrow_mut())
296 .map_err(self::Error::TransferableError)?;
297
298 let message = construct_message_object(self.name_js.as_ref(), Payload::Object(data));
299
300 self.target
301 .post_message_with_transfer(&message, &transfer)
302 .map_err(|error| self::Error::SendingError(error.into()))?;
303
304 Ok(())
305 }
306
307 fn send_open(&self) {
308 let message = construct_message_object(self.name_js.as_ref(), Payload::Open);
309 let _ = self.target.post_message(&message);
310 }
311
312 fn send_close(&self) {
313 let message = construct_message_object(self.name_js.as_ref(), Payload::Close);
314 let _ = self.target.post_message(&message);
315 }
316}
317
318impl<T, Context, Incoming, Outgoing, Error> Drop
319 for TransferableTransport<T, Context, Incoming, Outgoing, Error>
320where
321 T: JsCast + AsRef<EventTarget> + PostMessage,
322 Incoming: FromTransferable<Context, Error>,
323 Outgoing: IntoTransferable<Context, Error>,
324 Error: std::error::Error + 'static,
325{
326 fn drop(&mut self) {
327 self.send_close();
328 }
329}
330
331impl<T, Context, Incoming, Outgoing, Error> Sink<Outgoing>
332 for TransferableTransport<T, Context, Incoming, Outgoing, Error>
333where
334 T: JsCast + AsRef<EventTarget> + PostMessage,
335 Incoming: FromTransferable<Context, Error>,
336 Outgoing: IntoTransferable<Context, Error>,
337 Error: std::error::Error + 'static,
338{
339 type Error = dnet_base::Error<self::Error<Error>>;
340
341 fn poll_ready(
342 self: Pin<&mut Self>,
343 _cx: &mut task::Context<'_>,
344 ) -> Poll<Result<(), Self::Error>> {
345 let result = Poll::Ready(Ok(()));
346
347 #[cfg(feature = "logging")]
348 self.logger.borrow().log_ready(&result);
349
350 result
351 }
352
353 fn start_send(self: Pin<&mut Self>, item: Outgoing) -> Result<(), Self::Error> {
354 let result = if self.state.borrow().closed {
355 Err(dnet_base::Error::Closed)
356 } else {
357 self.send_message(item).map_err(dnet_base::Error::Other)
358 };
359
360 #[cfg(feature = "logging")]
361 self.logger
362 .borrow()
363 .log_sending::<Outgoing, _>(&result, None);
364
365 result
366 }
367
368 fn poll_flush(
369 self: Pin<&mut Self>,
370 _cx: &mut task::Context<'_>,
371 ) -> Poll<Result<(), Self::Error>> {
372 let result = if self.state.borrow().closed {
373 Poll::Ready(Err(dnet_base::Error::Closed))
374 } else {
375 Poll::Ready(Ok(()))
376 };
377
378 #[cfg(feature = "logging")]
379 self.logger.borrow().log_flush(&result);
380
381 result
382 }
383
384 fn poll_close(
385 self: Pin<&mut Self>,
386 _cx: &mut task::Context<'_>,
387 ) -> Poll<Result<(), Self::Error>> {
388 let result = if self.state.borrow().closed {
389 Poll::Ready(Err(dnet_base::Error::Closed))
390 } else {
391 self.send_close();
392 self.state.borrow_mut().close();
393 Poll::Ready(Ok(()))
394 };
395
396 #[cfg(feature = "logging")]
397 self.logger.borrow().log_close(&result);
398
399 result
400 }
401}
402
403impl<T, Context, Incoming, Outgoing, Error> Stream
404 for TransferableTransport<T, Context, Incoming, Outgoing, Error>
405where
406 T: JsCast + AsRef<EventTarget> + PostMessage,
407 Incoming: FromTransferable<Context, Error>,
408 Outgoing: IntoTransferable<Context, Error>,
409 Error: std::error::Error + 'static,
410{
411 type Item = Result<Incoming, self::Error<Error>>;
412
413 fn poll_next(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Option<Self::Item>> {
414 let mut state = self.state.borrow_mut();
415 let result = if state.is_terminated() {
416 Poll::Ready(None)
417 } else if let Some(item) = state.incoming.pop_front() {
418 Poll::Ready(Some(item.and_then(|item| {
419 <Incoming::Input>::reconstruct(item, &mut self.context.borrow_mut())
420 .map_err(self::Error::TransferableError)
421 .map(|item| Incoming::from_transferable(item))
422 })))
423 } else {
424 state.update_waker_with(cx.waker());
425 Poll::Pending
426 };
427
428 #[cfg(feature = "logging")]
429 self.logger.borrow().log_receiving(&result, None);
430
431 result
432 }
433}
434
435impl<T, Context, Incoming, Outgoing, Error> FusedStream
436 for TransferableTransport<T, Context, Incoming, Outgoing, Error>
437where
438 T: JsCast + AsRef<EventTarget> + PostMessage,
439 Incoming: FromTransferable<Context, Error>,
440 Outgoing: IntoTransferable<Context, Error>,
441 Error: std::error::Error + 'static,
442{
443 fn is_terminated(&self) -> bool {
444 self.state.borrow().is_terminated()
445 }
446}
447
448#[cfg(feature = "logging")]
449impl<T, Context, Incoming, Outgoing, Error> dnet_base::Logging
450 for TransferableTransport<T, Context, Incoming, Outgoing, Error>
451where
452 T: JsCast + AsRef<EventTarget> + PostMessage,
453 Incoming: FromTransferable<Context, Error>,
454 Outgoing: IntoTransferable<Context, Error>,
455 Error: std::error::Error + 'static,
456{
457 const KIND: &'static str = "Transferable";
458
459 fn with_logger<F, R>(&self, f: F) -> R
460 where
461 F: FnOnce(&dnet_base::Logger) -> R,
462 {
463 f(&self.logger.borrow())
464 }
465
466 fn with_logger_mut<F, R>(&mut self, f: F) -> R
467 where
468 F: FnOnce(&mut dnet_base::Logger) -> R,
469 {
470 f(&mut self.logger.borrow_mut())
471 }
472}
473
474#[cfg(test)]
475mod tests {
476 use std::rc::Rc;
477
478 use dnet_base::Receive;
479 use dnet_codecs::{bincode, BincodeCodec};
480 use dnet_macros::IntoTransferable;
481 use dnet_tests::dtest_configure;
482 use futures::{join, SinkExt};
483 use js_sys::{ArrayBuffer, Uint32Array};
484 use wasm_bindgen_test::wasm_bindgen_test;
485 use web_sys::{MessageChannel, MessagePort};
486
487 use crate::{wrapper, TransferableTransport};
488
489 dtest_configure!();
490
491 type Context = wrapper::Context<BincodeCodec>;
492 type Error = wrapper::Error<bincode::EncodeError, bincode::DecodeError>;
493
494 async fn create_transports<I, O>() -> (
495 TransferableTransport<MessagePort, Context, I, O, Error>,
496 TransferableTransport<MessagePort, Context, O, I, Error>,
497 )
498 where
499 I: crate::FromTransferable<Context, Error> + crate::IntoTransferable<Context, Error>,
500 O: crate::FromTransferable<Context, Error> + crate::IntoTransferable<Context, Error>,
501 {
502 let channel = MessageChannel::new().unwrap();
503
504 let left_port = Rc::new(channel.port1());
505 let right_port = Rc::new(channel.port2());
506
507 let left = TransferableTransport::new(
508 &left_port,
509 None,
510 Context::new(BincodeCodec::default()),
511 true,
512 );
513 let right = TransferableTransport::new(
514 &right_port,
515 None,
516 Context::new(BincodeCodec::default()),
517 true,
518 );
519
520 left_port.start();
521 right_port.start();
522
523 let (left, right) = join!(left, right);
524 let left = left.unwrap();
525 let right = right.unwrap();
526
527 (left, right)
528 }
529
530 #[wasm_bindgen_test]
531 async fn test_into_transferable_struct_unnamed_fields() {
532 #[derive(Debug, IntoTransferable)]
533 struct Message(Vec<u32>, #[transferable] ArrayBuffer);
534
535 #[derive(Debug, IntoTransferable)]
536 struct Empty {}
537
538 let (mut left, mut right) = create_transports::<Empty, Message>().await;
539
540 dnet_tests::init_logging(&mut left, &mut right);
541
542 let ints = vec![1, 2, 3];
543
544 let array = Uint32Array::new_with_length(3);
545 array.copy_from(&[4, 5, 6]);
546
547 let message = Message(ints.clone(), array.buffer());
548
549 left.send(message).await.unwrap();
550 let received = right.receive().await.unwrap();
551
552 assert_eq!(received.0, ints);
553 assert_eq!(Uint32Array::new(&received.1).to_vec(), vec![4, 5, 6]);
554 }
555
556 #[wasm_bindgen_test]
557 async fn test_into_transferable_struct() {
558 #[derive(Debug, IntoTransferable)]
559 struct Message {
560 ints: Vec<u32>,
561
562 #[transferable]
563 array_buffer_1: ArrayBuffer,
564
565 #[transferable]
566 array_buffer_2: ArrayBuffer,
567 }
568
569 #[derive(Debug, IntoTransferable)]
570 struct Empty {}
571
572 let (mut left, mut right) = create_transports::<Empty, Message>().await;
573
574 dnet_tests::init_logging(&mut left, &mut right);
575
576 let ints = vec![1, 2, 3];
577
578 let array_1 = Uint32Array::new_with_length(3);
579 array_1.copy_from(&[4, 5, 6]);
580
581 let array_2 = Uint32Array::new_with_length(3);
582 array_2.copy_from(&[7, 8, 9]);
583
584 let message = Message {
585 ints: ints.clone(),
586 array_buffer_1: array_1.buffer(),
587 array_buffer_2: array_2.buffer(),
588 };
589
590 left.send(message).await.unwrap();
591 let received = right.receive().await.unwrap();
592
593 assert_eq!(received.ints, ints);
594 assert_eq!(
595 Uint32Array::new(&received.array_buffer_1).to_vec(),
596 vec![4, 5, 6]
597 );
598 assert_eq!(
599 Uint32Array::new(&received.array_buffer_2).to_vec(),
600 vec![7, 8, 9]
601 );
602 }
603
604 #[wasm_bindgen_test]
605 async fn test_into_transferable_nested_struct() {
606 #[derive(Debug, IntoTransferable)]
607 struct Message {
608 ints: Vec<u32>,
609
610 #[transferable]
611 array_buffer: ArrayBuffer,
612 }
613
614 #[derive(Debug, IntoTransferable)]
615 struct Wrapper {
616 #[into_transferable]
617 message_1: Message,
618
619 #[into_transferable]
620 message_2: Message,
621
622 ints: Vec<u32>,
623 }
624
625 #[derive(Debug, IntoTransferable)]
626 struct Wrapper2 {
627 #[into_transferable]
628 wrapper: Wrapper,
629 }
630
631 #[derive(Debug, IntoTransferable)]
632 struct Empty {}
633
634 let (mut left, mut right) = create_transports::<Empty, Wrapper2>().await;
635
636 dnet_tests::init_logging(&mut left, &mut right);
637
638 let ints_1 = vec![1, 2, 3];
639 let ints_2 = vec![4, 5, 6];
640 let ints_3 = vec![7, 8, 9];
641
642 let array_1 = Uint32Array::new_with_length(3);
643 array_1.copy_from(&[10, 11, 12]);
644
645 let array_2 = Uint32Array::new_with_length(3);
646 array_2.copy_from(&[13, 14, 15]);
647
648 let wrapper = Wrapper {
649 message_1: Message {
650 ints: ints_1.clone(),
651 array_buffer: array_1.buffer(),
652 },
653 message_2: Message {
654 ints: ints_2.clone(),
655 array_buffer: array_2.buffer(),
656 },
657 ints: ints_3,
658 };
659 let wrapper_2 = Wrapper2 { wrapper };
660
661 left.send(wrapper_2).await.unwrap();
662 let received = right.receive().await.unwrap();
663
664 assert_eq!(received.wrapper.message_1.ints, ints_1);
665 assert_eq!(received.wrapper.message_2.ints, ints_2);
666 assert_eq!(
667 Uint32Array::new(&received.wrapper.message_1.array_buffer).to_vec(),
668 vec![10, 11, 12]
669 );
670 assert_eq!(
671 Uint32Array::new(&received.wrapper.message_2.array_buffer).to_vec(),
672 vec![13, 14, 15]
673 );
674 }
675
676 #[wasm_bindgen_test]
677 async fn test_into_transferable_enum() {
678 #[derive(Debug, IntoTransferable)]
679 enum Message {
680 Variant1 {
681 ints: Vec<u32>,
682
683 #[transferable]
684 array_buffer_1: ArrayBuffer,
685
686 #[transferable]
687 array_buffer_2: ArrayBuffer,
688 },
689 Variant2 {
690 ints: Vec<u32>,
691 },
692 Variant3 {
693 #[transferable]
694 array_buffer: ArrayBuffer,
695 },
696 Variant4,
697 }
698
699 #[derive(Debug, IntoTransferable)]
700 struct Empty {}
701
702 let (mut left, mut right) = create_transports::<Empty, Message>().await;
703
704 dnet_tests::init_logging(&mut left, &mut right);
705
706 let ints = vec![1, 2, 3];
707
708 let array_1 = Uint32Array::new_with_length(3);
709 array_1.copy_from(&[4, 5, 6]);
710
711 let array_2 = Uint32Array::new_with_length(3);
712 array_2.copy_from(&[7, 8, 9]);
713
714 let message = Message::Variant1 {
715 ints: ints.clone(),
716 array_buffer_1: array_1.buffer(),
717 array_buffer_2: array_2.buffer(),
718 };
719
720 left.send(message).await.unwrap();
721 let received = right.receive().await.unwrap();
722
723 if let Message::Variant1 {
724 ints: ints_received,
725 array_buffer_1,
726 array_buffer_2,
727 } = received
728 {
729 assert_eq!(ints_received, ints);
730 assert_eq!(Uint32Array::new(&array_buffer_1).to_vec(), vec![4, 5, 6]);
731 assert_eq!(Uint32Array::new(&array_buffer_2).to_vec(), vec![7, 8, 9]);
732 } else {
733 panic!("unexpected variant received");
734 }
735
736 let ints = vec![10, 11, 12];
737 left.send(Message::Variant2 { ints: ints.clone() })
738 .await
739 .unwrap();
740 let received = right.receive().await.unwrap();
741
742 if let Message::Variant2 {
743 ints: ints_received,
744 } = received
745 {
746 assert_eq!(ints_received, ints);
747 } else {
748 panic!("unexpected variant received");
749 }
750
751 let array = Uint32Array::new_with_length(3);
752 array.copy_from(&[13, 14, 15]);
753
754 left.send(Message::Variant3 {
755 array_buffer: array.buffer(),
756 })
757 .await
758 .unwrap();
759 let received = right.receive().await.unwrap();
760
761 if let Message::Variant3 { array_buffer } = received {
762 assert_eq!(Uint32Array::new(&array_buffer).to_vec(), vec![13, 14, 15]);
763 } else {
764 panic!("unexpected variant received");
765 }
766
767 left.send(Message::Variant4).await.unwrap();
768 let received = right.receive().await.unwrap();
769
770 if !matches!(received, Message::Variant4) {
771 panic!("unexpected variant received");
772 }
773 }
774
775 #[wasm_bindgen_test]
776 async fn test_into_transferable_nested_enum() {
777 #[derive(Debug, IntoTransferable)]
778 struct Message {
779 ints: Vec<u32>,
780
781 #[transferable]
782 array_buffer: ArrayBuffer,
783 }
784
785 #[derive(Debug, IntoTransferable)]
786 enum Message2 {
787 Variant1 {
788 ints: Vec<u32>,
789
790 #[transferable]
791 array_buffer: ArrayBuffer,
792 },
793
794 Variant2 {
795 #[into_transferable]
796 message: Message,
797 },
798 }
799
800 #[derive(Debug, IntoTransferable)]
801 struct Empty {}
802
803 let (mut left, mut right) = create_transports::<Empty, Message2>().await;
804
805 dnet_tests::init_logging(&mut left, &mut right);
806
807 let ints = vec![1, 2, 3];
808
809 let array = Uint32Array::new_with_length(3);
810 array.copy_from(&[4, 5, 6]);
811
812 let message = Message2::Variant1 {
813 ints: ints.clone(),
814 array_buffer: array.buffer(),
815 };
816
817 left.send(message).await.unwrap();
818 let received = right.receive().await.unwrap();
819
820 if let Message2::Variant1 {
821 ints: ints_received,
822 array_buffer,
823 } = received
824 {
825 assert_eq!(ints_received, ints);
826 assert_eq!(Uint32Array::new(&array_buffer).to_vec(), vec![4, 5, 6]);
827 } else {
828 panic!("unexpected variant received");
829 }
830
831 let ints = vec![7, 8, 9];
832
833 let array = Uint32Array::new_with_length(3);
834 array.copy_from(&[10, 11, 12]);
835
836 let message = Message2::Variant2 {
837 message: Message {
838 ints: ints.clone(),
839 array_buffer: array.buffer(),
840 },
841 };
842 left.send(message).await.unwrap();
843 let received = right.receive().await.unwrap();
844
845 if let Message2::Variant2 {
846 message:
847 Message {
848 ints: ints_received,
849 array_buffer,
850 },
851 } = received
852 {
853 assert_eq!(ints_received, ints);
854 assert_eq!(Uint32Array::new(&array_buffer).to_vec(), vec![10, 11, 12]);
855 } else {
856 panic!("unexpected variant received");
857 }
858 }
859
860 #[wasm_bindgen_test]
861 async fn test_into_transferable_enum_unnamed_fields() {
862 #[derive(Debug, IntoTransferable)]
863 enum Message {
864 Variant1(Vec<u32>, #[transferable] ArrayBuffer),
865 Variant2(Vec<u32>),
866 Variant3 {
867 #[transferable]
868 some_field: ArrayBuffer,
869 },
870 Variant4,
871 }
872
873 #[derive(Debug, IntoTransferable)]
874 struct Empty {}
875
876 let (mut left, mut right) = create_transports::<Empty, Message>().await;
877
878 dnet_tests::init_logging(&mut left, &mut right);
879
880 let ints = vec![1, 2, 3];
881
882 let array = Uint32Array::new_with_length(3);
883 array.copy_from(&[4, 5, 6]);
884
885 let message = Message::Variant1(ints.clone(), array.buffer());
886
887 left.send(message).await.unwrap();
888 let received = right.receive().await.unwrap();
889
890 if let Message::Variant1(ints_received, array_buffer) = received {
891 assert_eq!(ints_received, ints);
892 assert_eq!(Uint32Array::new(&array_buffer).to_vec(), vec![4, 5, 6]);
893 } else {
894 panic!("unexpected variant received");
895 }
896
897 let ints = vec![10, 11, 12];
898 left.send(Message::Variant2(ints.clone())).await.unwrap();
899 let received = right.receive().await.unwrap();
900
901 if let Message::Variant2(ints_received) = received {
902 assert_eq!(ints_received, ints);
903 } else {
904 panic!("unexpected variant received");
905 }
906
907 let array = Uint32Array::new_with_length(3);
908 array.copy_from(&[13, 14, 15]);
909
910 left.send(Message::Variant3 {
911 some_field: array.buffer(),
912 })
913 .await
914 .unwrap();
915 let received = right.receive().await.unwrap();
916
917 if let Message::Variant3 {
918 some_field: array_buffer,
919 } = received
920 {
921 assert_eq!(Uint32Array::new(&array_buffer).to_vec(), vec![13, 14, 15]);
922 } else {
923 panic!("unexpected variant received");
924 }
925
926 left.send(Message::Variant4).await.unwrap();
927 let received = right.receive().await.unwrap();
928
929 if !matches!(received, Message::Variant4) {
930 panic!("unexpected variant received");
931 }
932 }
933}