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