mirror of
https://github.com/ruvnet/RuView
synced 2026-08-04 19:31:42 +00:00
feat: vendor midstream and sublinear-time-solver libraries
Add ruvnet/midstream (AIMDS real-time inference) and ruvnet/sublinear-time-solver (sublinear optimization algorithms) as vendored dependencies under vendor/. Co-Authored-By: claude-flow <ruv@ruv.net>
This commit is contained in:
ruv
+310
@@ -0,0 +1,310 @@
|
||||
//! Comprehensive simulation tests for various real-world scenarios
|
||||
|
||||
use midstream::{
|
||||
LeanAgenticSystem, LeanAgenticConfig, AgentContext,
|
||||
KnowledgeGraph, Entity, EntityType, Relation,
|
||||
};
|
||||
use std::time::Instant;
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_weather_intent_simulation() {
|
||||
let config = LeanAgenticConfig::default();
|
||||
let system = LeanAgenticSystem::new(config);
|
||||
let mut context = AgentContext::new("weather_session".to_string());
|
||||
|
||||
let messages = vec![
|
||||
"What's the weather like today?",
|
||||
"How about tomorrow?",
|
||||
"Will it rain this weekend?",
|
||||
"Should I bring an umbrella?",
|
||||
];
|
||||
|
||||
for (i, msg) in messages.iter().enumerate() {
|
||||
let result = system.process_stream_chunk(msg, context.clone()).await;
|
||||
assert!(result.is_ok(), "Message {} failed: {:?}", i, result);
|
||||
|
||||
let res = result.unwrap();
|
||||
println!("Message: {}", msg);
|
||||
println!(" Action: {}", res.action.description);
|
||||
println!(" Reward: {:.3}", res.reward);
|
||||
println!(" Verified: {}", res.verified);
|
||||
|
||||
context.add_message(msg.to_string());
|
||||
}
|
||||
|
||||
// Verify learning occurred
|
||||
let stats = system.get_stats().await;
|
||||
assert!(stats.total_actions >= messages.len() as u64);
|
||||
println!("\nFinal stats: {:?}", stats);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_knowledge_accumulation_simulation() {
|
||||
let config = LeanAgenticConfig::default();
|
||||
let system = LeanAgenticSystem::new(config);
|
||||
let mut context = AgentContext::new("learning_session".to_string());
|
||||
|
||||
let learning_sequence = vec![
|
||||
"My name is Alice and I work at Google",
|
||||
"I live in San Francisco",
|
||||
"I prefer detailed weather forecasts",
|
||||
"My favorite color is blue",
|
||||
"I usually wake up at 7 AM",
|
||||
];
|
||||
|
||||
for msg in &learning_sequence {
|
||||
let result = system.process_stream_chunk(msg, context.clone()).await.unwrap();
|
||||
context.add_message(msg.to_string());
|
||||
context.set_preference("detail_level".to_string(), 0.9);
|
||||
}
|
||||
|
||||
let stats = system.get_stats().await;
|
||||
|
||||
// Verify knowledge was accumulated
|
||||
assert!(stats.total_entities > 0, "No entities extracted");
|
||||
assert!(stats.learning_iterations > 0, "No learning occurred");
|
||||
|
||||
println!("Knowledge accumulation results:");
|
||||
println!(" Entities: {}", stats.total_entities);
|
||||
println!(" Learning iterations: {}", stats.learning_iterations);
|
||||
println!(" Average reward: {:.3}", stats.average_reward);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_high_frequency_streaming_simulation() {
|
||||
let config = LeanAgenticConfig {
|
||||
enable_formal_verification: false, // Disable for speed
|
||||
learning_rate: 0.05,
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
let system = LeanAgenticSystem::new(config);
|
||||
let context = AgentContext::new("streaming_session".to_string());
|
||||
|
||||
let start = Instant::now();
|
||||
let num_chunks = 1000;
|
||||
|
||||
for i in 0..num_chunks {
|
||||
let chunk = format!("Stream chunk {}", i);
|
||||
let result = system.process_stream_chunk(&chunk, context.clone()).await;
|
||||
assert!(result.is_ok(), "Chunk {} failed", i);
|
||||
}
|
||||
|
||||
let duration = start.elapsed();
|
||||
let chunks_per_sec = num_chunks as f64 / duration.as_secs_f64();
|
||||
|
||||
println!("\nHigh-frequency streaming results:");
|
||||
println!(" Total chunks: {}", num_chunks);
|
||||
println!(" Duration: {:?}", duration);
|
||||
println!(" Throughput: {:.2} chunks/sec", chunks_per_sec);
|
||||
println!(" Avg latency: {:.2} ms/chunk", duration.as_millis() as f64 / num_chunks as f64);
|
||||
|
||||
// Verify minimum throughput
|
||||
assert!(chunks_per_sec > 50.0, "Throughput too low: {:.2} chunks/sec", chunks_per_sec);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_concurrent_sessions_simulation() {
|
||||
let config = LeanAgenticConfig::default();
|
||||
let system = LeanAgenticSystem::new(config);
|
||||
|
||||
let num_sessions = 100;
|
||||
let mut handles = vec![];
|
||||
|
||||
let start = Instant::now();
|
||||
|
||||
for i in 0..num_sessions {
|
||||
let sys = &system;
|
||||
let handle = tokio::spawn(async move {
|
||||
let context = AgentContext::new(format!("session_{}", i));
|
||||
let messages = vec![
|
||||
"Hello",
|
||||
"What's the weather?",
|
||||
"Thank you",
|
||||
];
|
||||
|
||||
for msg in messages {
|
||||
sys.process_stream_chunk(msg, context.clone()).await.unwrap();
|
||||
}
|
||||
});
|
||||
handles.push(handle);
|
||||
}
|
||||
|
||||
for handle in handles {
|
||||
handle.await.unwrap();
|
||||
}
|
||||
|
||||
let duration = start.elapsed();
|
||||
|
||||
println!("\nConcurrent sessions results:");
|
||||
println!(" Sessions: {}", num_sessions);
|
||||
println!(" Duration: {:?}", duration);
|
||||
println!(" Avg per session: {:.2} ms", duration.as_millis() as f64 / num_sessions as f64);
|
||||
|
||||
let stats = system.get_stats().await;
|
||||
println!(" Total actions: {}", stats.total_actions);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_learning_convergence_simulation() {
|
||||
let config = LeanAgenticConfig {
|
||||
learning_rate: 0.1, // Higher learning rate for faster convergence
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
let system = LeanAgenticSystem::new(config);
|
||||
let mut context = AgentContext::new("convergence_session".to_string());
|
||||
|
||||
// Repeat the same pattern to test learning convergence
|
||||
let pattern = "What is the weather in Tokyo?";
|
||||
let mut rewards = vec![];
|
||||
|
||||
for iteration in 0..100 {
|
||||
let result = system.process_stream_chunk(pattern, context.clone()).await.unwrap();
|
||||
rewards.push(result.reward);
|
||||
|
||||
if iteration % 10 == 0 {
|
||||
println!("Iteration {}: reward = {:.3}", iteration, result.reward);
|
||||
}
|
||||
|
||||
context.add_message(pattern.to_string());
|
||||
}
|
||||
|
||||
// Check if rewards are improving (basic convergence check)
|
||||
let early_avg: f64 = rewards[0..20].iter().sum::<f64>() / 20.0;
|
||||
let late_avg: f64 = rewards[80..100].iter().sum::<f64>() / 20.0;
|
||||
|
||||
println!("\nLearning convergence results:");
|
||||
println!(" Early average reward (0-20): {:.3}", early_avg);
|
||||
println!(" Late average reward (80-100): {:.3}", late_avg);
|
||||
println!(" Improvement: {:.3}", late_avg - early_avg);
|
||||
|
||||
// Rewards should stabilize or improve
|
||||
assert!(late_avg >= early_avg * 0.8, "Learning degraded significantly");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_knowledge_graph_scaling() {
|
||||
let mut kg = KnowledgeGraph::new();
|
||||
|
||||
let start = Instant::now();
|
||||
let num_entities = 10000;
|
||||
|
||||
// Add many entities
|
||||
for i in 0..num_entities {
|
||||
let entity = Entity {
|
||||
id: format!("entity_{}", i),
|
||||
name: format!("Entity {}", i),
|
||||
entity_type: if i % 3 == 0 {
|
||||
EntityType::Person
|
||||
} else if i % 3 == 1 {
|
||||
EntityType::Organization
|
||||
} else {
|
||||
EntityType::Concept
|
||||
},
|
||||
attributes: std::collections::HashMap::new(),
|
||||
confidence: 0.9,
|
||||
};
|
||||
|
||||
kg.update(vec![entity]).await.unwrap();
|
||||
}
|
||||
|
||||
let insert_duration = start.elapsed();
|
||||
|
||||
// Add relations
|
||||
let relation_start = Instant::now();
|
||||
for i in 0..1000 {
|
||||
kg.add_relation(Relation {
|
||||
id: format!("rel_{}", i),
|
||||
subject: format!("entity_{}", i * 10),
|
||||
predicate: "relates_to".to_string(),
|
||||
object: format!("entity_{}", i * 10 + 1),
|
||||
confidence: 0.85,
|
||||
source: "test".to_string(),
|
||||
});
|
||||
}
|
||||
let relation_duration = relation_start.elapsed();
|
||||
|
||||
// Query performance
|
||||
let query_start = Instant::now();
|
||||
let results = kg.query_entities(EntityType::Person);
|
||||
let query_duration = query_start.elapsed();
|
||||
|
||||
println!("\nKnowledge graph scaling results:");
|
||||
println!(" Entities inserted: {}", num_entities);
|
||||
println!(" Insert time: {:?}", insert_duration);
|
||||
println!(" Insert rate: {:.2} entities/sec", num_entities as f64 / insert_duration.as_secs_f64());
|
||||
println!(" Relations added: 1000");
|
||||
println!(" Relation time: {:?}", relation_duration);
|
||||
println!(" Query time: {:?}", query_duration);
|
||||
println!(" Results found: {}", results.len());
|
||||
|
||||
assert_eq!(kg.entity_count(), num_entities);
|
||||
assert_eq!(kg.relation_count(), 1000);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_adaptive_behavior_simulation() {
|
||||
let config = LeanAgenticConfig {
|
||||
learning_rate: 0.05,
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
let system = LeanAgenticSystem::new(config);
|
||||
let mut context = AgentContext::new("adaptive_session".to_string());
|
||||
|
||||
// Phase 1: Weather queries
|
||||
println!("\nPhase 1: Weather queries");
|
||||
for i in 0..10 {
|
||||
let msg = format!("What's the weather in city {}?", i);
|
||||
let result = system.process_stream_chunk(&msg, context.clone()).await.unwrap();
|
||||
context.add_message(msg);
|
||||
if i == 0 || i == 9 {
|
||||
println!(" Iteration {}: reward = {:.3}", i, result.reward);
|
||||
}
|
||||
}
|
||||
|
||||
// Phase 2: Switch to learning/memory queries
|
||||
println!("\nPhase 2: Learning queries");
|
||||
for i in 0..10 {
|
||||
let msg = format!("Remember that I like {}", i);
|
||||
let result = system.process_stream_chunk(&msg, context.clone()).await.unwrap();
|
||||
context.add_message(msg);
|
||||
if i == 0 || i == 9 {
|
||||
println!(" Iteration {}: reward = {:.3}", i, result.reward);
|
||||
}
|
||||
}
|
||||
|
||||
let stats = system.get_stats().await;
|
||||
println!("\nAdaptive behavior stats:");
|
||||
println!(" Total actions: {}", stats.total_actions);
|
||||
println!(" Average reward: {:.3}", stats.average_reward);
|
||||
println!(" Entities learned: {}", stats.total_entities);
|
||||
|
||||
assert!(stats.total_actions >= 20);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_memory_efficiency() {
|
||||
use std::mem::size_of;
|
||||
|
||||
println!("\nMemory efficiency analysis:");
|
||||
println!(" AgentContext: {} bytes", size_of::<AgentContext>());
|
||||
println!(" Entity: {} bytes", size_of::<Entity>());
|
||||
println!(" Relation: {} bytes", size_of::<Relation>());
|
||||
|
||||
// Test memory growth with many sessions
|
||||
let config = LeanAgenticConfig::default();
|
||||
let system = LeanAgenticSystem::new(config);
|
||||
|
||||
for i in 0..100 {
|
||||
let context = AgentContext::new(format!("session_{}", i));
|
||||
system.process_stream_chunk("test", context).await.unwrap();
|
||||
}
|
||||
|
||||
let stats = system.get_stats().await;
|
||||
println!(" Sessions processed: 100");
|
||||
println!(" Total entities: {}", stats.total_entities);
|
||||
println!(" Estimated memory per session: ~{} KB",
|
||||
(stats.total_entities * size_of::<Entity>()) / 100 / 1024);
|
||||
}
|
||||
Reference in New Issue
Block a user