* Added unit test to confirm a timer will trigger the waitset.

Author: imdexsam

rclrs/src/node.rs

@@ -356,7 +356,7 @@ impl Node {
     where
         F: Fn(&mut Timer) + 'static + Send + Sync,
     {
-        let timer = Arc::new(Mutex::new(Timer::new(
+        let timer = Arc::new(Mutex::new(Timer::new_with_context_handle(
             Arc::clone(&self.handle.context_handle),
             self.get_clock(),
             period,

rclrs/src/timer.rs

@@ -7,7 +7,7 @@ use crate::{
         rcl_timer_is_canceled, rcl_timer_is_ready, rcl_timer_reset, rcl_timer_t,
         rcutils_get_default_allocator,
     },
-    ContextHandle, RclReturnCode, RclrsError, ToResult, ENTITY_LIFECYCLE_MUTEX,
+    Context, ContextHandle, RclReturnCode, RclrsError, ToResult, ENTITY_LIFECYCLE_MUTEX,
 };
 use std::{
     i64,
@@ -80,7 +80,20 @@ pub struct Timer {
 impl Timer {
     /// Creates a new `Timer` with the given period and callback.
     /// Periods greater than i64::MAX nanoseconds will saturate to i64::MAX.
-    pub(crate) fn new<F>(
+    pub fn new<F>(
+        context: &Context,
+        clock: Clock,
+        period: Duration,
+        callback: F,
+    ) -> Result<Self, RclrsError>
+    where
+        F: Fn(&mut Timer) + 'static + Send + Sync,
+    {
+        Timer::new_with_context_handle(Arc::clone(&context.handle), clock, period, callback)
+    }
+
+    /// Version of [`Timer::new`] that takes a context handle directly.
+    pub(crate) fn new_with_context_handle<F>(
         context_handle: Arc<ContextHandle>,
         clock: Clock,
         period: Duration,
@@ -310,14 +323,11 @@ mod tests {
 
     fn new_timer() -> Timer {
         let context = Context::new([]).unwrap();
+
+        // This is technically a wall clock, but we have a period of 0 so it won't slow down unit testing.
         let clock = Clock::system();
 
-        let timer = Timer::new(
-            context.handle.clone(),
-            clock,
-            Duration::from_secs(0),
-            |_| {},
-        );
+        let timer = Timer::new(&context, clock, Duration::from_secs(0), |_| {});
 
         timer.expect("Timer::new should not return an error")
     }

rclrs/src/wait.rs

@@ -475,6 +475,8 @@ impl WaitSet {
 
 #[cfg(test)]
 mod tests {
+    use crate::{Clock, Timer};
+
     use super::*;
 
     #[test]
@@ -500,4 +502,28 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn timer_in_wait_set_readies() -> Result<(), RclrsError> {
+        let context = Context::new([])?;
+        // This is technically a wall clock, but we have a period of 0 so it won't slow down unit testing.
+        let clock = Clock::system();
+
+        let timer: Arc<Mutex<dyn TimerBase>> = Arc::new(Mutex::new(Timer::new(
+            &context,
+            clock,
+            Duration::from_secs(0),
+            |_| {},
+        )?));
+        let mut wait_set = WaitSet::new(0, 0, 1, 0, 0, 0, &context)?;
+
+        assert!(wait_set.timers.is_empty());
+        wait_set.add_timer(Arc::clone(&timer))?;
+
+        let readies = wait_set.wait(Some(std::time::Duration::from_millis(10)))?;
+
+        assert_eq!(readies.timers.len(), 1);
+
+        Ok(())
+    }
 }