Squashed 'vendor/ruvector/' content from commit b64c2172

git-subtree-dir: vendor/ruvector
git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900

crates/cognitum-gate-kernel/tests_disabled/report_tests.rs

@@ -0,0 +1,249 @@
+//! Comprehensive tests for TileReport generation and serialization
+//!
+//! Tests cover:
+//! - Report creation and initialization
+//! - Serialization/deserialization roundtrips
+//! - Checksum verification
+//! - WitnessFragment operations
+
+use cognitum_gate_kernel::report::{TileReport, TileStatus, WitnessFragment};
+use cognitum_gate_kernel::shard::EdgeId;
+
+#[cfg(test)]
+mod tile_status {
+    use super::*;
+
+    #[test]
+    fn test_status_values() {
+        assert_eq!(TileStatus::Active as u8, 0);
+        assert_eq!(TileStatus::Idle as u8, 1);
+        assert_eq!(TileStatus::Recovery as u8, 2);
+        assert_eq!(TileStatus::Error as u8, 3);
+    }
+
+    #[test]
+    fn test_status_from_u8() {
+        assert_eq!(TileStatus::from_u8(0), Some(TileStatus::Active));
+        assert_eq!(TileStatus::from_u8(1), Some(TileStatus::Idle));
+        assert_eq!(TileStatus::from_u8(255), None);
+    }
+
+    #[test]
+    fn test_is_healthy() {
+        assert!(TileStatus::Active.is_healthy());
+        assert!(TileStatus::Idle.is_healthy());
+        assert!(!TileStatus::Error.is_healthy());
+    }
+}
+
+#[cfg(test)]
+mod witness_fragment {
+    use super::*;
+
+    #[test]
+    fn test_fragment_creation() {
+        let frag = WitnessFragment::new(42);
+        assert_eq!(frag.tile_id, 42);
+        assert_eq!(frag.min_cut_value, 0);
+    }
+
+    #[test]
+    fn test_is_fragile() {
+        let mut frag = WitnessFragment::new(0);
+        frag.min_cut_value = 5;
+        assert!(frag.is_fragile(10));
+        assert!(!frag.is_fragile(5));
+    }
+
+    #[test]
+    fn test_fragment_hash_deterministic() {
+        let frag = WitnessFragment::new(5);
+        assert_eq!(frag.compute_hash(), frag.compute_hash());
+    }
+
+    #[test]
+    fn test_fragment_hash_unique() {
+        let frag1 = WitnessFragment::new(1);
+        let frag2 = WitnessFragment::new(2);
+        assert_ne!(frag1.compute_hash(), frag2.compute_hash());
+    }
+}
+
+#[cfg(test)]
+mod tile_report_creation {
+    use super::*;
+
+    #[test]
+    fn test_new_report() {
+        let report = TileReport::new(5);
+        assert_eq!(report.tile_id, 5);
+        assert_eq!(report.status, TileStatus::Active);
+        assert!(report.is_healthy());
+    }
+
+    #[test]
+    fn test_error_report() {
+        let report = TileReport::error(10);
+        assert_eq!(report.status, TileStatus::Error);
+        assert!(!report.is_healthy());
+    }
+
+    #[test]
+    fn test_idle_report() {
+        let report = TileReport::idle(15);
+        assert_eq!(report.status, TileStatus::Idle);
+        assert!(report.is_healthy());
+    }
+}
+
+#[cfg(test)]
+mod report_health_checks {
+    use super::*;
+
+    #[test]
+    fn test_needs_attention_boundary_moved() {
+        let mut report = TileReport::new(0);
+        assert!(!report.needs_attention());
+        report.boundary_moved = true;
+        assert!(report.needs_attention());
+    }
+
+    #[test]
+    fn test_needs_attention_negative_coherence() {
+        let mut report = TileReport::new(0);
+        report.coherence = -100;
+        assert!(report.needs_attention());
+    }
+}
+
+#[cfg(test)]
+mod coherence_conversion {
+    use super::*;
+
+    #[test]
+    fn test_coherence_f32_values() {
+        let mut report = TileReport::new(0);
+
+        report.coherence = 0;
+        assert!((report.coherence_f32() - 0.0).abs() < 0.001);
+
+        report.coherence = 256;
+        assert!((report.coherence_f32() - 1.0).abs() < 0.01);
+
+        report.coherence = -128;
+        assert!((report.coherence_f32() - (-0.5)).abs() < 0.01);
+    }
+}
+
+#[cfg(test)]
+mod serialization {
+    use super::*;
+
+    #[test]
+    fn test_to_bytes_size() {
+        let report = TileReport::new(0);
+        let bytes = report.to_bytes();
+        assert_eq!(bytes.len(), 64);
+    }
+
+    #[test]
+    fn test_roundtrip_basic() {
+        let report = TileReport::new(42);
+        let bytes = report.to_bytes();
+        let restored = TileReport::from_bytes(&bytes).unwrap();
+        assert_eq!(report.tile_id, restored.tile_id);
+        assert_eq!(report.status, restored.status);
+    }
+
+    #[test]
+    fn test_roundtrip_with_data() {
+        let mut report = TileReport::new(100);
+        report.coherence = 512;
+        report.e_value = 2.5;
+        report.boundary_moved = true;
+        report.suspicious_edges[0] = EdgeId(100);
+
+        let bytes = report.to_bytes();
+        let restored = TileReport::from_bytes(&bytes).unwrap();
+
+        assert_eq!(restored.coherence, 512);
+        assert!((restored.e_value - 2.5).abs() < 0.001);
+        assert!(restored.boundary_moved);
+        assert_eq!(restored.suspicious_edges[0], EdgeId(100));
+    }
+}
+
+#[cfg(test)]
+mod checksum {
+    use super::*;
+
+    #[test]
+    fn test_checksum_deterministic() {
+        let report = TileReport::new(42);
+        assert_eq!(report.checksum(), report.checksum());
+    }
+
+    #[test]
+    fn test_checksum_different_reports() {
+        let r1 = TileReport::new(1);
+        let r2 = TileReport::new(2);
+        assert_ne!(r1.checksum(), r2.checksum());
+    }
+
+    #[test]
+    fn test_verify_checksum() {
+        let report = TileReport::new(42);
+        let cs = report.checksum();
+        assert!(report.verify_checksum(cs));
+        assert!(!report.verify_checksum(0));
+    }
+}
+
+#[cfg(test)]
+mod report_size {
+    use super::*;
+    use std::mem::size_of;
+
+    #[test]
+    fn test_report_fits_cache_line() {
+        assert!(size_of::<TileReport>() <= 64);
+    }
+}
+
+#[cfg(test)]
+mod property_tests {
+    use super::*;
+    use proptest::prelude::*;
+
+    proptest! {
+        #[test]
+        fn prop_serialization_roundtrip(
+            tile_id in 0u8..255,
+            coherence in i16::MIN..i16::MAX,
+            e_value in 0.0f32..100.0,
+            boundary_moved: bool
+        ) {
+            let mut report = TileReport::new(tile_id);
+            report.coherence = coherence;
+            report.e_value = e_value;
+            report.boundary_moved = boundary_moved;
+
+            let bytes = report.to_bytes();
+            let restored = TileReport::from_bytes(&bytes).unwrap();
+
+            assert_eq!(report.tile_id, restored.tile_id);
+            assert_eq!(report.coherence, restored.coherence);
+            assert_eq!(report.boundary_moved, restored.boundary_moved);
+        }
+
+        #[test]
+        fn prop_checksum_changes_with_data(a: i16, b: i16) {
+            prop_assume!(a != b);
+            let mut r1 = TileReport::new(0);
+            let mut r2 = TileReport::new(0);
+            r1.coherence = a;
+            r2.coherence = b;
+            assert_ne!(r1.checksum(), r2.checksum());
+        }
+    }
+}