Add unit testing (#84)

* Copied tests from jhdcs' fork

* Ran cargo fmt

* Run clippy on tests as well

* Make Clippy happy

* Fix rustfmt warning

* Added std_msgs to package.xml

* Disable deref_nullptr warning for generated code

* Include Soya-Onishi's changes

* Fix Node::new call

* Fix spelling mistakes

Co-authored-by: jhdcs <[email protected]>

* Fix spelling mistakes

Co-authored-by: jhdcs <[email protected]>

* Fix spelling mistakes

Co-authored-by: jhdcs <[email protected]>

* Fix formatting

Co-authored-by: jhdcs <[email protected]>

Author: esteve

.github/workflows/rust.yml

@@ -91,7 +91,7 @@ jobs:
         for path in $(colcon list | awk '$3 == "(ament_cargo)" { print $2 }'); do
         cd $path
         echo "Running clippy in $path"
-        cargo clippy -- -D warnings
+        cargo clippy --all-targets --all-features -- -D warnings
         cd -
         done
 

rclrs/Cargo.toml

@@ -22,6 +22,9 @@ rosidl_runtime_rs = "*"
 # Needed for e.g. writing yaml files in tests
 tempfile = "3.3.0"
 
+[dev-dependencies.std_msgs]
+version = "*"
+
 [build-dependencies]
 # Needed for FFI
 bindgen = "0.59.1"

rclrs/package.xml

@@ -17,6 +17,8 @@
   <build_depend>rosidl_runtime_rs</build_depend>
   <build_depend>rcl</build_depend>
 
+  <test_depend>std_msgs</test_depend>
+
   <export>
     <build_type>ament_cargo</build_type>
   </export>

rclrs/src/context.rs

@@ -158,3 +158,24 @@ impl Context {
         unsafe { rcl_context_is_valid(rcl_context) }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_context() -> Result<(), RclrsError> {
+        // If the context fails to be created, this will cause a panic
+        let _ = Context::new(vec![])?;
+        Ok(())
+    }
+
+    #[test]
+    fn test_context_ok() -> Result<(), RclrsError> {
+        // If the context fails to be created, this will cause a panic
+        let created_context = Context::new(vec![]).unwrap();
+        assert!(created_context.ok());
+
+        Ok(())
+    }
+}

rclrs/src/lib.rs

@@ -77,3 +77,44 @@ pub fn spin(node: &Node) -> Result<(), RclrsError> {
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::{Arc, Mutex};
+    use std::time::Duration;
+
+    #[test]
+    fn test_spin_once() -> Result<(), RclrsError> {
+        let context = Context::new(vec![]).unwrap();
+        let mut subscriber_node = context.create_node("minimal_subscriber")?;
+        let num_messages = Arc::new(Mutex::new(0));
+        let received_msg = Arc::new(Mutex::new(String::new()));
+        let n = num_messages.clone();
+        let m = received_msg.clone();
+        let publisher = subscriber_node
+            .create_publisher::<std_msgs::msg::String>("topic", QOS_PROFILE_DEFAULT)?;
+        let _subscription = subscriber_node.create_subscription::<std_msgs::msg::String, _>(
+            "topic",
+            QOS_PROFILE_DEFAULT,
+            move |msg: std_msgs::msg::String| {
+                let mut num_messages = n.lock().unwrap();
+                let mut received_msg = m.lock().unwrap();
+
+                *num_messages += 1;
+                *received_msg = msg.data;
+            },
+        )?;
+
+        let message = std_msgs::msg::String {
+            data: String::from("Hello World"),
+        };
+        publisher.publish(message)?;
+        spin_once(&subscriber_node, Some(Duration::from_millis(500)))?;
+
+        assert_eq!(*num_messages.lock().unwrap(), 1);
+        assert_eq!(&*received_msg.lock().unwrap().as_str(), "Hello World");
+
+        Ok(())
+    }
+}

rclrs/src/node.rs

@@ -286,3 +286,41 @@ unsafe fn call_string_getter_with_handle(
     let cstr = CStr::from_ptr(char_ptr);
     cstr.to_string_lossy().into_owned()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{Context, Node, QOS_PROFILE_DEFAULT};
+
+    #[test]
+    fn test_new() -> Result<(), RclrsError> {
+        let context =
+            Context::new(vec![]).expect("Context instantiation is expected to be a success");
+        let _ = Node::new(&context, "Bob")?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_create_subscription() -> Result<(), RclrsError> {
+        let context =
+            Context::new(vec![]).expect("Context instantiation is expected to be a success");
+        let mut node = context.create_node("test_create_subscription")?;
+        let _subscription = node.create_subscription::<std_msgs::msg::String, _>(
+            "topic",
+            QOS_PROFILE_DEFAULT,
+            move |_: std_msgs::msg::String| {},
+        )?;
+        Ok(())
+    }
+
+    #[test]
+    fn test_create_publisher() -> Result<(), RclrsError> {
+        let context =
+            Context::new(vec![]).expect("Context instantiation is expected to be a success");
+        let node = context.create_node("test_create_publisher")?;
+        let _publisher =
+            node.create_publisher::<std_msgs::msg::String>("topic", QOS_PROFILE_DEFAULT)?;
+        Ok(())
+    }
+}

rclrs/src/node/publisher.rs

@@ -163,3 +163,38 @@ impl<'a, T: Message> MessageCow<'a, T> for &'a T {
         Cow::Borrowed(self)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{Context, Publisher, QOS_PROFILE_DEFAULT};
+
+    fn create_fixture(name: &str) -> (Context, Node) {
+        let context =
+            Context::new(vec![]).expect("Context instantiation is expected to be a success");
+        let node = context
+            .create_node(name)
+            .expect("Node instantiation is expected to be a success");
+
+        (context, node)
+    }
+
+    #[test]
+    fn test_new_publisher() -> Result<(), RclrsError> {
+        let (_, node) = create_fixture("test_new_publisher");
+        let _ = Publisher::<std_msgs::msg::String>::new(&node, "test", QOS_PROFILE_DEFAULT)?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_publish_message() -> Result<(), RclrsError> {
+        let (_, node) = create_fixture("test_publish_message");
+        let publisher =
+            Publisher::<std_msgs::msg::String>::new(&node, "test", QOS_PROFILE_DEFAULT)?;
+        let message = std_msgs::msg::String {
+            data: "Hello world!".to_owned(),
+        };
+        publisher.publish(&message)
+    }
+}

rclrs/src/node/subscription.rs

@@ -206,3 +206,24 @@ where
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{Context, Subscription, QOS_PROFILE_DEFAULT};
+
+    #[test]
+    fn test_instantiate_subscriber() -> Result<(), RclrsError> {
+        let context =
+            Context::new(vec![]).expect("Context instantiation is expected to be a success");
+        let node = context.create_node("test_new_subscriber")?;
+        let _subscriber = Subscription::<std_msgs::msg::String>::new(
+            &node,
+            "test",
+            QOS_PROFILE_DEFAULT,
+            move |_: std_msgs::msg::String| {},
+        )?;
+
+        Ok(())
+    }
+}

rclrs/src/rcl_bindings.rs

@@ -1,4 +1,5 @@
 #![allow(dead_code)]
+#![allow(deref_nullptr)]
 #![allow(non_upper_case_globals)]
 #![allow(non_camel_case_types)]
 #![allow(non_snake_case)]

rosidl_runtime_rs/src/sequence.rs

@@ -705,10 +705,10 @@ mod tests {
             if xs_seq.len() != xs.len() + ys.len() {
                 return false;
             }
-            if &xs_seq[..xs.len()] != &xs[..] {
+            if xs_seq[..xs.len()] != xs[..] {
                 return false;
             }
-            if &xs_seq[xs.len()..] != &ys[..] {
+            if xs_seq[xs.len()..] != ys[..] {
                 return false;
             }
             true