diff --git a/genetic-rs-common/src/builtin/eliminator.rs b/genetic-rs-common/src/builtin/eliminator.rs index d9c4e08..5309d4e 100644 --- a/genetic-rs-common/src/builtin/eliminator.rs +++ b/genetic-rs-common/src/builtin/eliminator.rs @@ -81,6 +81,56 @@ where } } +impl Default for LayeredObserver +where + A: Default + FitnessObserver, + B: Default + FitnessObserver, +{ + fn default() -> Self { + Self(A::default(), B::default(), std::marker::PhantomData) + } +} + +impl Clone for LayeredObserver +where + A: Clone + FitnessObserver, + B: Clone + FitnessObserver, +{ + fn clone(&self) -> Self { + Self(self.0.clone(), self.1.clone(), std::marker::PhantomData) + } +} + +impl std::fmt::Debug for LayeredObserver +where + A: std::fmt::Debug + FitnessObserver, + B: std::fmt::Debug + FitnessObserver, +{ + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_tuple("LayeredObserver") + .field(&self.0) + .field(&self.1) + .finish() + } +} + +impl PartialEq for LayeredObserver +where + A: PartialEq + FitnessObserver, + B: PartialEq + FitnessObserver, +{ + fn eq(&self, other: &Self) -> bool { + self.0 == other.0 && self.1 == other.1 + } +} + +impl Eq for LayeredObserver +where + A: Eq + FitnessObserver, + B: Eq + FitnessObserver, +{ +} + #[cfg(not(feature = "rayon"))] #[doc(hidden)] pub trait FeatureBoundedFitnessObserver: FitnessObserver {} diff --git a/genetic-rs/tests/eliminator.rs b/genetic-rs/tests/eliminator.rs index f4c2b26..8738c7e 100644 --- a/genetic-rs/tests/eliminator.rs +++ b/genetic-rs/tests/eliminator.rs @@ -12,6 +12,15 @@ impl<'a, G> FitnessObserver for CountingObserver<'a> { } } +#[derive(Debug, Default, Clone, PartialEq, Eq)] +struct TrackingObserver(usize); + +impl FitnessObserver for TrackingObserver { + fn observe(&mut self, _fitnesses: &[(G, f32)]) { + self.0 += 1; + } +} + #[test] fn layered_observer_calls_both() { let count_a = Cell::new(0usize); @@ -43,3 +52,50 @@ fn layered_observer_triple_layer() { assert_eq!(count_b.get(), 1); assert_eq!(count_c.get(), 1); } + +#[test] +fn layered_observer_default() { + let layered: LayeredObserver<(), TrackingObserver, TrackingObserver> = + LayeredObserver::default(); + assert_eq!(layered.0, TrackingObserver(0)); + assert_eq!(layered.1, TrackingObserver(0)); +} + +#[test] +fn layered_observer_clone() { + let original = TrackingObserver::default().layer(TrackingObserver::default()); + let mut cloned: LayeredObserver<(), _, _> = original.clone(); + + let fitnesses: Vec<((), f32)> = vec![((), 1.0)]; + cloned.observe(&fitnesses); + + assert_eq!(cloned.0, TrackingObserver(1)); + assert_eq!(cloned.1, TrackingObserver(1)); + assert_eq!(original.0, TrackingObserver(0)); + assert_eq!(original.1, TrackingObserver(0)); +} + +#[test] +fn layered_observer_debug() { + let layered: LayeredObserver<(), TrackingObserver, TrackingObserver> = + TrackingObserver::default().layer(TrackingObserver::default()); + let debug_str = format!("{:?}", layered); + assert!(debug_str.contains("LayeredObserver")); + assert!(debug_str.contains("TrackingObserver")); +} + +#[test] +fn layered_observer_partial_eq() { + let a: LayeredObserver<(), _, _> = + TrackingObserver::default().layer(TrackingObserver::default()); + let b: LayeredObserver<(), _, _> = + TrackingObserver::default().layer(TrackingObserver::default()); + assert_eq!(a, b); +} + +#[test] +fn layered_observer_partial_eq_not_equal() { + let a: LayeredObserver<(), _, _> = TrackingObserver(1).layer(TrackingObserver(0)); + let b: LayeredObserver<(), _, _> = TrackingObserver(0).layer(TrackingObserver(0)); + assert_ne!(a, b); +}