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