Add tests for signal mechanism

Author: elfenpiff

iceoryx2-cal/src/event/mod.rs

@@ -12,7 +12,7 @@
 
 pub mod id_tracker;
 pub mod process_local;
-pub mod signal;
+pub mod signal_mechanism;
 pub mod unix_datagram_socket;
 
 use std::{fmt::Debug, time::Duration};

iceoryx2-cal/src/event/signal/mod.rs renamed to iceoryx2-cal/src/event/signal_mechanism/mod.rs

@@ -21,7 +21,7 @@ pub trait SignalMechanism {
     fn init(&mut self) -> Result<(), ListenerCreateError>;
 
     fn notify(&self) -> Result<(), NotifierNotifyError>;
-    fn try_wait(&self) -> Result<(), ListenerWaitError>;
-    fn timed_wait(&self, timeout: Duration) -> Result<(), ListenerWaitError>;
+    fn try_wait(&self) -> Result<bool, ListenerWaitError>;
+    fn timed_wait(&self, timeout: Duration) -> Result<bool, ListenerWaitError>;
     fn blocking_wait(&self) -> Result<(), ListenerWaitError>;
 }

iceoryx2-cal/src/event/signal/semaphore.rs renamed to iceoryx2-cal/src/event/signal_mechanism/semaphore.rs

@@ -59,27 +59,24 @@ impl SignalMechanism for Semaphore {
         Ok(())
     }
 
-    fn try_wait(&self) -> Result<(), ListenerWaitError> {
-        fail!(from self, when self.semaphore().try_wait(),
+    fn try_wait(&self) -> Result<bool, ListenerWaitError> {
+        Ok(fail!(from self, when self.semaphore().try_wait(),
             with ListenerWaitError::InternalFailure,
-            "Failed to dedcrement underlying semaphore.");
-        Ok(())
+            "Failed to dedcrement underlying semaphore."))
     }
 
     fn timed_wait(
         &self,
         timeout: std::time::Duration,
-    ) -> Result<(), crate::event::ListenerWaitError> {
-        fail!(from self, when self.semaphore().timed_wait(timeout),
+    ) -> Result<bool, crate::event::ListenerWaitError> {
+        Ok(fail!(from self, when self.semaphore().timed_wait(timeout),
             with ListenerWaitError::InternalFailure,
-            "Failed to dedcrement underlying semaphore.");
-        Ok(())
+            "Failed to dedcrement underlying semaphore."))
     }
 
     fn blocking_wait(&self) -> Result<(), crate::event::ListenerWaitError> {
-        fail!(from self, when self.semaphore().wait(),
+        Ok(fail!(from self, when self.semaphore().wait(),
             with ListenerWaitError::InternalFailure,
-            "Failed to dedcrement underlying semaphore.");
-        Ok(())
+            "Failed to dedcrement underlying semaphore."))
     }
 }

iceoryx2-cal/tests/event_signal_mechanism_tests.rs

@@ -0,0 +1,50 @@
+// Copyright (c) 2024 Contributors to the Eclipse Foundation
+//
+// See the NOTICE file(s) distributed with this work for additional
+// information regarding copyright ownership.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Apache Software License 2.0 which is available at
+// https://www.apache.org/licenses/LICENSE-2.0, or the MIT license
+// which is available at https://opensource.org/licenses/MIT.
+//
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+#[generic_tests::define]
+mod signal_mechanism {
+    use std::time::Duration;
+
+    use iceoryx2_bb_testing::{assert_that, watchdog::Watchdog};
+    use iceoryx2_cal::event::signal_mechanism::{semaphore::Semaphore, SignalMechanism};
+    const TIMEOUT: Duration = Duration::from_millis(25);
+
+    #[test]
+    fn try_wait_works<Sut: SignalMechanism>() {
+        let mut sut = Sut::new();
+        assert_that!(sut.init(), is_ok);
+
+        assert_that!(sut.try_wait(), eq Ok(false));
+        //assert_that!(sut.notify(), is_ok);
+        //assert_that!(sut.try_wait(), eq Ok(true));
+        //assert_that!(sut.try_wait(), eq Ok(false));
+    }
+
+    #[test]
+    fn notified_signal_does_not_block<Sut: SignalMechanism>() {
+        let _watchdog = Watchdog::new(Duration::from_secs(1));
+        let mut sut = Sut::new();
+        assert_that!(sut.init(), is_ok);
+
+        assert_that!(sut.notify(), is_ok);
+        assert_that!(sut.try_wait(), eq Ok(true));
+
+        assert_that!(sut.notify(), is_ok);
+        assert_that!(sut.timed_wait(TIMEOUT), eq Ok(true));
+
+        assert_that!(sut.notify(), is_ok);
+        assert_that!(sut.blocking_wait(), is_ok);
+    }
+
+    #[instantiate_tests(<Semaphore>)]
+    mod bitset {}
+}