1 // Silence warning on `..Default::default()` with no effect:
2 #![allow(clippy::needless_update)]
3
4 use super::*;
5 use crate::error::Result;
6 use bytes::{Bytes, BytesMut};
7
8 #[test]
test_basic() -> Result<()>9 fn test_basic() -> Result<()> {
10 let mut empty_bytes = &vec![0u8; 0][..];
11 let result = Packet::unmarshal(&mut empty_bytes);
12 assert!(
13 result.is_err(),
14 "Unmarshal did not error on zero length packet"
15 );
16
17 let raw_pkt = Bytes::from_static(&[
18 0x90, 0xe0, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, 0x1c, 0x64, 0x27, 0x82, 0x00, 0x01, 0x00,
19 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0x98, 0x36, 0xbe, 0x88, 0x9e,
20 ]);
21 let parsed_packet = Packet {
22 header: Header {
23 version: 2,
24 padding: false,
25 extension: true,
26 marker: true,
27 payload_type: 96,
28 sequence_number: 27023,
29 timestamp: 3653407706,
30 ssrc: 476325762,
31 csrc: vec![],
32 extension_profile: 1,
33 extensions: vec![Extension {
34 id: 0,
35 payload: Bytes::from_static(&[0xFF, 0xFF, 0xFF, 0xFF]),
36 }],
37 ..Default::default()
38 },
39 payload: Bytes::from_static(&[0x98, 0x36, 0xbe, 0x88, 0x9e]),
40 };
41 let buf = &mut raw_pkt.clone();
42 let packet = Packet::unmarshal(buf)?;
43 assert_eq!(
44 packet, parsed_packet,
45 "TestBasic unmarshal: got {packet}, want {parsed_packet}"
46 );
47 assert_eq!(
48 packet.header.marshal_size(),
49 20,
50 "wrong computed header marshal size"
51 );
52 assert_eq!(
53 packet.marshal_size(),
54 raw_pkt.len(),
55 "wrong computed marshal size"
56 );
57
58 let raw = packet.marshal()?;
59 let n = raw.len();
60 assert_eq!(n, raw_pkt.len(), "wrong marshal size");
61
62 assert_eq!(
63 raw.len(),
64 raw_pkt.len(),
65 "wrong raw marshal size {} vs {}",
66 raw.len(),
67 raw_pkt.len()
68 );
69 assert_eq!(
70 raw, raw_pkt,
71 "TestBasic marshal: got {raw:?}, want {raw_pkt:?}"
72 );
73
74 Ok(())
75 }
76
77 #[test]
test_extension() -> Result<()>78 fn test_extension() -> Result<()> {
79 let mut missing_extension_pkt = Bytes::from_static(&[
80 0x90, 0x60, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, 0x1c, 0x64, 0x27, 0x82,
81 ]);
82 let buf = &mut missing_extension_pkt;
83 let result = Packet::unmarshal(buf);
84 assert!(
85 result.is_err(),
86 "Unmarshal did not error on packet with missing extension data"
87 );
88
89 let mut invalid_extension_length_pkt = Bytes::from_static(&[
90 0x90, 0x60, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, 0x1c, 0x64, 0x27, 0x82, 0x99, 0x99, 0x99,
91 0x99,
92 ]);
93 let buf = &mut invalid_extension_length_pkt;
94 let result = Packet::unmarshal(buf);
95 assert!(
96 result.is_err(),
97 "Unmarshal did not error on packet with invalid extension length"
98 );
99
100 let packet = Packet {
101 header: Header {
102 extension: true,
103 extension_profile: 3,
104 extensions: vec![Extension {
105 id: 0,
106 payload: Bytes::from_static(&[0]),
107 }],
108 ..Default::default()
109 },
110 payload: Bytes::from_static(&[]),
111 };
112
113 let mut raw = BytesMut::new();
114 let result = packet.marshal_to(&mut raw);
115 assert!(
116 result.is_err(),
117 "Marshal did not error on packet with invalid extension length"
118 );
119 if let Err(err) = result {
120 assert_eq!(Error::ErrBufferTooSmall, err);
121 }
122
123 Ok(())
124 }
125
126 #[test]
test_padding() -> Result<()>127 fn test_padding() -> Result<()> {
128 let raw_pkt = Bytes::from_static(&[
129 0xa0, 0x60, 0x19, 0x58, 0x63, 0xff, 0x7d, 0x7c, 0x4b, 0x98, 0xd4, 0x0a, 0x67, 0x4d, 0x00,
130 0x29, 0x9a, 0x64, 0x03, 0xc0, 0x11, 0x3f, 0x2c, 0xd4, 0x04, 0x04, 0x05, 0x00, 0x00, 0x03,
131 0x03, 0xe8, 0x00, 0x00, 0xea, 0x60, 0x04, 0x00, 0x00, 0x03,
132 ]);
133 let buf = &mut raw_pkt.clone();
134 let packet = Packet::unmarshal(buf)?;
135 assert_eq!(&packet.payload[..], &raw_pkt[12..12 + 25]);
136
137 let raw = packet.marshal()?;
138 assert_eq!(raw, raw_pkt);
139
140 Ok(())
141 }
142
143 #[test]
test_packet_marshal_unmarshal() -> Result<()>144 fn test_packet_marshal_unmarshal() -> Result<()> {
145 let pkt = Packet {
146 header: Header {
147 extension: true,
148 csrc: vec![1, 2],
149 extension_profile: EXTENSION_PROFILE_TWO_BYTE,
150 extensions: vec![
151 Extension {
152 id: 1,
153 payload: Bytes::from_static(&[3, 4]),
154 },
155 Extension {
156 id: 2,
157 payload: Bytes::from_static(&[5, 6]),
158 },
159 ],
160 ..Default::default()
161 },
162 payload: Bytes::from_static(&[0xFFu8; 15]),
163 ..Default::default()
164 };
165 let mut raw = pkt.marshal()?;
166 let p = Packet::unmarshal(&mut raw)?;
167
168 assert_eq!(pkt, p);
169
170 Ok(())
171 }
172
173 #[test]
test_rfc_8285_one_byte_extension() -> Result<()>174 fn test_rfc_8285_one_byte_extension() -> Result<()> {
175 let raw_pkt = Bytes::from_static(&[
176 0x90, 0xe0, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, 0x1c, 0x64, 0x27, 0x82, 0xBE, 0xDE, 0x00,
177 0x01, 0x50, 0xAA, 0x00, 0x00, 0x98, 0x36, 0xbe, 0x88, 0x9e,
178 ]);
179 let buf = &mut raw_pkt.clone();
180 Packet::unmarshal(buf)?;
181
182 let p = Packet {
183 header: Header {
184 marker: true,
185 extension: true,
186 extension_profile: 0xBEDE,
187 extensions: vec![Extension {
188 id: 5,
189 payload: Bytes::from_static(&[0xAA]),
190 }],
191 version: 2,
192 payload_type: 96,
193 sequence_number: 27023,
194 timestamp: 3653407706,
195 ssrc: 476325762,
196 csrc: vec![],
197 ..Default::default()
198 },
199 payload: raw_pkt.slice(20..),
200 };
201
202 let dst = p.marshal()?;
203 assert_eq!(dst, raw_pkt);
204
205 Ok(())
206 }
207
208 #[test]
test_rfc_8285_one_byte_two_extension_of_two_bytes() -> Result<()>209 fn test_rfc_8285_one_byte_two_extension_of_two_bytes() -> Result<()> {
210 // 0 1 2 3
211 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
212 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
213 // | 0xBE | 0xDE | length=1 |
214 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
215 // | ID | L=0 | data | ID | L=0 | data...
216 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
217 let raw_pkt = Bytes::from_static(&[
218 0x90, 0xe0, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, 0x1c, 0x64, 0x27, 0x82, 0xBE, 0xDE, 0x00,
219 0x01, 0x10, 0xAA, 0x20, 0xBB, // Payload
220 0x98, 0x36, 0xbe, 0x88, 0x9e,
221 ]);
222 let buf = &mut raw_pkt.clone();
223 let p = Packet::unmarshal(buf)?;
224
225 let ext1 = p.header.get_extension(1);
226 let ext1_expect = Bytes::from_static(&[0xAA]);
227 if let Some(ext1) = ext1 {
228 assert_eq!(ext1, ext1_expect);
229 } else {
230 panic!("ext1 is none");
231 }
232
233 let ext2 = p.header.get_extension(2);
234 let ext2_expect = Bytes::from_static(&[0xBB]);
235 if let Some(ext2) = ext2 {
236 assert_eq!(ext2, ext2_expect);
237 } else {
238 panic!("ext2 is none");
239 }
240
241 // Test Marshal
242 let p = Packet {
243 header: Header {
244 marker: true,
245 extension: true,
246 extension_profile: 0xBEDE,
247 extensions: vec![
248 Extension {
249 id: 1,
250 payload: Bytes::from_static(&[0xAA]),
251 },
252 Extension {
253 id: 2,
254 payload: Bytes::from_static(&[0xBB]),
255 },
256 ],
257 version: 2,
258 payload_type: 96,
259 sequence_number: 27023,
260 timestamp: 3653407706,
261 ssrc: 476325762,
262 csrc: vec![],
263 ..Default::default()
264 },
265 payload: raw_pkt.slice(20..),
266 };
267
268 let dst = p.marshal()?;
269 assert_eq!(dst, raw_pkt);
270
271 Ok(())
272 }
273
274 #[test]
test_rfc_8285_one_byte_multiple_extensions_with_padding() -> Result<()>275 fn test_rfc_8285_one_byte_multiple_extensions_with_padding() -> Result<()> {
276 // 0 1 2 3
277 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
278 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
279 // | 0xBE | 0xDE | length=3 |
280 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
281 // | ID | L=0 | data | ID | L=1 | data...
282 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
283 // ...data | 0 (pad) | 0 (pad) | ID | L=3 |
284 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
285 // | data |
286 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
287
288 let mut raw_pkt = Bytes::from_static(&[
289 0x90, 0xe0, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, 0x1c, 0x64, 0x27, 0x82, 0xBE, 0xDE, 0x00,
290 0x03, 0x10, 0xAA, 0x21, 0xBB, 0xBB, 0x00, 0x00, 0x33, 0xCC, 0xCC, 0xCC, 0xCC,
291 // Payload
292 0x98, 0x36, 0xbe, 0x88, 0x9e,
293 ]);
294 let buf = &mut raw_pkt;
295 let packet = Packet::unmarshal(buf)?;
296 let ext1 = packet
297 .header
298 .get_extension(1)
299 .expect("Error getting header extension.");
300
301 let ext1_expect = Bytes::from_static(&[0xAA]);
302 assert_eq!(ext1, ext1_expect);
303
304 let ext2 = packet
305 .header
306 .get_extension(2)
307 .expect("Error getting header extension.");
308
309 let ext2_expect = Bytes::from_static(&[0xBB, 0xBB]);
310 assert_eq!(ext2, ext2_expect);
311
312 let ext3 = packet
313 .header
314 .get_extension(3)
315 .expect("Error getting header extension.");
316
317 let ext3_expect = Bytes::from_static(&[0xCC, 0xCC, 0xCC, 0xCC]);
318 assert_eq!(ext3, ext3_expect);
319
320 let mut dst_buf: Vec<Vec<u8>> = vec![vec![0u8; 1000], vec![0xFF; 1000], vec![0xAA; 2]];
321
322 let raw_pkg_marshal: [u8; 33] = [
323 // padding is moved to the end by re-marshaling
324 0x90, 0xe0, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, 0x1c, 0x64, 0x27, 0x82, 0xBE, 0xDE, 0x00,
325 0x03, 0x10, 0xAA, 0x21, 0xBB, 0xBB, 0x33, 0xCC, 0xCC, 0xCC, 0xCC, 0x00, 0x00,
326 // Payload
327 0x98, 0x36, 0xbe, 0x88, 0x9e,
328 ];
329
330 let checker = |name: &str, buf: &mut [u8], p: &Packet| -> Result<()> {
331 let size = p.marshal_to(buf)?;
332
333 assert_eq!(
334 &buf[..size],
335 &raw_pkg_marshal[..],
336 "Marshalled fields are not equal for {name}."
337 );
338
339 Ok(())
340 };
341
342 checker("CleanBuffer", &mut dst_buf[0], &packet)?;
343 checker("DirtyBuffer", &mut dst_buf[1], &packet)?;
344
345 let result = packet.marshal_to(&mut dst_buf[2]);
346 assert!(result.is_err());
347 if let Err(err) = result {
348 assert_eq!(Error::ErrBufferTooSmall, err);
349 }
350
351 Ok(())
352 }
353
test_rfc_8285_one_byte_multiple_extension() -> Result<()>354 fn test_rfc_8285_one_byte_multiple_extension() -> Result<()> {
355 // 0 1 2 3
356 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
357 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
358 // | 0xBE | 0xDE | length=3 |
359 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
360 // | ID=1 | L=0 | data | ID=2 | L=1 | data...
361 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
362 // ...data | ID=3 | L=3 | data...
363 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
364 // ...data |
365 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
366 let raw_pkt = &[
367 0x90u8, 0xe0, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, 0x1c, 0x64, 0x27, 0x82, 0xBE, 0xDE, 0x00,
368 0x03, 0x10, 0xAA, 0x21, 0xBB, 0xBB, 0x33, 0xCC, 0xCC, 0xCC, 0xCC, 0x00, 0x00,
369 // Payload
370 0x98, 0x36, 0xbe, 0x88, 0x9e,
371 ];
372
373 let p = Packet {
374 header: Header {
375 marker: true,
376 extension: true,
377 extension_profile: 0xBEDE,
378 extensions: vec![
379 Extension {
380 id: 1,
381 payload: Bytes::from_static(&[0xAA]),
382 },
383 Extension {
384 id: 2,
385 payload: Bytes::from_static(&[0xBB, 0xBB]),
386 },
387 Extension {
388 id: 3,
389 payload: Bytes::from_static(&[0xCC, 0xCC]),
390 },
391 ],
392 version: 2,
393 payload_type: 96,
394 sequence_number: 27023,
395 timestamp: 3653407706,
396 ssrc: 476325762,
397 ..Default::default()
398 },
399 payload: raw_pkt[28..].into(),
400 };
401
402 let dst_data = p.marshal()?;
403 assert_eq!(
404 &dst_data[..],
405 raw_pkt,
406 "Marshal failed raw \nMarshaled:\n{dst_data:?}\nrawPkt:\n{raw_pkt:?}",
407 );
408
409 Ok(())
410 }
411
test_rfc_8285_two_byte_extension() -> Result<()>412 fn test_rfc_8285_two_byte_extension() -> Result<()> {
413 let raw_pkt = Bytes::from_static(&[
414 0x90, 0xe0, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, 0x1c, 0x64, 0x27, 0x82, 0x10, 0x00, 0x00,
415 0x07, 0x05, 0x18, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
416 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x98,
417 0x36, 0xbe, 0x88, 0x9e,
418 ]);
419
420 let _ = Packet::unmarshal(&mut raw_pkt.clone())?;
421
422 let p = Packet {
423 header: Header {
424 marker: true,
425 extension: true,
426 extension_profile: 0x1000,
427 extensions: vec![Extension {
428 id: 5,
429 payload: Bytes::from_static(&[
430 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
431 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
432 ]),
433 }],
434 version: 2,
435 payload_type: 96,
436 sequence_number: 27023,
437 timestamp: 3653407706,
438 ssrc: 476325762,
439 ..Default::default()
440 },
441 payload: raw_pkt.slice(44..),
442 };
443
444 let dst_data = p.marshal()?;
445 assert_eq!(
446 dst_data, raw_pkt,
447 "Marshal failed raw \nMarshaled:\n{dst_data:?}\nrawPkt:\n{raw_pkt:?}"
448 );
449 Ok(())
450 }
451
test_rfc8285_two_byte_multiple_extension_with_padding() -> Result<()>452 fn test_rfc8285_two_byte_multiple_extension_with_padding() -> Result<()> {
453 // 0 1 2 3
454 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
455 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
456 // | 0x10 | 0x00 | length=3 |
457 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
458 // | ID=1 | L=0 | ID=2 | L=1 |
459 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
460 // | data | 0 (pad) | ID=3 | L=4 |
461 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
462 // | data |
463 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
464
465 let mut raw_pkt = Bytes::from_static(&[
466 0x90u8, 0xe0, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, 0x1c, 0x64, 0x27, 0x82, 0x10, 0x00, 0x00,
467 0x03, 0x01, 0x00, 0x02, 0x01, 0xBB, 0x00, 0x03, 0x04, 0xCC, 0xCC, 0xCC, 0xCC, 0x98, 0x36,
468 0xbe, 0x88, 0x9e,
469 ]);
470
471 let p = Packet::unmarshal(&mut raw_pkt)?;
472
473 let ext = p.header.get_extension(1);
474 let ext_expect = Some(Bytes::from_static(&[]));
475 assert_eq!(
476 ext, ext_expect,
477 "Extension has incorrect data. Got: {ext:?}, Expected: {ext_expect:?}"
478 );
479
480 let ext = p.header.get_extension(2);
481 let ext_expect = Some(Bytes::from_static(&[0xBB]));
482 assert_eq!(
483 ext, ext_expect,
484 "Extension has incorrect data. Got: {ext:?}, Expected: {ext_expect:?}"
485 );
486
487 let ext = p.header.get_extension(3);
488 let ext_expect = Some(Bytes::from_static(&[0xCC, 0xCC, 0xCC, 0xCC]));
489 assert_eq!(
490 ext, ext_expect,
491 "Extension has incorrect data. Got: {ext:?}, Expected: {ext_expect:?}"
492 );
493
494 Ok(())
495 }
496
test_rfc8285_two_byte_multiple_extension_with_large_extension() -> Result<()>497 fn test_rfc8285_two_byte_multiple_extension_with_large_extension() -> Result<()> {
498 // 0 1 2 3
499 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
500 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
501 // | 0x10 | 0x00 | length=3 |
502 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
503 // | ID=1 | L=0 | ID=2 | L=1 |
504 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
505 // | data | ID=3 | L=17 | data...
506 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
507 // ...data...
508 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
509 // ...data...
510 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
511 // ...data...
512 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
513 // ...data... |
514 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
515
516 let raw_pkt = Bytes::from_static(&[
517 0x90u8, 0xe0, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, 0x1c, 0x64, 0x27, 0x82, 0x10, 0x00, 0x00,
518 0x06, 0x01, 0x00, 0x02, 0x01, 0xBB, 0x03, 0x11, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC,
519 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, // Payload
520 0x98, 0x36, 0xbe, 0x88, 0x9e,
521 ]);
522
523 let p = Packet {
524 header: Header {
525 marker: true,
526 extension: true,
527 extension_profile: 0x1000,
528 extensions: vec![
529 Extension {
530 id: 1,
531 payload: Bytes::from_static(&[]),
532 },
533 Extension {
534 id: 2,
535 payload: Bytes::from_static(&[0xBB]),
536 },
537 Extension {
538 id: 3,
539 payload: Bytes::from_static(&[
540 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC,
541 0xCC, 0xCC, 0xCC, 0xCC, 0xCC,
542 ]),
543 },
544 ],
545 version: 2,
546 payload_type: 96,
547 sequence_number: 27023,
548 timestamp: 3653407706,
549 ssrc: 476325762,
550 ..Default::default()
551 },
552 payload: raw_pkt.slice(40..),
553 };
554
555 let dst_data = p.marshal()?;
556 assert_eq!(
557 dst_data,
558 raw_pkt[..],
559 "Marshal failed raw \nMarshaled: {dst_data:?}, \nraw_pkt:{raw_pkt:?}"
560 );
561
562 Ok(())
563 }
564
test_rfc8285_get_extension_returns_nil_when_extension_disabled() -> Result<()>565 fn test_rfc8285_get_extension_returns_nil_when_extension_disabled() -> Result<()> {
566 let payload = Bytes::from_static(&[
567 // Payload
568 0x98u8, 0x36, 0xbe, 0x88, 0x9e,
569 ]);
570
571 let p = Packet {
572 header: Header {
573 marker: true,
574 version: 2,
575 payload_type: 96,
576 sequence_number: 27023,
577 timestamp: 3653407706,
578 ssrc: 476325762,
579 ..Default::default()
580 },
581 payload,
582 ..Default::default()
583 };
584
585 let res = p.header.get_extension(1);
586 assert!(
587 res.is_none(),
588 "Should return none on get_extension when header extension is false"
589 );
590
591 Ok(())
592 }
593
test_rfc8285_del_extension() -> Result<()>594 fn test_rfc8285_del_extension() -> Result<()> {
595 let payload = Bytes::from_static(&[
596 // Payload
597 0x98u8, 0x36, 0xbe, 0x88, 0x9e,
598 ]);
599 let mut p = Packet {
600 header: Header {
601 marker: true,
602 extension: true,
603 extension_profile: 0xBEDE,
604 extensions: vec![Extension {
605 id: 1,
606 payload: Bytes::from_static(&[0xAA]),
607 }],
608 version: 2,
609 payload_type: 96,
610 sequence_number: 27023,
611 timestamp: 3653407706,
612 ssrc: 476325762,
613 ..Default::default()
614 },
615 payload,
616 ..Default::default()
617 };
618
619 let ext = p.header.get_extension(1);
620 assert!(ext.is_some(), "Extension should exist");
621
622 p.header.del_extension(1)?;
623
624 let ext = p.header.get_extension(1);
625 assert!(ext.is_none(), "Extension should not exist");
626
627 let err = p.header.del_extension(1);
628 assert!(
629 err.is_err(),
630 "Should return error when deleting extension that doesnt exist"
631 );
632
633 Ok(())
634 }
635
test_rfc8285_get_extension_ids()636 fn test_rfc8285_get_extension_ids() {
637 let payload = Bytes::from_static(&[0x98u8, 0x36, 0xbe, 0x88, 0x9e]);
638
639 let p = Packet {
640 header: Header {
641 marker: true,
642 extension: true,
643 extension_profile: 0xBEDE,
644 extensions: vec![
645 Extension {
646 id: 1,
647 payload: Bytes::from_static(&[0xAA]),
648 },
649 Extension {
650 id: 2,
651 payload: Bytes::from_static(&[0xBB]),
652 },
653 ],
654 version: 2,
655 payload_type: 96,
656 sequence_number: 27023,
657 timestamp: 3653407706,
658 ssrc: 476325762,
659 ..Default::default()
660 },
661 payload,
662 ..Default::default()
663 };
664
665 let ids = p.header.get_extension_ids();
666 assert!(!ids.is_empty(), "Extenstions should exist");
667
668 assert_eq!(
669 ids.len(),
670 p.header.extensions.len(),
671 "The number of IDs should be equal to the number of extensions, want={}, hanve{}",
672 ids.len(),
673 p.header.extensions.len()
674 );
675
676 for id in ids {
677 let ext = p.header.get_extension(id);
678 assert!(ext.is_some(), "Extension should exist for id: {id}")
679 }
680 }
681
test_rfc8285_get_extension_ids_return_empty_when_extension_disabled()682 fn test_rfc8285_get_extension_ids_return_empty_when_extension_disabled() {
683 let payload = Bytes::from_static(&[0x98u8, 0x36, 0xbe, 0x88, 0x9e]);
684
685 let p = Packet {
686 header: Header {
687 marker: true,
688 extension: false,
689 version: 2,
690 payload_type: 96,
691 sequence_number: 27023,
692 timestamp: 3653407706,
693 ssrc: 476325762,
694 ..Default::default()
695 },
696 payload,
697 ..Default::default()
698 };
699
700 let ids = p.header.get_extension_ids();
701 assert!(ids.is_empty(), "Extenstions should not exist");
702 }
703
test_rfc8285_del_extension_returns_error_when_extenstions_disabled()704 fn test_rfc8285_del_extension_returns_error_when_extenstions_disabled() {
705 let payload = Bytes::from_static(&[0x98u8, 0x36, 0xbe, 0x88, 0x9e]);
706
707 let mut p = Packet {
708 header: Header {
709 marker: true,
710 extension: false,
711 version: 2,
712 payload_type: 96,
713 sequence_number: 27023,
714 timestamp: 3653407706,
715 ssrc: 476325762,
716 ..Default::default()
717 },
718 payload,
719 ..Default::default()
720 };
721
722 let ids = p.header.del_extension(1);
723 assert!(
724 ids.is_err(),
725 "Should return error on del_extension when header extension field is false"
726 );
727 }
728
test_rfc8285_one_byte_set_extension_should_enable_extension_when_adding()729 fn test_rfc8285_one_byte_set_extension_should_enable_extension_when_adding() {
730 let payload = Bytes::from_static(&[0x98u8, 0x36, 0xbe, 0x88, 0x9e]);
731
732 let mut p = Packet {
733 header: Header {
734 marker: true,
735 extension: false,
736 version: 2,
737 payload_type: 96,
738 sequence_number: 27023,
739 timestamp: 3653407706,
740 ssrc: 476325762,
741 ..Default::default()
742 },
743 payload,
744 ..Default::default()
745 };
746
747 let extension = Bytes::from_static(&[0xAAu8, 0xAA]);
748 let result = p.header.set_extension(1, extension.clone());
749 assert!(result.is_ok(), "Error setting extension");
750
751 assert!(p.header.extension, "Extension should be set to true");
752 assert_eq!(
753 p.header.extension_profile, 0xBEDE,
754 "Extension profile should be set to 0xBEDE"
755 );
756 assert_eq!(
757 p.header.extensions.len(),
758 1,
759 "Extensions len should be set to 1"
760 );
761 assert_eq!(
762 p.header.get_extension(1),
763 Some(extension),
764 "Extension value is not set"
765 )
766 }
767
test_rfc8285_set_extension_should_set_correct_extension_profile_for_16_byte_extension()768 fn test_rfc8285_set_extension_should_set_correct_extension_profile_for_16_byte_extension() {
769 let payload = Bytes::from_static(&[0x98u8, 0x36, 0xbe, 0x88, 0x9e]);
770
771 let mut p = Packet {
772 header: Header {
773 marker: true,
774 extension: false,
775 version: 2,
776 payload_type: 96,
777 sequence_number: 27023,
778 timestamp: 3653407706,
779 ssrc: 476325762,
780 ..Default::default()
781 },
782 payload,
783 ..Default::default()
784 };
785
786 let extension = Bytes::from_static(&[
787 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
788 0xAA,
789 ]);
790
791 let res = p.header.set_extension(1, extension);
792 assert!(res.is_ok(), "Error setting extension");
793
794 assert_eq!(
795 p.header.extension_profile, 0xBEDE,
796 "Extension profile should be 0xBEDE"
797 );
798 }
799
test_rfc8285_set_extension_should_update_existing_extension() -> Result<()>800 fn test_rfc8285_set_extension_should_update_existing_extension() -> Result<()> {
801 let payload = Bytes::from_static(&[0x98u8, 0x36, 0xbe, 0x88, 0x9e]);
802
803 let mut p = Packet {
804 header: Header {
805 marker: true,
806 extension: true,
807 extension_profile: 0xBEDE,
808 extensions: vec![Extension {
809 id: 1,
810 payload: Bytes::from_static(&[0xAA]),
811 }],
812 version: 2,
813 payload_type: 96,
814 sequence_number: 27023,
815 timestamp: 3653407706,
816 ssrc: 476325762,
817 ..Default::default()
818 },
819 payload,
820 ..Default::default()
821 };
822
823 assert_eq!(
824 p.header.get_extension(1),
825 Some([0xAA][..].into()),
826 "Extension value not initialized properly"
827 );
828
829 let extension = Bytes::from_static(&[0xBBu8]);
830 p.header.set_extension(1, extension.clone())?;
831
832 assert_eq!(
833 p.header.get_extension(1),
834 Some(extension),
835 "Extension value was not set"
836 );
837
838 Ok(())
839 }
840
test_rfc8285_one_byte_set_extension_should_error_when_invalid_id_provided()841 fn test_rfc8285_one_byte_set_extension_should_error_when_invalid_id_provided() {
842 let payload = Bytes::from_static(&[0x98u8, 0x36, 0xbe, 0x88, 0x9e]);
843
844 let mut p = Packet {
845 header: Header {
846 marker: true,
847 extension: true,
848 extension_profile: 0xBEDE,
849 extensions: vec![Extension {
850 id: 1,
851 payload: Bytes::from_static(&[0xAA]),
852 }],
853 version: 2,
854 payload_type: 96,
855 sequence_number: 27023,
856 timestamp: 3653407706,
857 ssrc: 476325762,
858 ..Default::default()
859 },
860 payload,
861 ..Default::default()
862 };
863
864 assert!(
865 p.header
866 .set_extension(0, Bytes::from_static(&[0xBBu8]))
867 .is_err(),
868 "set_extension did not error on invalid id"
869 );
870 assert!(
871 p.header
872 .set_extension(15, Bytes::from_static(&[0xBBu8]))
873 .is_err(),
874 "set_extension did not error on invalid id"
875 );
876 }
877
test_rfc8285_one_byte_extension_terminate_processing_when_reserved_id_encountered() -> Result<()>878 fn test_rfc8285_one_byte_extension_terminate_processing_when_reserved_id_encountered() -> Result<()>
879 {
880 let reserved_id_pkt = Bytes::from_static(&[
881 0x90u8, 0xe0, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, 0x1c, 0x64, 0x27, 0x82, 0xBE, 0xDE, 0x00,
882 0x01, 0xF0, 0xAA, 0x98, 0x36, 0xbe, 0x88, 0x9e,
883 ]);
884
885 let p = Packet::unmarshal(&mut reserved_id_pkt.clone())?;
886
887 assert_eq!(
888 p.header.extensions.len(),
889 0,
890 "Extension should be empty for invalid ID"
891 );
892
893 let payload = reserved_id_pkt.slice(17..);
894 assert_eq!(p.payload, payload, "p.payload must be same as payload");
895
896 Ok(())
897 }
898
test_rfc8285_one_byte_set_extension_should_error_when_payload_too_large()899 fn test_rfc8285_one_byte_set_extension_should_error_when_payload_too_large() {
900 let payload = Bytes::from_static(&[0x98u8, 0x36, 0xbe, 0x88, 0x9e]);
901
902 let mut p = Packet {
903 header: Header {
904 marker: true,
905 extension: true,
906 extension_profile: 0xBEDE,
907 extensions: vec![Extension {
908 id: 1,
909 payload: Bytes::from_static(&[0xAAu8]),
910 }],
911 version: 2,
912 payload_type: 96,
913 sequence_number: 27023,
914 timestamp: 3653407706,
915 ssrc: 476325762,
916 ..Default::default()
917 },
918 payload,
919 ..Default::default()
920 };
921
922 let res = p.header.set_extension(
923 1,
924 Bytes::from_static(&[
925 0xBBu8, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
926 0xBB, 0xBB, 0xBB,
927 ]),
928 );
929
930 assert!(
931 res.is_err(),
932 "set_extension did not error on too large payload"
933 );
934 }
935
test_rfc8285_two_bytes_set_extension_should_enable_extension_when_adding() -> Result<()>936 fn test_rfc8285_two_bytes_set_extension_should_enable_extension_when_adding() -> Result<()> {
937 let payload = Bytes::from_static(&[0x98u8, 0x36, 0xbe, 0x88, 0x9e]);
938
939 let mut p = Packet {
940 header: Header {
941 marker: true,
942 extension: true,
943 extension_profile: 0xBEDE,
944 version: 2,
945 payload_type: 96,
946 sequence_number: 27023,
947 timestamp: 3653407706,
948 ssrc: 476325762,
949 ..Default::default()
950 },
951 payload,
952 ..Default::default()
953 };
954
955 let extension = Bytes::from_static(&[
956 0xAAu8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
957 0xAA, 0xAA,
958 ]);
959
960 p.header.set_extension(1, extension.clone())?;
961
962 assert!(p.header.extension, "Extension should be set to true");
963 assert_eq!(
964 p.header.extension_profile, 0x1000,
965 "Extension profile should be set to 0xBEDE"
966 );
967 assert_eq!(
968 p.header.extensions.len(),
969 1,
970 "Extensions should be set to 1"
971 );
972 assert_eq!(
973 p.header.get_extension(1),
974 Some(extension),
975 "Extension value is not set"
976 );
977
978 Ok(())
979 }
980
test_rfc8285_two_byte_set_extension_should_update_existing_extension() -> Result<()>981 fn test_rfc8285_two_byte_set_extension_should_update_existing_extension() -> Result<()> {
982 let payload = Bytes::from_static(&[0x98u8, 0x36, 0xbe, 0x88, 0x9e]);
983
984 let mut p = Packet {
985 header: Header {
986 marker: true,
987 extension: true,
988 extension_profile: 0x1000,
989 extensions: vec![Extension {
990 id: 1,
991 payload: Bytes::from_static(&[0xAA]),
992 }],
993 version: 2,
994 payload_type: 96,
995 sequence_number: 27023,
996 timestamp: 3653407706,
997 ssrc: 476325762,
998 ..Default::default()
999 },
1000 payload,
1001 ..Default::default()
1002 };
1003
1004 assert_eq!(
1005 p.header.get_extension(1),
1006 Some(Bytes::from_static(&[0xAA])),
1007 "Extension value not initialized properly"
1008 );
1009
1010 let extension = Bytes::from_static(&[
1011 0xBBu8, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1012 0xBB, 0xBB,
1013 ]);
1014
1015 p.header.set_extension(1, extension.clone())?;
1016
1017 assert_eq!(p.header.get_extension(1), Some(extension));
1018
1019 Ok(())
1020 }
1021
test_rfc8285_two_byte_set_extension_should_error_when_payload_too_large()1022 fn test_rfc8285_two_byte_set_extension_should_error_when_payload_too_large() {
1023 let payload = Bytes::from_static(&[0x98u8, 0x36, 0xbe, 0x88, 0x9e]);
1024
1025 let mut p = Packet {
1026 header: Header {
1027 marker: true,
1028 extension: true,
1029 extension_profile: 0xBEDE,
1030 extensions: vec![Extension {
1031 id: 1,
1032 payload: Bytes::from_static(&[0xAA]),
1033 }],
1034 version: 2,
1035 payload_type: 96,
1036 sequence_number: 27023,
1037 timestamp: 3653407706,
1038 ssrc: 476325762,
1039 ..Default::default()
1040 },
1041 payload,
1042 ..Default::default()
1043 };
1044
1045 let res = p.header.set_extension(
1046 1,
1047 Bytes::from_static(&[
1048 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1049 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1050 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1051 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1052 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1053 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1054 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1055 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1056 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1057 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1058 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1059 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1060 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1061 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1062 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1063 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1064 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1065 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB,
1066 0xBB, 0xBB, 0xBB, 0xBB,
1067 ]),
1068 );
1069
1070 assert!(
1071 res.is_err(),
1072 "Set extension did not error on too large payload"
1073 );
1074 }
1075
test_rfc3550_set_extension_should_error_when_non_zero() -> Result<()>1076 fn test_rfc3550_set_extension_should_error_when_non_zero() -> Result<()> {
1077 let payload = Bytes::from_static(&[0x98u8, 0x36, 0xbe, 0x88, 0x9e]);
1078
1079 let mut p = Packet {
1080 header: Header {
1081 marker: true,
1082 extension: true,
1083 extension_profile: 0x1111,
1084 extensions: vec![Extension {
1085 id: 1,
1086 payload: Bytes::from_static(&[0xAA]),
1087 }],
1088 version: 2,
1089 payload_type: 96,
1090 sequence_number: 27023,
1091 timestamp: 3653407706,
1092 ssrc: 476325762,
1093 ..Default::default()
1094 },
1095 payload,
1096 ..Default::default()
1097 };
1098
1099 p.header.set_extension(0, Bytes::from_static(&[0xBB]))?;
1100 let res = p.header.get_extension(0);
1101 assert_eq!(
1102 res,
1103 Some(Bytes::from_static(&[0xBB])),
1104 "p.get_extenstion returned incorrect value"
1105 );
1106
1107 Ok(())
1108 }
1109
test_rfc3550_set_extension_should_error_when_setting_non_zero_id()1110 fn test_rfc3550_set_extension_should_error_when_setting_non_zero_id() {
1111 let payload = Bytes::from_static(&[0x98u8, 0x36, 0xbe, 0x88, 0x9e]);
1112
1113 let mut p = Packet {
1114 header: Header {
1115 marker: true,
1116 extension: true,
1117 extension_profile: 0x1111,
1118 version: 2,
1119 payload_type: 96,
1120 sequence_number: 27023,
1121 timestamp: 3653407706,
1122 ssrc: 476325762,
1123 ..Default::default()
1124 },
1125 payload,
1126 ..Default::default()
1127 };
1128
1129 let res = p.header.set_extension(1, Bytes::from_static(&[0xBB]));
1130 assert!(res.is_err(), "set_extension did not error on invalid id");
1131 }
1132
1133 use std::collections::HashMap;
1134
1135 struct Cases {
1136 input: Bytes,
1137 err: Error,
1138 }
1139
test_unmarshal_error_handling()1140 fn test_unmarshal_error_handling() {
1141 let mut cases = HashMap::new();
1142
1143 cases.insert(
1144 "ShortHeader",
1145 Cases {
1146 input: Bytes::from_static(&[
1147 0x80, 0xe0, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, // timestamp
1148 0x1c, 0x64, 0x27, // SSRC (one byte missing)
1149 ]),
1150 err: Error::ErrHeaderSizeInsufficient,
1151 },
1152 );
1153
1154 cases.insert(
1155 "MissingCSRC",
1156 Cases {
1157 input: Bytes::from_static(&[
1158 0x81, 0xe0, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, // timestamp
1159 0x1c, 0x64, 0x27, 0x82, // SSRC
1160 ]),
1161 err: Error::ErrHeaderSizeInsufficient,
1162 },
1163 );
1164
1165 cases.insert(
1166 "MissingExtension",
1167 Cases {
1168 input: Bytes::from_static(&[
1169 0x90, 0xe0, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, // timestamp
1170 0x1c, 0x64, 0x27, 0x82, // SSRC
1171 ]),
1172 err: Error::ErrHeaderSizeInsufficientForExtension,
1173 },
1174 );
1175
1176 cases.insert(
1177 "MissingExtensionData",
1178 Cases {
1179 input: Bytes::from_static(&[
1180 0x90, 0xe0, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, // timestamp
1181 0x1c, 0x64, 0x27, 0x82, // SSRC
1182 0xBE, 0xDE, 0x00, 0x03, // specified to have 3 extensions, but actually not
1183 ]),
1184 err: Error::ErrHeaderSizeInsufficientForExtension,
1185 },
1186 );
1187
1188 cases.insert(
1189 "MissingExtensionDataPayload",
1190 Cases {
1191 input: Bytes::from_static(&[
1192 0x90, 0xe0, 0x69, 0x8f, 0xd9, 0xc2, 0x93, 0xda, // timestamp
1193 0x1c, 0x64, 0x27, 0x82, // SSRC
1194 0xBE, 0xDE, 0x00, 0x01, // have 1 extension
1195 0x12,
1196 0x00, // length of the payload is expected to be 3, but actually have only 1
1197 ]),
1198 err: Error::ErrHeaderSizeInsufficientForExtension,
1199 },
1200 );
1201
1202 for (name, mut test_case) in cases.drain() {
1203 let result = Header::unmarshal(&mut test_case.input);
1204 let err = result.err().unwrap();
1205 assert_eq!(
1206 test_case.err, err,
1207 "Expected :{:?}, found: {:?} for testcase {}",
1208 test_case.err, err, name
1209 )
1210 }
1211 }
1212
test_round_trip() -> Result<()>1213 fn test_round_trip() -> Result<()> {
1214 let raw_pkt = Bytes::from_static(&[
1215 0x00u8, 0x10, 0x23, 0x45, 0x12, 0x34, 0x45, 0x67, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11, 0x22,
1216 0x33, 0x44, 0x55, 0x66, 0x77,
1217 ]);
1218
1219 let payload = raw_pkt.slice(12..);
1220
1221 let p = Packet::unmarshal(&mut raw_pkt.clone())?;
1222
1223 assert_eq!(
1224 payload, p.payload,
1225 "p.payload must be same as payload.\n p.payload: {:?},\nraw_pkt: {:?}",
1226 p.payload, payload
1227 );
1228
1229 let buf = p.marshal()?;
1230
1231 assert_eq!(
1232 raw_pkt, buf,
1233 "buf must be the same as raw_pkt. \n buf: {buf:?},\nraw_pkt: {raw_pkt:?}",
1234 );
1235 assert_eq!(
1236 payload, p.payload,
1237 "p.payload must be the same as payload. \n payload: {:?},\np.payload: {:?}",
1238 payload, p.payload,
1239 );
1240
1241 Ok(())
1242 }
1243