rtc_datachannel/message/
message_type.rs

1use super::*;
2use shared::error::{Error, Result};
3
4// The first byte in a `Message` that specifies its type:
5pub(crate) const MESSAGE_TYPE_ACK: u8 = 0x02;
6pub(crate) const MESSAGE_TYPE_OPEN: u8 = 0x03;
7pub(crate) const MESSAGE_TYPE_LEN: usize = 1;
8
9// A parsed DataChannel message
10#[derive(Eq, PartialEq, Copy, Clone, Debug)]
11pub enum MessageType {
12    DataChannelAck,
13    DataChannelOpen,
14}
15
16impl MarshalSize for MessageType {
17    fn marshal_size(&self) -> usize {
18        MESSAGE_TYPE_LEN
19    }
20}
21
22impl Marshal for MessageType {
23    fn marshal_to(&self, mut buf: &mut [u8]) -> Result<usize> {
24        let b = match self {
25            MessageType::DataChannelAck => MESSAGE_TYPE_ACK,
26            MessageType::DataChannelOpen => MESSAGE_TYPE_OPEN,
27        };
28
29        buf.put_u8(b);
30
31        Ok(1)
32    }
33}
34
35impl Unmarshal for MessageType {
36    fn unmarshal<B>(buf: &mut B) -> Result<Self>
37    where
38        B: Buf,
39    {
40        let required_len = MESSAGE_TYPE_LEN;
41        if buf.remaining() < required_len {
42            return Err(Error::UnexpectedEndOfBuffer {
43                expected: required_len,
44                actual: buf.remaining(),
45            });
46        }
47
48        let b = buf.get_u8();
49
50        match b {
51            MESSAGE_TYPE_ACK => Ok(Self::DataChannelAck),
52            MESSAGE_TYPE_OPEN => Ok(Self::DataChannelOpen),
53            _ => Err(Error::InvalidMessageType(b)),
54        }
55    }
56}
57
58#[cfg(test)]
59mod tests {
60    use bytes::{Bytes, BytesMut};
61
62    use super::*;
63
64    #[test]
65    fn test_message_type_unmarshal_open_success() -> Result<()> {
66        let mut bytes = Bytes::from_static(&[0x03]);
67        let msg_type = MessageType::unmarshal(&mut bytes)?;
68
69        assert_eq!(msg_type, MessageType::DataChannelOpen);
70
71        Ok(())
72    }
73
74    #[test]
75    fn test_message_type_unmarshal_ack_success() -> Result<()> {
76        let mut bytes = Bytes::from_static(&[0x02]);
77        let msg_type = MessageType::unmarshal(&mut bytes)?;
78
79        assert_eq!(msg_type, MessageType::DataChannelAck);
80        Ok(())
81    }
82
83    #[test]
84    fn test_message_type_unmarshal_invalid() -> Result<()> {
85        let mut bytes = Bytes::from_static(&[0x01]);
86        match MessageType::unmarshal(&mut bytes) {
87            Ok(_) => panic!("expected Error, but got Ok"),
88            Err(err) => {
89                if Error::InvalidMessageType(0x01) == err {
90                    return Ok(());
91                }
92                panic!(
93                    "unexpected err {:?}, want {:?}",
94                    err,
95                    Error::InvalidMessageType(0x01)
96                );
97            }
98        }
99    }
100
101    #[test]
102    fn test_message_type_marshal_size() -> Result<()> {
103        let ack = MessageType::DataChannelAck;
104        let marshal_size = ack.marshal_size();
105
106        assert_eq!(marshal_size, MESSAGE_TYPE_LEN);
107        Ok(())
108    }
109
110    #[test]
111    fn test_message_type_marshal() -> Result<()> {
112        let mut buf = BytesMut::with_capacity(MESSAGE_TYPE_LEN);
113        buf.resize(MESSAGE_TYPE_LEN, 0u8);
114        let msg_type = MessageType::DataChannelAck;
115        let n = msg_type.marshal_to(&mut buf)?;
116        let bytes = buf.freeze();
117
118        assert_eq!(n, MESSAGE_TYPE_LEN);
119        assert_eq!(&bytes[..], &[0x02]);
120        Ok(())
121    }
122}
rtc_datachannel/message/message_type.rs

rtc_datachannel/message/
message_type.rs
