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