1 use super::*;
2 use crate::codecs::*;
3 use crate::error::Result;
4 
5 use chrono::prelude::*;
6 use std::time::{Duration, UNIX_EPOCH};
7 
8 #[tokio::test]
9 async fn test_packetizer() -> Result<()> {
10     let multiple_payload = Bytes::from_static(&[0; 128]);
11     let g722 = Box::new(g7xx::G722Payloader {});
12     let seq = Box::new(new_random_sequencer());
13 
14     //use the G722 payloader here, because it's very simple and all 0s is valid G722 data.
15     let mut packetizer = new_packetizer(100, 98, 0x1234ABCD, g722, seq, 90000);
16     let packets = packetizer.packetize(&multiple_payload, 2000).await?;
17 
18     if packets.len() != 2 {
19         let mut packet_lengths = String::new();
20         #[allow(clippy::needless_range_loop)]
21         for i in 0..packets.len() {
22             packet_lengths +=
23                 format!("Packet {} length {}\n", i, packets[i].payload.len()).as_str();
24         }
25         panic!(
26             "Generated {} packets instead of 2\n{}",
27             packets.len(),
28             packet_lengths,
29         );
30     }
31     Ok(())
32 }
33 
34 #[tokio::test]
35 async fn test_packetizer_abs_send_time() -> Result<()> {
36     let g722 = Box::new(g7xx::G722Payloader {});
37     let sequencer = Box::new(new_fixed_sequencer(1234));
38 
39     let time_gen: Option<FnTimeGen> = Some(Arc::new(
40         || -> Pin<Box<dyn Future<Output = SystemTime> + Send + 'static>> {
41             Box::pin(async move {
42                 let loc = FixedOffset::west_opt(5 * 60 * 60).unwrap(); // UTC-5
43                 let t = loc.with_ymd_and_hms(1985, 6, 23, 4, 0, 0).unwrap();
44                 UNIX_EPOCH
45                     .checked_add(Duration::from_nanos(t.timestamp_nanos() as u64))
46                     .unwrap_or(UNIX_EPOCH)
47             })
48         },
49     ));
50 
51     //use the G722 payloader here, because it's very simple and all 0s is valid G722 data.
52     let mut pktizer = PacketizerImpl {
53         mtu: 100,
54         payload_type: 98,
55         ssrc: 0x1234ABCD,
56         payloader: g722,
57         sequencer,
58         timestamp: 45678,
59         clock_rate: 90000,
60         abs_send_time: 0,
61         time_gen,
62     };
63     pktizer.enable_abs_send_time(1);
64 
65     let payload = Bytes::from_static(&[0x11, 0x12, 0x13, 0x14]);
66     let packets = pktizer.packetize(&payload, 2000).await?;
67 
68     let expected = Packet {
69         header: Header {
70             version: 2,
71             padding: false,
72             extension: true,
73             marker: true,
74             payload_type: 98,
75             sequence_number: 1234,
76             timestamp: 45678,
77             ssrc: 0x1234ABCD,
78             csrc: vec![],
79             extension_profile: 0xBEDE,
80             extensions: vec![Extension {
81                 id: 1,
82                 payload: Bytes::from_static(&[0x40, 0, 0]),
83             }],
84         },
85         payload: Bytes::from_static(&[0x11, 0x12, 0x13, 0x14]),
86     };
87 
88     if packets.len() != 1 {
89         panic!("Generated {} packets instead of 1", packets.len())
90     }
91 
92     assert_eq!(packets[0], expected);
93 
94     Ok(())
95 }
96 
97 #[tokio::test]
98 async fn test_packetizer_timestamp_rollover_does_not_panic() -> Result<()> {
99     let g722 = Box::new(g7xx::G722Payloader {});
100     let seq = Box::new(new_random_sequencer());
101 
102     let payload = Bytes::from_static(&[0; 128]);
103     let mut packetizer = new_packetizer(100, 98, 0x1234ABCD, g722, seq, 90000);
104 
105     packetizer.packetize(&payload, 10).await?;
106 
107     packetizer.packetize(&payload, u32::MAX).await?;
108 
109     packetizer.skip_samples(u32::MAX);
110 
111     Ok(())
112 }
113