Evaluates the Timer::new() againts different clock types.

Signed-off-by: Agustin Alba Chicar <[email protected]>

Author: agalbachicar

rclrs/src/clock.rs

@@ -28,6 +28,7 @@ impl From<ClockType> for rcl_clock_type_t {
 #[derive(Clone, Debug)]
 pub struct Clock {
     kind: ClockType,
+    // TODO(ekumen): Fix the extra pub here.
     pub rcl_clock: Arc<Mutex<rcl_clock_t>>,
     // TODO(luca) Implement jump callbacks
 }

rclrs/src/timer.rs

@@ -16,8 +16,7 @@ unsafe extern "C" fn timer_callback(_: *mut rcl_timer_t, time_since_last_callbac
 impl Timer {
     pub fn new(clock: &Clock, context: &Context, period: i64) -> Result<Timer, RclrsError> {
         let mut rcl_timer;
-        let timer_init_result;
-        unsafe {
+        let timer_init_result = unsafe {
             // SAFETY: Getting a default value is always safe.
             rcl_timer = rcl_get_zero_initialized_timer();
             let allocator = rcutils_get_default_allocator();
@@ -26,22 +25,36 @@ impl Timer {
             let callback: rcl_timer_callback_t = Some(timer_callback);
             // Function will return Err(_) only if there isn't enough memory to allocate a clock
             // object.
-            timer_init_result = rcl_timer_init(
+            rcl_timer_init(
                 &mut rcl_timer,
                 &mut *rcl_clock,
                 &mut *rcl_context,
                 period,
                 callback,
                 allocator,
-            );
-        }        
+            )
+        };
         to_rclrs_result(timer_init_result).map(|_| {
             Timer {
                 rcl_timer: Arc::new(Mutex::new(rcl_timer))
             }
         })
     }
 
+    pub fn time_since_last_call(&self) -> Result<i64, RclrsError> {
+        let mut time_value_ns: i64 = 0;
+        let time_since_last_call_result = unsafe {
+            let rcl_timer = self.rcl_timer.lock().unwrap();
+            rcl_timer_get_time_since_last_call(
+                &* rcl_timer,
+                &mut time_value_ns
+            )
+        };
+        to_rclrs_result(time_since_last_call_result).map(|_| {
+            time_value_ns
+        })
+    }
+
     // handle() -> RCLC Timer Type
 
     // destroy() -> None 
@@ -89,4 +102,43 @@ mod tests {
         assert_send::<Timer>();
         assert_sync::<Timer>();
     }
+
+    #[test]
+    fn test_new_with_system_clock() {
+        let clock = Clock::system();
+        let context = Context::new(vec![]).unwrap();
+        let period: i64 = 1000000000;  // 1000 milliseconds.
+
+        let dut = Timer::new(&clock, &context, period);
+        assert!(dut.is_ok());
+    }
+
+    #[test]
+    fn test_new_with_steady_clock() {
+        let clock = Clock::steady();
+        let context = Context::new(vec![]).unwrap();
+        let period: i64 = 1000000000;  // 1000 milliseconds.
+
+        let dut = Timer::new(&clock, &context, period);
+        assert!(dut.is_ok());
+    }
+
+    #[ignore = "SIGSEGV when creating the timer with Clock::with_source()."]
+    #[test]
+    fn test_new_with_source_clock() {
+        let (clock, source) = Clock::with_source();
+        // No manual time set, it should default to 0
+        assert!(clock.now().nsec == 0);
+        let set_time = 1234i64;
+        source.set_ros_time_override(set_time);
+        // Ros time is set, should return the value that was set
+        assert_eq!(clock.now().nsec, set_time);
+
+
+        let context = Context::new(vec![]).unwrap();
+        let period: i64 = 1000000000;  // 1000 milliseconds.
+
+        let dut = Timer::new(&clock, &context, period);
+        assert!(dut.is_ok());
+    }
 }