Use new format constructors

See https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/merge_requests/1128

1 files changed, 133 insertions, 162 deletions

diff --git a/utils/togglerecord/tests/tests.rs b/utils/togglerecord/tests/tests.rs
index cc891f54..8e16990d 100644
--- a/utils/togglerecord/tests/tests.rs
+++ b/utils/togglerecord/tests/tests.rs
@@ -143,8 +143,8 @@ fn setup_sender_receiver(
                         let mut buffer = buffer.clone();
                         {
                             let buffer = buffer.make_mut();
-                            buffer.set_pts(offset + i * 20 * gst::ClockTime::MSECOND);
-                            buffer.set_duration(20 * gst::ClockTime::MSECOND);
+                            buffer.set_pts(offset + i * 20.mseconds());
+                            buffer.set_duration(20.mseconds());
                         }
                         let _ = sinkpad.chain(buffer);
                         i += 1;
@@ -156,11 +156,8 @@ fn setup_sender_receiver(
                         buffer
                             .get_mut()
                             .unwrap()
-                            .set_pts(offset + i * 20 * gst::ClockTime::MSECOND);
-                        buffer
-                            .get_mut()
-                            .unwrap()
-                            .set_duration(20 * gst::ClockTime::MSECOND);
+                            .set_pts(offset + i * 20.mseconds());
+                        buffer.get_mut().unwrap().set_duration(20.mseconds());
                         buffer
                             .get_mut()
                             .unwrap()
@@ -171,10 +168,7 @@ fn setup_sender_receiver(
                 }
                 SendData::Gaps(n) => {
                     for _ in 0..n {
-                        let event = gst::event::Gap::new(
-                            offset + i * 20 * gst::ClockTime::MSECOND,
-                            20 * gst::ClockTime::MSECOND,
-                        );
+                        let event = gst::event::Gap::new(offset + i * 20.mseconds(), 20.mseconds());
                         let _ = sinkpad.send_event(event);
                         i += 1;
                     }
@@ -297,9 +291,9 @@ fn test_one_stream_open() {
     assert_eq!(buffers.len(), 10);
     for (index, &(running_time, pts, duration)) in buffers.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
 
     thread.join().unwrap();
@@ -330,9 +324,9 @@ fn test_one_stream_gaps_open() {
     assert_eq!(buffers.len(), 10);
     for (index, &(running_time, pts, duration)) in buffers.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
 
     thread.join().unwrap();
@@ -364,9 +358,9 @@ fn test_one_stream_close_open() {
     assert_eq!(buffers.len(), 10);
     for (index, &(running_time, pts, duration)) in buffers.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), (10 + index) * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), (10 + index) * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
 
     thread.join().unwrap();
@@ -399,9 +393,9 @@ fn test_one_stream_open_close() {
     assert_eq!(buffers.len(), 10);
     for (index, &(running_time, pts, duration)) in buffers.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
 
     thread.join().unwrap();
@@ -437,15 +431,15 @@ fn test_one_stream_open_close_open() {
     assert_eq!(buffers.len(), 20);
     for (index, &(running_time, pts, duration)) in buffers.iter().enumerate() {
         let pts_off = if index >= 10 {
-            10 * 20 * gst::ClockTime::MSECOND
+            10 * 20.mseconds()
         } else {
             gst::ClockTime::ZERO
         };
 
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), pts_off + index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), pts_off + index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
 
     thread.join().unwrap();
@@ -483,9 +477,9 @@ fn test_two_stream_open() {
     let (buffers_1, _) = recv_buffers(&receiver_output_1, &mut segment_1, 0);
     for (index, &(running_time, pts, duration)) in buffers_1.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_1.len(), 10);
 
@@ -494,9 +488,9 @@ fn test_two_stream_open() {
     let (buffers_2, _) = recv_buffers(&receiver_output_2, &mut segment_2, 0);
     for (index, &(running_time, pts, duration)) in buffers_2.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_2.len(), 10);
 
@@ -517,12 +511,7 @@ fn test_two_stream_open_shift() {
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
         setup_sender_receiver(&pipeline, &togglerecord, "src", gst::ClockTime::ZERO);
     let (sender_input_2, receiver_input_done_2, receiver_output_2, thread_2) =
-        setup_sender_receiver(
-            &pipeline,
-            &togglerecord,
-            "src_%u",
-            5 * gst::ClockTime::MSECOND,
-        );
+        setup_sender_receiver(&pipeline, &togglerecord, "src_%u", 5.mseconds());
 
     pipeline.set_state(gst::State::Playing).unwrap();
 
@@ -541,9 +530,9 @@ fn test_two_stream_open_shift() {
     let (buffers_1, _) = recv_buffers(&receiver_output_1, &mut segment_1, 0);
     for (index, &(running_time, pts, duration)) in buffers_1.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_1.len(), 10);
 
@@ -552,18 +541,12 @@ fn test_two_stream_open_shift() {
     let (buffers_2, _) = recv_buffers(&receiver_output_2, &mut segment_2, 0);
     for (index, &(running_time, pts, duration)) in buffers_2.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(
-            running_time.unwrap(),
-            5 * gst::ClockTime::MSECOND + index * 20 * gst::ClockTime::MSECOND
-        );
-        assert_eq!(
-            pts.unwrap(),
-            5 * gst::ClockTime::MSECOND + index * 20 * gst::ClockTime::MSECOND
-        );
+        assert_eq!(running_time.unwrap(), 5.mseconds() + index * 20.mseconds());
+        assert_eq!(pts.unwrap(), 5.mseconds() + index * 20.mseconds());
         if index == 9 {
-            assert_eq!(duration.unwrap(), 15 * gst::ClockTime::MSECOND);
+            assert_eq!(duration.unwrap(), 15.mseconds());
         } else {
-            assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+            assert_eq!(duration.unwrap(), 20.mseconds());
         }
     }
     assert_eq!(buffers_2.len(), 10);
@@ -583,7 +566,7 @@ fn test_two_stream_open_shift_main() {
     pipeline.add(&togglerecord).unwrap();
 
     let (sender_input_1, receiver_input_done_1, receiver_output_1, thread_1) =
-        setup_sender_receiver(&pipeline, &togglerecord, "src", 5 * gst::ClockTime::MSECOND);
+        setup_sender_receiver(&pipeline, &togglerecord, "src", 5.mseconds());
     let (sender_input_2, receiver_input_done_2, receiver_output_2, thread_2) =
         setup_sender_receiver(&pipeline, &togglerecord, "src_%u", gst::ClockTime::ZERO);
 
@@ -605,12 +588,9 @@ fn test_two_stream_open_shift_main() {
     let (buffers_1, _) = recv_buffers(&receiver_output_1, &mut segment_1, 0);
     for (index, &(running_time, pts, duration)) in buffers_1.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(
-            pts.unwrap(),
-            5 * gst::ClockTime::MSECOND + index * 20 * gst::ClockTime::MSECOND
-        );
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), 5.mseconds() + index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_1.len(), 10);
 
@@ -621,26 +601,17 @@ fn test_two_stream_open_shift_main() {
     for (index, &(running_time, pts, duration)) in buffers_2.iter().enumerate() {
         let index = index as u64;
         if index == 0 {
-            assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-            assert_eq!(
-                pts.unwrap(),
-                5 * gst::ClockTime::MSECOND + index * 20 * gst::ClockTime::MSECOND
-            );
-            assert_eq!(duration.unwrap(), 15 * gst::ClockTime::MSECOND);
+            assert_eq!(running_time.unwrap(), index * 20.mseconds());
+            assert_eq!(pts.unwrap(), 5.mseconds() + index * 20.mseconds());
+            assert_eq!(duration.unwrap(), 15.mseconds());
         } else if index == 10 {
-            assert_eq!(
-                running_time.unwrap(),
-                index * 20 * gst::ClockTime::MSECOND - 5 * gst::ClockTime::MSECOND
-            );
-            assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-            assert_eq!(duration.unwrap(), 5 * gst::ClockTime::MSECOND);
+            assert_eq!(running_time.unwrap(), index * 20.mseconds() - 5.mseconds());
+            assert_eq!(pts.unwrap(), index * 20.mseconds());
+            assert_eq!(duration.unwrap(), 5.mseconds());
         } else {
-            assert_eq!(
-                running_time.unwrap(),
-                index * 20 * gst::ClockTime::MSECOND - 5 * gst::ClockTime::MSECOND
-            );
-            assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-            assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+            assert_eq!(running_time.unwrap(), index * 20.mseconds() - 5.mseconds());
+            assert_eq!(pts.unwrap(), index * 20.mseconds());
+            assert_eq!(duration.unwrap(), 20.mseconds());
         }
     }
     assert_eq!(buffers_2.len(), 11);
@@ -697,9 +668,9 @@ fn test_two_stream_open_close() {
     let (buffers_1, _) = recv_buffers(&receiver_output_1, &mut segment_1, 0);
     for (index, &(running_time, pts, duration)) in buffers_1.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_1.len(), 10);
 
@@ -708,9 +679,9 @@ fn test_two_stream_open_close() {
     let (buffers_2, _) = recv_buffers(&receiver_output_2, &mut segment_2, 0);
     for (index, &(running_time, pts, duration)) in buffers_2.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_2.len(), 10);
 
@@ -766,9 +737,9 @@ fn test_two_stream_close_open() {
     let (buffers_1, _) = recv_buffers(&receiver_output_1, &mut segment_1, 0);
     for (index, &(running_time, pts, duration)) in buffers_1.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), (10 + index) * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), (10 + index) * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_1.len(), 10);
 
@@ -777,9 +748,9 @@ fn test_two_stream_close_open() {
     let (buffers_2, _) = recv_buffers(&receiver_output_2, &mut segment_2, 0);
     for (index, &(running_time, pts, duration)) in buffers_2.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), (10 + index) * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), (10 + index) * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_2.len(), 10);
 
@@ -848,15 +819,15 @@ fn test_two_stream_open_close_open() {
     let (buffers_1, _) = recv_buffers(&receiver_output_1, &mut segment_1, 0);
     for (index, &(running_time, pts, duration)) in buffers_1.iter().enumerate() {
         let pts_off = if index >= 10 {
-            10 * 20 * gst::ClockTime::MSECOND
+            10 * 20.mseconds()
         } else {
             gst::ClockTime::ZERO
         };
 
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), pts_off + index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), pts_off + index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_1.len(), 20);
 
@@ -865,15 +836,15 @@ fn test_two_stream_open_close_open() {
     let (buffers_2, _) = recv_buffers(&receiver_output_2, &mut segment_2, 0);
     for (index, &(running_time, pts, duration)) in buffers_2.iter().enumerate() {
         let pts_off = if index >= 10 {
-            10 * 20 * gst::ClockTime::MSECOND
+            10 * 20.mseconds()
         } else {
             gst::ClockTime::ZERO
         };
 
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), pts_off + index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), pts_off + index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_2.len(), 20);
 
@@ -948,15 +919,15 @@ fn test_two_stream_open_close_open_gaps() {
     let (buffers_1, _) = recv_buffers(&receiver_output_1, &mut segment_1, 0);
     for (index, &(running_time, pts, duration)) in buffers_1.iter().enumerate() {
         let pts_off = if index >= 10 {
-            10 * 20 * gst::ClockTime::MSECOND
+            10 * 20.mseconds()
         } else {
             gst::ClockTime::ZERO
         };
 
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), pts_off + index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), pts_off + index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_1.len(), 20);
 
@@ -965,15 +936,15 @@ fn test_two_stream_open_close_open_gaps() {
     let (buffers_2, _) = recv_buffers(&receiver_output_2, &mut segment_2, 0);
     for (index, &(running_time, pts, duration)) in buffers_2.iter().enumerate() {
         let pts_off = if index >= 10 {
-            10 * 20 * gst::ClockTime::MSECOND
+            10 * 20.mseconds()
         } else {
             gst::ClockTime::ZERO
         };
 
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), pts_off + index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), pts_off + index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_2.len(), 20);
 
@@ -1049,9 +1020,9 @@ fn test_two_stream_close_open_close_delta() {
     let (buffers_1, _) = recv_buffers(&receiver_output_1, &mut segment_1, 0);
     for (index, &(running_time, pts, duration)) in buffers_1.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), (11 + index) * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), (11 + index) * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_1.len(), 10);
 
@@ -1060,9 +1031,9 @@ fn test_two_stream_close_open_close_delta() {
     let (buffers_2, _) = recv_buffers(&receiver_output_2, &mut segment_2, 0);
     for (index, &(running_time, pts, duration)) in buffers_2.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), (11 + index) * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), (11 + index) * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_2.len(), 10);
 
@@ -1144,15 +1115,15 @@ fn test_three_stream_open_close_open() {
     let (buffers_1, _) = recv_buffers(&receiver_output_1, &mut segment_1, 0);
     for (index, &(running_time, pts, duration)) in buffers_1.iter().enumerate() {
         let pts_off = if index >= 10 {
-            10 * 20 * gst::ClockTime::MSECOND
+            10 * 20.mseconds()
         } else {
             gst::ClockTime::ZERO
         };
 
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), pts_off + index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), pts_off + index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_1.len(), 20);
 
@@ -1161,15 +1132,15 @@ fn test_three_stream_open_close_open() {
     let (buffers_2, _) = recv_buffers(&receiver_output_2, &mut segment_2, 0);
     for (index, &(running_time, pts, duration)) in buffers_2.iter().enumerate() {
         let pts_off = if index >= 10 {
-            10 * 20 * gst::ClockTime::MSECOND
+            10 * 20.mseconds()
         } else {
             gst::ClockTime::ZERO
         };
 
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), pts_off + index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), pts_off + index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_2.len(), 20);
 
@@ -1177,15 +1148,15 @@ fn test_three_stream_open_close_open() {
     let (buffers_3, _) = recv_buffers(&receiver_output_3, &mut segment_3, 0);
     for (index, &(running_time, pts, duration)) in buffers_3.iter().enumerate() {
         let pts_off = if index >= 10 {
-            10 * 20 * gst::ClockTime::MSECOND
+            10 * 20.mseconds()
         } else {
             gst::ClockTime::ZERO
         };
 
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), pts_off + index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), pts_off + index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_3.len(), 20);
 
@@ -1246,9 +1217,9 @@ fn test_two_stream_main_eos() {
     let (buffers_1, saw_eos) = recv_buffers(&receiver_output_1, &mut segment_1, 0);
     for (index, &(running_time, pts, duration)) in buffers_1.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_1.len(), 10);
     assert!(saw_eos);
@@ -1258,9 +1229,9 @@ fn test_two_stream_main_eos() {
     let (buffers_2, saw_eos) = recv_buffers(&receiver_output_2, &mut segment_2, 0);
     for (index, &(running_time, pts, duration)) in buffers_2.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_2.len(), 10);
     assert!(saw_eos);
@@ -1313,9 +1284,9 @@ fn test_two_stream_secondary_eos_first() {
     let (buffers_1, saw_eos) = recv_buffers(&receiver_output_1, &mut segment_1, 0);
     for (index, &(running_time, pts, duration)) in buffers_1.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_1.len(), 10);
     assert!(saw_eos);
@@ -1326,9 +1297,9 @@ fn test_two_stream_secondary_eos_first() {
     let (buffers_2, saw_eos) = recv_buffers(&receiver_output_2, &mut segment_2, 0);
     for (index, &(running_time, pts, duration)) in buffers_2.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_2.len(), 9);
     assert!(saw_eos);
@@ -1403,9 +1374,9 @@ fn test_three_stream_main_eos() {
     let (buffers_1, saw_eos) = recv_buffers(&receiver_output_1, &mut segment_1, 0);
     for (index, &(running_time, pts, duration)) in buffers_1.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_1.len(), 10);
     assert!(saw_eos);
@@ -1415,9 +1386,9 @@ fn test_three_stream_main_eos() {
     let (buffers_2, saw_eos) = recv_buffers(&receiver_output_2, &mut segment_2, 0);
     for (index, &(running_time, pts, duration)) in buffers_2.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_2.len(), 10);
     assert!(saw_eos);
@@ -1426,9 +1397,9 @@ fn test_three_stream_main_eos() {
     let (buffers_3, saw_eos) = recv_buffers(&receiver_output_3, &mut segment_3, 0);
     for (index, &(running_time, pts, duration)) in buffers_3.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_3.len(), 10);
     assert!(saw_eos);
@@ -1503,9 +1474,9 @@ fn test_three_stream_main_and_second_eos() {
     let (buffers_1, saw_eos) = recv_buffers(&receiver_output_1, &mut segment_1, 0);
     for (index, &(running_time, pts, duration)) in buffers_1.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_1.len(), 10);
     assert!(saw_eos);
@@ -1515,9 +1486,9 @@ fn test_three_stream_main_and_second_eos() {
     let (buffers_2, saw_eos) = recv_buffers(&receiver_output_2, &mut segment_2, 0);
     for (index, &(running_time, pts, duration)) in buffers_2.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_2.len(), 9);
     assert!(saw_eos);
@@ -1527,9 +1498,9 @@ fn test_three_stream_main_and_second_eos() {
     let (buffers_3, saw_eos) = recv_buffers(&receiver_output_3, &mut segment_3, 0);
     for (index, &(running_time, pts, duration)) in buffers_3.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_3.len(), 10);
     assert!(saw_eos);
@@ -1590,9 +1561,9 @@ fn test_three_stream_secondary_eos_first() {
     let (buffers_1, saw_eos) = recv_buffers(&receiver_output_1, &mut segment_1, 0);
     for (index, &(running_time, pts, duration)) in buffers_1.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_1.len(), 10);
     assert!(saw_eos);
@@ -1602,9 +1573,9 @@ fn test_three_stream_secondary_eos_first() {
     let (buffers_2, saw_eos) = recv_buffers(&receiver_output_2, &mut segment_2, 0);
     for (index, &(running_time, pts, duration)) in buffers_2.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_2.len(), 9);
     assert!(saw_eos);
@@ -1613,9 +1584,9 @@ fn test_three_stream_secondary_eos_first() {
     let (buffers_3, saw_eos) = recv_buffers(&receiver_output_3, &mut segment_3, 0);
     for (index, &(running_time, pts, duration)) in buffers_3.iter().enumerate() {
         let index = index as u64;
-        assert_eq!(running_time.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(pts.unwrap(), index * 20 * gst::ClockTime::MSECOND);
-        assert_eq!(duration.unwrap(), 20 * gst::ClockTime::MSECOND);
+        assert_eq!(running_time.unwrap(), index * 20.mseconds());
+        assert_eq!(pts.unwrap(), index * 20.mseconds());
+        assert_eq!(duration.unwrap(), 20.mseconds());
     }
     assert_eq!(buffers_3.len(), 9);
     assert!(saw_eos);