add tests

Author: s5suzuki

autd3-core/src/datagram/mod.rs

@@ -39,7 +39,7 @@ pub trait DatagramL: std::fmt::Debug {
     #[doc(hidden)]
     type G;
     #[doc(hidden)]
-    type Error: std::error::Error;
+    type Error;
 
     #[doc(hidden)]
     fn operation_generator_with_loop_behavior(
@@ -52,17 +52,15 @@ pub trait DatagramL: std::fmt::Debug {
     ) -> Result<Self::G, Self::Error>;
 
     /// Returns the option of the datagram.
-    fn option(&self) -> DatagramOption {
-        DatagramOption::default()
-    }
+    fn option(&self) -> DatagramOption;
 }
 
 /// [`DatagramS`] is a [`Datagram`] with [`Segment`].
 pub trait DatagramS: std::fmt::Debug {
     #[doc(hidden)]
     type G;
     #[doc(hidden)]
-    type Error: std::error::Error;
+    type Error;
 
     #[doc(hidden)]
     fn operation_generator_with_segment(
@@ -74,9 +72,7 @@ pub trait DatagramS: std::fmt::Debug {
     ) -> Result<Self::G, Self::Error>;
 
     /// Returns the option of the datagram.
-    fn option(&self) -> DatagramOption {
-        DatagramOption::default()
-    }
+    fn option(&self) -> DatagramOption;
 }
 
 impl<D: DatagramL> DatagramS for D {
@@ -109,7 +105,7 @@ pub trait Datagram: std::fmt::Debug {
     #[doc(hidden)]
     type G;
     #[doc(hidden)]
-    type Error: std::error::Error;
+    type Error;
 
     #[doc(hidden)]
     fn operation_generator(

autd3-core/src/datagram/operation.rs

@@ -12,6 +12,7 @@ pub trait Operation: Send + Sync {
 #[doc(hidden)]
 pub struct NullOp;
 
+// GRCOV_EXCL_START
 impl Operation for NullOp {
     type Error = std::convert::Infallible;
 
@@ -33,3 +34,4 @@ impl Default for Box<dyn Operation<Error = std::convert::Infallible>> {
         Box::new(NullOp)
     }
 }
+// GRCOV_EXCL_STOP

autd3-core/src/datagram/tuple.rs

@@ -4,6 +4,7 @@ use crate::geometry::Geometry;
 
 use super::{Datagram, DatagramOption};
 
+#[derive(Debug, PartialEq)]
 #[doc(hidden)]
 pub struct CombinedOperationGenerator<O1, O2> {
     pub o1: O1,
@@ -12,11 +13,7 @@ pub struct CombinedOperationGenerator<O1, O2> {
 
 #[derive(Error, Debug, PartialEq)]
 #[doc(hidden)]
-pub enum CombinedError<E1, E2>
-where
-    E1: std::error::Error,
-    E2: std::error::Error,
-{
+pub enum CombinedError<E1, E2> {
     #[error("{0}")]
     E1(E1),
     #[error("{0}")]
@@ -27,8 +24,6 @@ impl<G1, G2, D1, D2, E1, E2> Datagram for (D1, D2)
 where
     D1: Datagram<G = G1, Error = E1>,
     D2: Datagram<G = G2, Error = E2>,
-    E1: std::error::Error,
-    E2: std::error::Error,
 {
     type G = CombinedOperationGenerator<D1::G, D2::G>;
     type Error = CombinedError<E1, E2>;
@@ -67,27 +62,57 @@ mod tests {
     use std::time::Duration;
 
     #[derive(Debug)]
-    pub struct NullDatagram {
+    pub struct TestDatagram {
         pub option: DatagramOption,
+        pub result: Result<(), ()>,
     }
 
-    impl Datagram for NullDatagram {
+    impl Datagram for TestDatagram {
         type G = ();
-        type Error = std::convert::Infallible;
+        type Error = ();
 
         fn operation_generator(
             self,
             _: &Geometry,
             _: &DatagramOption,
         ) -> Result<Self::G, Self::Error> {
-            Ok(())
+            self.result
         }
 
         fn option(&self) -> DatagramOption {
             self.option
         }
     }
 
+    #[rstest::rstest]
+    #[case(Ok(CombinedOperationGenerator { o1: (), o2: () }), Ok(()), Ok(()))]
+    #[case(Err(CombinedError::E1(())), Err(()), Ok(()))]
+    #[case(Err(CombinedError::E2(())), Ok(()), Err(()))]
+    #[test]
+    fn operation_generator(
+        #[case] expect: Result<CombinedOperationGenerator<(), ()>, CombinedError<(), ()>>,
+        #[case] result1: Result<(), ()>,
+        #[case] result2: Result<(), ()>,
+    ) {
+        assert_eq!(
+            expect,
+            (
+                TestDatagram {
+                    option: DatagramOption::default(),
+                    result: result1,
+                },
+                TestDatagram {
+                    option: DatagramOption::default(),
+                    result: result2,
+                }
+            )
+                .operation_generator(
+                    &Geometry::new(Default::default()),
+                    &DatagramOption::default()
+                )
+        );
+    }
+
     #[rstest::rstest]
     #[case(
         Duration::from_millis(200),
@@ -104,17 +129,19 @@ mod tests {
         assert_eq!(
             expect,
             (
-                NullDatagram {
+                TestDatagram {
                     option: DatagramOption {
                         timeout: timeout1,
                         parallel_threshold: 0,
                     },
+                    result: Ok(()),
                 },
-                NullDatagram {
+                TestDatagram {
                     option: DatagramOption {
                         timeout: timeout2,
                         parallel_threshold: 0,
                     },
+                    result: Ok(()),
                 }
             )
                 .option()
@@ -134,17 +161,19 @@ mod tests {
         assert_eq!(
             expect,
             (
-                NullDatagram {
+                TestDatagram {
                     option: DatagramOption {
                         timeout: Duration::ZERO,
                         parallel_threshold: threshold1,
                     },
+                    result: Ok(()),
                 },
-                NullDatagram {
+                TestDatagram {
                     option: DatagramOption {
                         timeout: Duration::ZERO,
                         parallel_threshold: threshold2,
                     },
+                    result: Ok(()),
                 }
             )
                 .option()

autd3-core/src/gain/phase.rs

@@ -27,12 +27,6 @@ impl Phase {
     }
 }
 
-impl From<u8> for Phase {
-    fn from(v: u8) -> Self {
-        Self(v)
-    }
-}
-
 impl From<Angle> for Phase {
     fn from(v: Angle) -> Self {
         Self((((v.radian() / (2.0 * PI) * 256.0).round() as i32) & 0xFF) as _)

autd3-core/src/geometry/transducer.rs

@@ -46,14 +46,18 @@ mod tests {
         };
     }
 
-    #[rstest::fixture]
-    fn tr() -> Transducer {
-        Transducer::new(0, 0, Point3::origin())
+    #[test]
+    fn idx() {
+        let tr = Transducer::new(1, 2, Point3::origin());
+        assert_eq!(1, tr.idx());
+        assert_eq!(2, tr.dev_idx());
     }
 
     #[rstest::rstest]
     #[test]
-    fn affine(mut tr: Transducer) {
+    fn affine() {
+        let mut tr = Transducer::new(0, 0, Point3::origin());
+
         let vector = Vector3::new(40., 50., 60.);
         let rotation = UnitQuaternion::from_axis_angle(&Vector3::x_axis(), 0.)
             * UnitQuaternion::from_axis_angle(&Vector3::y_axis(), 0.)

autd3-core/src/modulation/error.rs

@@ -39,6 +39,7 @@ pub enum SamplingConfigError {
     SamplingPeriodOutOfRange(Duration, Duration, Duration),
 }
 
+// GRCOV_EXCL_START
 impl From<Infallible> for SamplingConfigError {
     fn from(_: Infallible) -> Self {
         unreachable!()
@@ -56,3 +57,4 @@ impl From<SamplingConfigError> for ModulationError {
         Self::new(e.to_string())
     }
 }
+// GRCOV_EXCL_STOP

autd3-core/src/modulation/sampling_config.rs

@@ -252,6 +252,7 @@ mod tests {
     #[case(Ok(10), 4000 * Hz)]
     #[case(Ok(1), 40000. * Hz)]
     #[case(Ok(10), 4000. * Hz)]
+    #[case(Err(SamplingConfigError::SamplingDivisionInvalid), 0)]
     #[case(Err(SamplingConfigError::SamplingFreqInvalid(ultrasound_freq() - 1 * Hz)), ultrasound_freq() - 1 * Hz)]
     #[case(Err(SamplingConfigError::SamplingFreqOutOfRange(0 * Hz, 1 * Hz, ultrasound_freq())), 0 * Hz)]
     #[case(Err(SamplingConfigError::SamplingFreqOutOfRange(ultrasound_freq() + 1 * Hz, 1 * Hz, ultrasound_freq())), ultrasound_freq() + 1 * Hz)]

autd3-derive/src/modulation.rs

@@ -25,6 +25,10 @@ pub(crate) fn impl_mod_macro(input: syn::DeriveInput) -> TokenStream {
                     transition_mode,
                 })
             }
+
+            fn option(&self) -> DatagramOption {
+                DatagramOption::default()
+            }
         }
     };