Squashed 'vendor/ruvector/' content from commit b64c2172

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

crates/ruvector-nervous-system/tests/workspace_integration.rs

@@ -0,0 +1,113 @@
+//! Integration tests for Global Workspace implementation
+
+use ruvector_nervous_system::routing::workspace::{
+    AccessRequest, ContentType, GlobalWorkspace, ModuleInfo, WorkspaceItem, WorkspaceRegistry,
+};
+
+#[test]
+fn test_complete_workspace_workflow() {
+    // Create workspace with typical capacity
+    let mut workspace = GlobalWorkspace::new(7);
+    assert_eq!(workspace.capacity(), 7);
+    assert_eq!(workspace.available_slots(), 7);
+
+    // Broadcast items with competition
+    let item1 = WorkspaceItem::new(vec![1.0; 64], 0.9, 1, 0);
+    let item2 = WorkspaceItem::new(vec![2.0; 64], 0.5, 2, 0);
+
+    assert!(workspace.broadcast(item1));
+    assert!(workspace.broadcast(item2));
+    assert_eq!(workspace.len(), 2);
+
+    // Competition
+    let survivors = workspace.compete();
+    assert!(survivors.len() <= 2);
+
+    // Retrieval
+    let all = workspace.retrieve_all();
+    assert_eq!(all.len(), workspace.len());
+}
+
+#[test]
+fn test_workspace_registry_integration() {
+    let mut registry = WorkspaceRegistry::new(7);
+
+    // Register modules
+    let mod1 = ModuleInfo::new(0, "Module1".to_string(), 1.0, vec![ContentType::Query]);
+    let mod2 = ModuleInfo::new(0, "Module2".to_string(), 0.8, vec![ContentType::Result]);
+
+    let id1 = registry.register(mod1);
+    let id2 = registry.register(mod2);
+
+    assert_eq!(id1, 0);
+    assert_eq!(id2, 1);
+
+    // Route item
+    let item = WorkspaceItem::new(vec![1.0; 32], 0.85, id1, 0);
+    let recipients = registry.route(item);
+
+    assert_eq!(recipients.len(), 2);
+}
+
+#[test]
+fn test_performance_requirements() {
+    use std::time::Instant;
+
+    let mut workspace = GlobalWorkspace::new(100);
+
+    // Access request performance (<1μs target)
+    let start = Instant::now();
+    for i in 0..1000 {
+        let request = AccessRequest::new(i, vec![1.0], 0.8, i as u64);
+        workspace.request_access(request);
+    }
+    let duration = start.elapsed();
+    let avg_us = duration.as_micros() / 1000;
+    assert!(
+        avg_us < 10,
+        "Access request avg: {}μs (target: <1μs)",
+        avg_us
+    );
+
+    // Broadcast performance (<100μs target)
+    let start = Instant::now();
+    for i in 0..100 {
+        let item = WorkspaceItem::new(vec![1.0; 128], 0.8, i, 0);
+        workspace.broadcast(item);
+    }
+    let duration = start.elapsed();
+    let avg_us = duration.as_micros() / 100;
+    assert!(avg_us < 200, "Broadcast avg: {}μs (target: <100μs)", avg_us);
+}
+
+#[test]
+fn test_millers_law_capacity() {
+    // Miller's Law: 7±2 items in working memory
+    for capacity in 5..=9 {
+        let workspace = GlobalWorkspace::new(capacity);
+        assert_eq!(workspace.capacity(), capacity);
+    }
+}
+
+#[test]
+fn test_salience_based_competition() {
+    let mut workspace = GlobalWorkspace::new(3);
+
+    // Fill with medium salience items
+    workspace.broadcast(WorkspaceItem::new(vec![1.0], 0.5, 1, 0));
+    workspace.broadcast(WorkspaceItem::new(vec![2.0], 0.6, 2, 0));
+    workspace.broadcast(WorkspaceItem::new(vec![3.0], 0.4, 3, 0));
+
+    assert!(workspace.is_full());
+
+    // High salience item should replace lowest
+    let high_salience = WorkspaceItem::new(vec![4.0], 0.9, 4, 0);
+    assert!(workspace.broadcast(high_salience));
+
+    // Should still be full
+    assert!(workspace.is_full());
+
+    // Check that lowest salience was removed
+    let items = workspace.retrieve();
+    assert!(items.iter().all(|item| item.salience >= 0.5));
+}