Iox 5 add more tests

README.md

@@ -59,6 +59,9 @@ find target -type f -wholename "*/iceoryx-install/bin/iox-roudi" -exec {} \;
 
 ### Run the simple publisher and subscriber example
 
+The `publisher_simple` and `subscriber_simple` examples are demonstrating a typical inter-process communication
+use case.
+
 A good introductory example to demonstrate the inter-process communication are `publisher_simple`
 and `subscriber_simple`.
 

src/error.rs

@@ -6,12 +6,12 @@ use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum IceoryxError {
-    #[error("could not allocate chunk")]
-    SampleAllocationFailed,
-    #[error("could not create publisher")]
+    #[error("Could not loan sample")]
+    LoanSampleFailed,
+    #[error("Could not create publisher")]
     PublisherCreationFailed,
-    #[error("could not create subscriber")]
+    #[error("Could not create subscriber")]
     SubscriberCreationFailed,
-    #[error("number of allowed chunks to hold is exhausted")]
-    TooManyChunksHoldInParallel,
+    #[error("Number of allowed samples to hold is exhausted")]
+    TooManySamplesHoldInParallel,
 }

src/publisher.rs

@@ -131,7 +131,7 @@ impl<T: ShmSend + Default> Publisher<T> {
         let mut data = self
             .ffi_pub
             .allocate_chunk::<T>()
-            .ok_or(IceoryxError::SampleAllocationFailed)?;
+            .ok_or(IceoryxError::LoanSampleFailed)?;
 
         // TDDO use this once 'new_uninit' is stabilized
         // let data = Box::write(data, T::default());
@@ -151,7 +151,7 @@ impl<T: ShmSend> Publisher<T> {
         let data = self
             .ffi_pub
             .allocate_chunk::<T>()
-            .ok_or(IceoryxError::SampleAllocationFailed)?;
+            .ok_or(IceoryxError::LoanSampleFailed)?;
 
         Ok(SampleMut {
             data: Some(data),

src/tests/basic_pub_sub.rs

@@ -10,6 +10,8 @@ use crate::SubscriberBuilder;
 
 use anyhow::{anyhow, Result};
 
+use std::thread;
+
 #[repr(C)]
 #[derive(Default)]
 struct Counter {
@@ -19,7 +21,7 @@ struct Counter {
 unsafe impl ShmSend for Counter {}
 
 #[test]
-fn basic_pub_sub() -> Result<()> {
+fn single_threaded_subscriber() -> Result<()> {
     let _roudi = RouDiEnvironment::new();
 
     Runtime::init("basic_pub_sub");
@@ -46,5 +48,111 @@ fn basic_pub_sub() -> Result<()> {
         _ => return Err(anyhow!("Could not read sample")),
     }
 
+    publisher.stop_offer();
+    subscriber.unsubscribe(sample_receiver);
+
+    Ok(())
+}
+
+#[test]
+fn multi_threaded_subscriber() -> Result<()> {
+    let _roudi = RouDiEnvironment::new();
+
+    Runtime::init("basic_pub_sub");
+
+    let (subscriber, sample_receive_token) =
+        SubscriberBuilder::<Counter>::new("Test", "BasicPubSub", "Counter")
+            .queue_capacity(5)
+            .create_mt()?;
+
+    let publisher = PublisherBuilder::<Counter>::new("Test", "BasicPubSub", "Counter").create()?;
+
+    let mut sample = publisher.loan()?;
+
+    const SEND_COUNTER: u32 = 13;
+    sample.counter = SEND_COUNTER;
+    publisher.publish(sample);
+
+    let sample_receiver = subscriber.get_sample_receiver(sample_receive_token);
+
+    let th = thread::spawn(move || {
+        assert!(sample_receiver.has_data());
+
+        match sample_receiver.take() {
+            Some(sample) => assert_eq!(sample.counter, SEND_COUNTER),
+            _ => assert!(false, "no sample received"),
+        }
+
+        sample_receiver
+    });
+
+    let sample_receiver = th.join().map_err(|_| anyhow!("could not join threads"))?;
+
+    publisher.stop_offer();
+    subscriber.unsubscribe(sample_receiver);
+
+    Ok(())
+}
+
+#[test]
+fn publisher_loaning_but_not_publishing_sample() -> Result<()> {
+    let _roudi = RouDiEnvironment::new();
+
+    Runtime::init("basic_pub_sub");
+
+    let (subscriber, sample_receive_token) =
+        SubscriberBuilder::<Counter>::new("Test", "BasicPubSub", "Counter")
+            .queue_capacity(5)
+            .create()?;
+
+    let publisher = PublisherBuilder::<Counter>::new("Test", "BasicPubSub", "Counter").create()?;
+
+    {
+        let _sample = publisher.loan()?;
+    }
+
+    let sample_receiver = subscriber.get_sample_receiver(sample_receive_token);
+
+    assert!(!sample_receiver.has_data());
+
+    publisher.stop_offer();
+    subscriber.unsubscribe(sample_receiver);
+
+    Ok(())
+}
+
+#[test]
+fn loaning_uninitialized_sample() -> Result<()> {
+    let _roudi = RouDiEnvironment::new();
+
+    Runtime::init("basic_pub_sub");
+
+    let (subscriber, sample_receive_token) =
+        SubscriberBuilder::<Counter>::new("Test", "BasicPubSub", "Counter")
+            .queue_capacity(5)
+            .create()?;
+
+    let publisher = PublisherBuilder::<Counter>::new("Test", "BasicPubSub", "Counter").create()?;
+
+    const SEND_COUNTER: u32 = 73;
+    let mut sample = publisher.loan_uninitialized()?;
+    let sample = unsafe {
+        (*sample.as_mut_ptr()).counter = SEND_COUNTER;
+        sample.assume_init()
+    };
+    publisher.publish(sample);
+
+    let sample_receiver = subscriber.get_sample_receiver(sample_receive_token);
+
+    assert!(sample_receiver.has_data());
+
+    match sample_receiver.take() {
+        Some(sample) => assert_eq!(sample.counter, SEND_COUNTER),
+        _ => return Err(anyhow!("Could not read sample")),
+    }
+
+    publisher.stop_offer();
+    subscriber.unsubscribe(sample_receiver);
+
     Ok(())
 }