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] 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] 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] 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] 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] 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] 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] 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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