Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

vendor/ruvector/examples/exo-ai-2025/tests/common/assertions.rs

@@ -0,0 +1,116 @@
+//! Custom assertions for integration tests
+//!
+//! Provides domain-specific assertions for cognitive substrate testing.
+
+#![allow(dead_code)]
+
+/// Assert two embeddings are approximately equal (within epsilon)
+pub fn assert_embeddings_approx_equal(a: &[f32], b: &[f32], epsilon: f32) {
+    assert_eq!(
+        a.len(),
+        b.len(),
+        "Embeddings have different dimensions: {} vs {}",
+        a.len(),
+        b.len()
+    );
+
+    for (i, (av, bv)) in a.iter().zip(b.iter()).enumerate() {
+        let diff = (av - bv).abs();
+        assert!(
+            diff < epsilon,
+            "Embedding mismatch at index {}: |{} - {}| = {} >= {}",
+            i,
+            av,
+            bv,
+            diff,
+            epsilon
+        );
+    }
+}
+
+/// Assert similarity scores are in descending order
+pub fn assert_scores_descending(scores: &[f32]) {
+    for window in scores.windows(2) {
+        assert!(
+            window[0] >= window[1],
+            "Scores not in descending order: {} < {}",
+            window[0],
+            window[1]
+        );
+    }
+}
+
+/// Assert causal ordering is respected
+pub fn assert_causal_order(results: &[String], expected_order: &[String]) {
+    // TODO: Implement once CausalResult type exists
+    // Verify results respect causal dependencies
+    assert_eq!(results.len(), expected_order.len(), "Result count mismatch");
+}
+
+/// Assert CRDT states are convergent
+pub fn assert_crdt_convergence(state1: &str, state2: &str) {
+    // TODO: Implement once CRDT types exist
+    // Verify eventual consistency
+    assert_eq!(state1, state2, "CRDT states did not converge");
+}
+
+/// Assert topological invariants match expected values
+pub fn assert_betti_numbers(betti: &[usize], expected: &[usize]) {
+    assert_eq!(
+        betti.len(),
+        expected.len(),
+        "Betti number dimension mismatch"
+    );
+
+    for (i, (actual, exp)) in betti.iter().zip(expected.iter()).enumerate() {
+        assert_eq!(
+            actual, exp,
+            "Betti number b_{} mismatch: {} != {}",
+            i, actual, exp
+        );
+    }
+}
+
+/// Assert consensus proof is valid
+pub fn assert_valid_consensus_proof(proof: &str, threshold: usize) {
+    // TODO: Implement once CommitProof type exists
+    // Verify proof has sufficient signatures
+    assert!(
+        !proof.is_empty(),
+        "Consensus proof is empty (need {} votes)",
+        threshold
+    );
+}
+
+/// Assert temporal ordering is consistent
+pub fn assert_temporal_order(timestamps: &[u64]) {
+    for window in timestamps.windows(2) {
+        assert!(
+            window[0] <= window[1],
+            "Timestamps not in temporal order: {} > {}",
+            window[0],
+            window[1]
+        );
+    }
+}
+
+/// Assert pattern is within manifold region
+pub fn assert_in_manifold_region(embedding: &[f32], center: &[f32], radius: f32) {
+    let distance = euclidean_distance(embedding, center);
+    assert!(
+        distance <= radius,
+        "Pattern outside manifold region: distance {} > radius {}",
+        distance,
+        radius
+    );
+}
+
+// Helper: Compute Euclidean distance
+fn euclidean_distance(a: &[f32], b: &[f32]) -> f32 {
+    assert_eq!(a.len(), b.len());
+    a.iter()
+        .zip(b.iter())
+        .map(|(av, bv)| (av - bv).powi(2))
+        .sum::<f32>()
+        .sqrt()
+}