Merge pull request #178 from elfenpiff/iox2-175-example-with-complex-data-types

[#175] Simplify example

Author: elfenpiff

examples/examples/complex_data_types/complex_data_types.rs

@@ -52,19 +52,20 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     while let Iox2Event::Tick = Iox2::wait(CYCLE_TIME) {
         // acquire and send out sample
         let mut sample = publisher.loan()?;
-        sample.payload_mut().plain_old_data = counter;
-        sample.payload_mut().text = FixedSizeByteString::from_bytes(b"hello")?;
-        sample.payload_mut().vec_of_data.push(counter);
-        sample.payload_mut().vec_of_complex_data.push(ComplexData {
+        let payload = sample.payload_mut();
+
+        payload.plain_old_data = counter;
+        payload.text = FixedSizeByteString::from_bytes(b"hello")?;
+        payload.vec_of_data.push(counter);
+        payload.vec_of_complex_data.push(ComplexData {
             name: FixedSizeByteString::from_bytes(b"bla")?,
             data: {
                 let mut v = FixedSizeVec::new();
                 v.fill(counter);
                 v
             },
         });
-        sample
-            .payload_mut()
+        payload
             .a_queue_of_things
             .push(FixedSizeByteString::from_bytes(b"buh")?);
 

iceoryx2-bb/posix/tests/condition_variable_tests.rs

@@ -201,41 +201,37 @@ fn condition_variable_trigger_all_signals_all_waiters() {
 
 #[test]
 fn condition_variable_trigger_one_signals_one_waiter() {
+    const NUMBER_OF_THREADS: usize = 2;
+
     let handle = MutexHandle::<ConditionVariableData<i32>>::new();
-    thread::scope(|s| {
-        let counter = Arc::new(AtomicI32::new(0));
-        let sut = Arc::new(
-            ConditionVariableBuilder::new()
-                .create_condition_variable(500, |v| *v > 1000, &handle)
-                .unwrap(),
-        );
+    let counter = AtomicI32::new(0);
+    let sut = ConditionVariableBuilder::new()
+        .create_condition_variable(500, |v| *v > 1000, &handle)
+        .unwrap();
+    let barrier = Barrier::new(3);
 
-        let sut_thread1 = Arc::clone(&sut);
-        let counter_thread1 = Arc::clone(&counter);
-        let t1 = s.spawn(move || {
-            sut_thread1.wait().unwrap();
-            counter_thread1.fetch_add(1, Ordering::Relaxed);
-        });
+    thread::scope(|s| {
+        let mut threads = vec![];
+        for _ in 0..NUMBER_OF_THREADS {
+            threads.push(s.spawn(|| {
+                barrier.wait();
 
-        let sut_thread2 = Arc::clone(&sut);
-        let counter_thread2 = Arc::clone(&counter);
-        let t2 = s.spawn(move || {
-            sut_thread2.wait().unwrap();
-            counter_thread2.fetch_add(1, Ordering::Relaxed);
-        });
+                sut.wait().unwrap();
+                counter.fetch_add(1, Ordering::Relaxed);
+            }));
+        }
 
+        barrier.wait();
         thread::sleep(TIMEOUT);
-        let counter_old_1 = counter.load(Ordering::Relaxed);
+        assert_that!(counter.load(Ordering::Relaxed), eq 0);
         sut.trigger_one();
-        thread::sleep(TIMEOUT);
-        let counter_old_2 = counter.load(Ordering::Relaxed);
+        assert_that!(|| counter.load(Ordering::Relaxed), block_until 1);
         sut.trigger_one();
 
-        t1.join().unwrap();
-        t2.join().unwrap();
+        for t in threads {
+            t.join().unwrap();
+        }
 
-        assert_that!(counter_old_1, eq 0);
-        assert_that!(counter_old_2, eq 1);
         assert_that!(counter.load(Ordering::Relaxed), eq 2);
     });
 }