724 lines
27 KiB
Rust
724 lines
27 KiB
Rust
//! Comprehensive Integration Tests for MidStream System
|
|
//!
|
|
//! Tests end-to-end workflows across all crates:
|
|
//! - temporal-compare: Sequence analysis and pattern matching
|
|
//! - nanosecond-scheduler: Real-time scheduling with nanosecond precision
|
|
//! - temporal-attractor-studio: Dynamical systems and attractor analysis
|
|
//! - temporal-neural-solver: Temporal logic verification and neural reasoning
|
|
//! - strange-loop: Meta-learning and self-reference
|
|
//! - quic-multistream: High-performance multiplexed streaming
|
|
|
|
use std::time::Duration;
|
|
|
|
// Import from published crates
|
|
use midstreamer_temporal_compare::{TemporalComparator, Sequence, ComparisonAlgorithm};
|
|
use midstreamer_scheduler::{RealtimeScheduler, SchedulerConfig, Priority, Deadline};
|
|
use midstreamer_attractor::{AttractorAnalyzer, PhasePoint, AttractorType};
|
|
use midstreamer_neural_solver::{TemporalNeuralSolver, TemporalFormula, TemporalState, VerificationStrictness};
|
|
use midstreamer_strange_loop::{StrangeLoop, MetaLevel, StrangeLoopConfig};
|
|
|
|
/// Test 1: Scheduler + Temporal Compare Integration
|
|
///
|
|
/// Scenario:
|
|
/// - Use temporal patterns to predict task priority
|
|
/// - Schedule tasks based on historical pattern similarity
|
|
/// - Verify scheduling order respects pattern-based priorities
|
|
#[test]
|
|
fn test_scheduler_temporal_integration() {
|
|
println!("\n=== Test 1: Scheduler + Temporal Compare Integration ===");
|
|
|
|
let scheduler: RealtimeScheduler<String> = RealtimeScheduler::default();
|
|
let comparator: TemporalComparator<String> = TemporalComparator::new(100, 1000);
|
|
|
|
// Historical execution patterns
|
|
let mut seq1: Sequence<String> = Sequence::new();
|
|
seq1.push("init".to_string(), 0);
|
|
seq1.push("process".to_string(), 100);
|
|
seq1.push("complete".to_string(), 200);
|
|
|
|
let mut seq2: Sequence<String> = Sequence::new();
|
|
seq2.push("init".to_string(), 0);
|
|
seq2.push("process".to_string(), 100);
|
|
seq2.push("complete".to_string(), 200);
|
|
|
|
// Compare sequences to detect patterns
|
|
let result = comparator.compare(&seq1, &seq2, ComparisonAlgorithm::DTW).unwrap();
|
|
println!(" Pattern similarity (DTW): {:.4}", result.distance);
|
|
assert!(result.distance < 1.0, "Should detect identical patterns");
|
|
|
|
// Schedule tasks with priority based on pattern confidence
|
|
let priority = if result.distance < 0.5 {
|
|
Priority::High
|
|
} else {
|
|
Priority::Medium
|
|
};
|
|
|
|
let task_id = scheduler.schedule(
|
|
"pattern_based_task".to_string(),
|
|
Deadline::from_millis(100),
|
|
priority,
|
|
).unwrap();
|
|
|
|
println!(" ✓ Task {} scheduled with {:?} priority", task_id, priority);
|
|
assert_eq!(scheduler.queue_size(), 1);
|
|
|
|
// Verify task retrieval
|
|
let task = scheduler.next_task().unwrap();
|
|
assert_eq!(task.id, task_id);
|
|
assert_eq!(task.priority, priority);
|
|
println!(" ✓ Task retrieved successfully with correct priority");
|
|
|
|
println!("=== Test 1 PASSED ===\n");
|
|
}
|
|
|
|
/// Test 2: Scheduler + Attractor Analysis Integration
|
|
///
|
|
/// Scenario:
|
|
/// - Analyze system behavior dynamics while scheduling tasks
|
|
/// - Detect attractors in task execution patterns
|
|
/// - Adjust scheduling based on stability analysis
|
|
#[test]
|
|
fn test_scheduler_attractor_integration() {
|
|
println!("\n=== Test 2: Scheduler + Attractor Analysis Integration ===");
|
|
|
|
let scheduler: RealtimeScheduler<f64> = RealtimeScheduler::default();
|
|
let mut analyzer = AttractorAnalyzer::new(3, 1000);
|
|
|
|
// Simulate task scheduling with dynamic behavior
|
|
for i in 0..150 {
|
|
let t = i as f64 * 0.1;
|
|
|
|
// Add phase point tracking system state
|
|
let point = PhasePoint::new(
|
|
vec![
|
|
t.sin(), // CPU load
|
|
t.cos(), // Memory usage
|
|
(-t / 10.0).exp(), // Queue depth (decaying)
|
|
],
|
|
i as u64 * 100,
|
|
);
|
|
analyzer.add_point(point).unwrap();
|
|
|
|
// Schedule task with priority based on queue depth
|
|
let priority = if i < 50 {
|
|
Priority::High
|
|
} else if i < 100 {
|
|
Priority::Medium
|
|
} else {
|
|
Priority::Low
|
|
};
|
|
|
|
scheduler.schedule(
|
|
i as f64,
|
|
Deadline::from_millis((i + 10) as u64),
|
|
priority,
|
|
).unwrap();
|
|
}
|
|
|
|
// Analyze attractor to understand system stability
|
|
let attractor_info = analyzer.analyze().unwrap();
|
|
println!(" Attractor type: {:?}", attractor_info.attractor_type);
|
|
println!(" Stable: {}", attractor_info.is_stable);
|
|
println!(" Confidence: {:.2}", attractor_info.confidence);
|
|
println!(" Max Lyapunov: {:.4}", attractor_info.max_lyapunov_exponent().unwrap_or(0.0));
|
|
|
|
// Verify behavior analysis
|
|
assert_eq!(attractor_info.dimension, 3);
|
|
assert!(attractor_info.confidence > 0.5);
|
|
|
|
// Verify scheduler processed all tasks
|
|
assert_eq!(scheduler.queue_size(), 150);
|
|
println!(" ✓ Scheduled 150 tasks with attractor-aware prioritization");
|
|
|
|
// Get scheduler stats
|
|
let stats = scheduler.stats();
|
|
println!(" ✓ Scheduler stats: {} total tasks, {} in queue",
|
|
stats.total_tasks, stats.queue_size);
|
|
assert_eq!(stats.total_tasks, 150);
|
|
|
|
println!("=== Test 2 PASSED ===\n");
|
|
}
|
|
|
|
/// Test 3: Attractor + Neural Solver Integration
|
|
///
|
|
/// Scenario:
|
|
/// - Detect behavioral attractors in system dynamics
|
|
/// - Verify temporal properties using neural solver
|
|
/// - Ensure attractor stability matches temporal invariants
|
|
#[test]
|
|
fn test_attractor_solver_integration() {
|
|
println!("\n=== Test 3: Attractor + Neural Solver Integration ===");
|
|
|
|
let mut analyzer = AttractorAnalyzer::new(2, 1000);
|
|
let mut solver = TemporalNeuralSolver::new(1000, 500, VerificationStrictness::High);
|
|
|
|
// Simulate limit cycle behavior (periodic oscillation)
|
|
for i in 0..200 {
|
|
let t = i as f64 * 0.1;
|
|
|
|
// Create periodic trajectory
|
|
let point = PhasePoint::new(
|
|
vec![t.sin(), t.cos()],
|
|
i as u64 * 10,
|
|
);
|
|
analyzer.add_point(point).unwrap();
|
|
|
|
// Record temporal state
|
|
let mut state = TemporalState::new(i, i * 10);
|
|
state.set_proposition("oscillating", true);
|
|
state.set_proposition("bounded", t.sin().abs() <= 1.0 && t.cos().abs() <= 1.0);
|
|
state.set_proposition("periodic", i % 63 < 5); // Approximate period detection
|
|
solver.add_state(state);
|
|
}
|
|
|
|
// Analyze attractor
|
|
let attractor_info = analyzer.analyze().unwrap();
|
|
println!(" Attractor type: {:?}", attractor_info.attractor_type);
|
|
println!(" Trajectory points: {}", analyzer.trajectory_length());
|
|
|
|
// Verify temporal properties match attractor behavior
|
|
let bounded_formula = TemporalFormula::globally(TemporalFormula::atom("bounded"));
|
|
let bounded_result = solver.verify(&bounded_formula).unwrap();
|
|
|
|
let oscillating_formula = TemporalFormula::globally(TemporalFormula::atom("oscillating"));
|
|
let oscillating_result = solver.verify(&oscillating_formula).unwrap();
|
|
|
|
println!(" ✓ Bounded property: {}", bounded_result.satisfied);
|
|
println!(" ✓ Oscillating property: {}", oscillating_result.satisfied);
|
|
|
|
assert!(bounded_result.satisfied, "Limit cycle should remain bounded");
|
|
assert!(oscillating_result.satisfied, "System should always oscillate");
|
|
|
|
// Verify eventually periodic
|
|
let periodic_formula = TemporalFormula::finally(TemporalFormula::atom("periodic"));
|
|
let periodic_result = solver.verify(&periodic_formula).unwrap();
|
|
assert!(periodic_result.satisfied, "Should detect periodic behavior");
|
|
|
|
println!(" ✓ Attractor analysis matches temporal verification");
|
|
println!("=== Test 3 PASSED ===\n");
|
|
}
|
|
|
|
/// Test 4: Temporal Compare + Neural Solver Integration
|
|
///
|
|
/// Scenario:
|
|
/// - Use pattern matching to identify sequences
|
|
/// - Verify sequence properties with temporal logic
|
|
/// - Ensure pattern similarity correlates with verification confidence
|
|
#[test]
|
|
fn test_temporal_solver_integration() {
|
|
println!("\n=== Test 4: Temporal Compare + Neural Solver Integration ===");
|
|
|
|
let comparator: TemporalComparator<String> = TemporalComparator::new(100, 1000);
|
|
let mut solver = TemporalNeuralSolver::new(1000, 500, VerificationStrictness::Medium);
|
|
|
|
// Create sequences representing system states
|
|
let mut seq1: Sequence<String> = Sequence::new();
|
|
seq1.push("safe".to_string(), 0);
|
|
seq1.push("safe".to_string(), 100);
|
|
seq1.push("safe".to_string(), 200);
|
|
seq1.push("unsafe".to_string(), 300);
|
|
|
|
let mut seq2: Sequence<String> = Sequence::new();
|
|
seq2.push("safe".to_string(), 0);
|
|
seq2.push("safe".to_string(), 100);
|
|
seq2.push("safe".to_string(), 200);
|
|
seq2.push("safe".to_string(), 300);
|
|
|
|
// Compare sequences
|
|
let distance = comparator.compare(&seq1, &seq2, ComparisonAlgorithm::EditDistance).unwrap();
|
|
println!(" Edit distance: {:.4}", distance.distance);
|
|
assert_eq!(distance.distance, 1.0, "Should differ by one element");
|
|
|
|
// Verify temporal properties
|
|
for i in 0..4 {
|
|
let mut state = TemporalState::new(i, i * 100);
|
|
let is_safe = seq2.elements[i as usize].value == "safe";
|
|
state.set_proposition("safe", is_safe);
|
|
solver.add_state(state);
|
|
}
|
|
|
|
// G safe - should be true for seq2
|
|
let safety_formula = TemporalFormula::globally(TemporalFormula::atom("safe"));
|
|
let result = solver.verify(&safety_formula).unwrap();
|
|
|
|
println!(" ✓ Safety property verified: {}", result.satisfied);
|
|
println!(" ✓ Confidence: {:.2}", result.confidence);
|
|
assert!(result.satisfied, "seq2 should maintain safety");
|
|
|
|
println!("=== Test 4 PASSED ===\n");
|
|
}
|
|
|
|
/// Test 5: Full System Integration with Strange Loop
|
|
///
|
|
/// Scenario:
|
|
/// - Meta-learning from complete workflow execution
|
|
/// - Integrate all crates in hierarchical meta-analysis
|
|
/// - Verify self-referential optimization
|
|
#[test]
|
|
fn test_full_system_strange_loop() {
|
|
println!("\n=== Test 5: Full System Integration with Strange Loop ===");
|
|
|
|
let mut strange_loop = StrangeLoop::new(StrangeLoopConfig {
|
|
max_levels: 5,
|
|
max_knowledge_per_level: 100,
|
|
enable_reflection: true,
|
|
learning_rate: 0.1,
|
|
});
|
|
|
|
let scheduler: RealtimeScheduler<String> = RealtimeScheduler::default();
|
|
let mut analyzer = AttractorAnalyzer::new(3, 1000);
|
|
let mut solver = TemporalNeuralSolver::default();
|
|
|
|
// Level 0: Base-level workflow
|
|
println!(" Level 0: Base workflow execution...");
|
|
let workflow_steps = vec![
|
|
"schedule".to_string(),
|
|
"execute".to_string(),
|
|
"analyze".to_string(),
|
|
"verify".to_string(),
|
|
];
|
|
|
|
strange_loop.learn_at_level(MetaLevel::base(), &workflow_steps).unwrap();
|
|
|
|
// Schedule tasks for each workflow step
|
|
for (i, step) in workflow_steps.iter().enumerate() {
|
|
scheduler.schedule(
|
|
step.clone(),
|
|
Deadline::from_millis((i as u64 + 1) * 100),
|
|
Priority::High,
|
|
).unwrap();
|
|
}
|
|
|
|
// Analyze dynamics
|
|
for i in 0..150 {
|
|
let point = PhasePoint::new(
|
|
vec![i as f64, (i as f64).sin(), (i as f64).cos()],
|
|
i as u64,
|
|
);
|
|
analyzer.add_point(point).unwrap();
|
|
}
|
|
|
|
let attractor_info = analyzer.analyze().unwrap();
|
|
|
|
// Verify workflow properties
|
|
for i in 0..workflow_steps.len() {
|
|
let mut state = TemporalState::new(i as u64, i as u64 * 100);
|
|
state.set_proposition("scheduled", i >= 0);
|
|
state.set_proposition("executed", i >= 1);
|
|
state.set_proposition("analyzed", i >= 2);
|
|
state.set_proposition("verified", i >= 3);
|
|
solver.add_state(state);
|
|
}
|
|
|
|
// Level 1: Meta-learning from workflow patterns
|
|
println!(" Level 1: Meta-learning from patterns...");
|
|
let meta_patterns = vec![
|
|
format!("attractor:{:?}", attractor_info.attractor_type),
|
|
format!("stable:{}", attractor_info.is_stable),
|
|
];
|
|
strange_loop.learn_at_level(MetaLevel(1), &meta_patterns).unwrap();
|
|
|
|
// Level 2: Analyze behavioral dynamics
|
|
println!(" Level 2: Behavioral dynamics analysis...");
|
|
let trajectory_data: Vec<Vec<f64>> = (0..150)
|
|
.map(|i| vec![i as f64, (i as f64).sin(), (i as f64).cos()])
|
|
.collect();
|
|
|
|
let behavior_type = strange_loop.analyze_behavior(trajectory_data).unwrap();
|
|
println!(" ✓ Detected behavior: {}", behavior_type);
|
|
|
|
// Verify meta-learning effectiveness
|
|
let summary = strange_loop.get_summary();
|
|
println!(" ✓ Meta-learning summary:");
|
|
println!(" - Total levels: {}", summary.total_levels);
|
|
println!(" - Total knowledge: {}", summary.total_knowledge);
|
|
println!(" - Learning iterations: {}", summary.learning_iterations);
|
|
|
|
assert!(summary.total_levels >= 2);
|
|
assert!(summary.total_knowledge > 0);
|
|
assert!(summary.learning_iterations > 0);
|
|
|
|
// Verify workflow completion
|
|
let eventually_verified = TemporalFormula::finally(TemporalFormula::atom("verified"));
|
|
let result = solver.verify(&eventually_verified).unwrap();
|
|
assert!(result.satisfied, "Workflow should eventually verify");
|
|
|
|
println!(" ✓ Complete system integration verified");
|
|
println!("=== Test 5 PASSED ===\n");
|
|
}
|
|
|
|
/// Test 6: Error Propagation Across Crates
|
|
///
|
|
/// Scenario:
|
|
/// - Test error handling in each crate
|
|
/// - Verify errors propagate correctly across boundaries
|
|
/// - Ensure graceful degradation
|
|
#[test]
|
|
fn test_error_propagation() {
|
|
println!("\n=== Test 6: Error Propagation ===");
|
|
|
|
// Test 1: Attractor analyzer dimension mismatch
|
|
let mut analyzer = AttractorAnalyzer::new(3, 1000);
|
|
let invalid_point = PhasePoint::new(vec![1.0, 2.0], 100);
|
|
let result = analyzer.add_point(invalid_point);
|
|
assert!(result.is_err(), "Should error on dimension mismatch");
|
|
println!(" ✓ Attractor dimension validation works");
|
|
|
|
// Test 2: Attractor analyzer insufficient data
|
|
let analyzer2 = AttractorAnalyzer::new(2, 1000);
|
|
let result = analyzer2.analyze();
|
|
assert!(result.is_err(), "Should error on insufficient data");
|
|
println!(" ✓ Attractor insufficient data detection works");
|
|
|
|
// Test 3: Temporal solver empty trace
|
|
let solver = TemporalNeuralSolver::default();
|
|
let formula = TemporalFormula::atom("test");
|
|
let result = solver.verify(&formula);
|
|
assert!(result.is_err(), "Should error on empty trace");
|
|
println!(" ✓ Temporal solver empty trace detection works");
|
|
|
|
// Test 4: Scheduler queue full
|
|
let scheduler: RealtimeScheduler<String> = RealtimeScheduler::new(SchedulerConfig {
|
|
max_queue_size: 5,
|
|
..Default::default()
|
|
});
|
|
|
|
for i in 0..10 {
|
|
let result = scheduler.schedule(
|
|
format!("task_{}", i),
|
|
Deadline::from_millis(100),
|
|
Priority::Medium,
|
|
);
|
|
if i >= 5 {
|
|
assert!(result.is_err(), "Should error when queue is full");
|
|
}
|
|
}
|
|
println!(" ✓ Scheduler queue overflow detection works");
|
|
|
|
// Test 5: Strange loop max depth
|
|
let mut strange_loop = StrangeLoop::default();
|
|
let deep_level = MetaLevel(10);
|
|
let data = vec!["test".to_string()];
|
|
let result = strange_loop.learn_at_level(deep_level, &data);
|
|
assert!(result.is_err(), "Should error on max depth exceeded");
|
|
println!(" ✓ Strange loop depth limit enforcement works");
|
|
|
|
// Test 6: Temporal comparator sequence too long
|
|
let comparator: TemporalComparator<i32> = TemporalComparator::new(100, 100);
|
|
let mut long_seq: Sequence<i32> = Sequence::new();
|
|
for i in 0..200 {
|
|
long_seq.push(i, i as u64);
|
|
}
|
|
let mut short_seq: Sequence<i32> = Sequence::new();
|
|
short_seq.push(1, 0);
|
|
|
|
let result = comparator.compare(&long_seq, &short_seq, ComparisonAlgorithm::DTW);
|
|
assert!(result.is_err(), "Should error on sequence too long");
|
|
println!(" ✓ Temporal comparator length validation works");
|
|
|
|
println!("=== Test 6 PASSED ===\n");
|
|
}
|
|
|
|
/// Test 7: Performance and Scalability
|
|
///
|
|
/// Scenario:
|
|
/// - Test throughput under load
|
|
/// - Verify latency requirements (<1ms for scheduler)
|
|
/// - Ensure cache effectiveness
|
|
#[test]
|
|
fn test_performance_scalability() {
|
|
println!("\n=== Test 7: Performance and Scalability ===");
|
|
|
|
use std::time::Instant;
|
|
|
|
// Test 1: Scheduler throughput
|
|
let start = Instant::now();
|
|
let scheduler: RealtimeScheduler<u64> = RealtimeScheduler::default();
|
|
|
|
for i in 0..1000 {
|
|
scheduler.schedule(
|
|
i,
|
|
Deadline::from_millis(100),
|
|
Priority::Medium,
|
|
).unwrap();
|
|
}
|
|
|
|
let duration = start.elapsed();
|
|
println!(" ✓ Scheduled 1000 tasks in {:?}", duration);
|
|
println!(" ✓ Average latency: {:?} per task", duration / 1000);
|
|
assert!(duration.as_millis() < 100, "Should schedule fast");
|
|
|
|
// Test 2: Temporal comparison with caching
|
|
let start = Instant::now();
|
|
let comparator: TemporalComparator<i32> = TemporalComparator::new(1000, 10000);
|
|
|
|
let mut seq1: Sequence<i32> = Sequence::new();
|
|
let mut seq2: Sequence<i32> = Sequence::new();
|
|
for i in 0..100 {
|
|
seq1.push(i, i as u64);
|
|
seq2.push(i, i as u64);
|
|
}
|
|
|
|
// First comparison - cache miss
|
|
let _result1 = comparator.compare(&seq1, &seq2, ComparisonAlgorithm::DTW).unwrap();
|
|
|
|
// Second comparison - cache hit
|
|
let _result2 = comparator.compare(&seq1, &seq2, ComparisonAlgorithm::DTW).unwrap();
|
|
|
|
let duration = start.elapsed();
|
|
println!(" ✓ Compared 100-element sequences (2x) in {:?}", duration);
|
|
|
|
let stats = comparator.cache_stats();
|
|
println!(" ✓ Cache hits: {}, misses: {}", stats.hits, stats.misses);
|
|
println!(" ✓ Cache hit rate: {:.2}%", stats.hit_rate() * 100.0);
|
|
assert!(stats.hits >= 1, "Should have at least one cache hit");
|
|
|
|
// Test 3: Attractor analysis performance
|
|
let start = Instant::now();
|
|
let mut analyzer = AttractorAnalyzer::new(3, 10000);
|
|
|
|
for i in 0..1000 {
|
|
let point = PhasePoint::new(
|
|
vec![(i as f64).sin(), (i as f64).cos(), i as f64 * 0.01],
|
|
i,
|
|
);
|
|
analyzer.add_point(point).unwrap();
|
|
}
|
|
|
|
let duration = start.elapsed();
|
|
println!(" ✓ Added 1000 phase points in {:?}", duration);
|
|
|
|
let start = Instant::now();
|
|
let _info = analyzer.analyze().unwrap();
|
|
let analysis_duration = start.elapsed();
|
|
println!(" ✓ Analyzed trajectory in {:?}", analysis_duration);
|
|
|
|
println!("=== Test 7 PASSED ===\n");
|
|
}
|
|
|
|
/// Test 8: Pattern Detection Pipeline
|
|
///
|
|
/// Scenario:
|
|
/// - Detect patterns using temporal compare
|
|
/// - Analyze pattern stability with attractors
|
|
/// - Verify pattern properties with solver
|
|
#[test]
|
|
fn test_pattern_detection_pipeline() {
|
|
println!("\n=== Test 8: Pattern Detection Pipeline ===");
|
|
|
|
let comparator: TemporalComparator<f64> = TemporalComparator::new(100, 1000);
|
|
|
|
// Time series with repeating pattern
|
|
let series = vec![1.0, 2.0, 3.0, 2.0, 1.0, 1.0, 2.0, 3.0, 2.0, 1.0, 5.0, 6.0];
|
|
let pattern = vec![1.0, 2.0, 3.0, 2.0, 1.0];
|
|
|
|
// Find similar patterns
|
|
let matches = comparator.find_similar(&series, &pattern, 1.0);
|
|
println!(" Found {} pattern matches", matches.len());
|
|
|
|
for (idx, dist) in &matches {
|
|
println!(" Match at index {} with distance {:.4}", idx, dist);
|
|
}
|
|
|
|
assert!(matches.len() >= 2, "Should find repeated pattern");
|
|
assert_eq!(matches[0].0, 0, "First match at index 0");
|
|
assert_eq!(matches[1].0, 5, "Second match at index 5");
|
|
|
|
// Test pattern detection
|
|
let detected = comparator.detect_pattern(&series, &pattern, 1.0);
|
|
assert!(detected, "Pattern should be detected");
|
|
|
|
let no_match = comparator.detect_pattern(&series, &vec![10.0, 20.0, 30.0], 1.0);
|
|
assert!(!no_match, "Non-existent pattern should not be detected");
|
|
|
|
println!(" ✓ Pattern detection pipeline verified");
|
|
println!("=== Test 8 PASSED ===\n");
|
|
}
|
|
|
|
/// Test 9: State Management and Recovery
|
|
///
|
|
/// Scenario:
|
|
/// - Test state persistence and recovery
|
|
/// - Verify clear/reset operations
|
|
/// - Ensure no memory leaks
|
|
#[test]
|
|
fn test_state_management() {
|
|
println!("\n=== Test 9: State Management and Recovery ===");
|
|
|
|
// Test 1: Attractor analyzer clear
|
|
let mut analyzer = AttractorAnalyzer::new(2, 1000);
|
|
|
|
for i in 0..50 {
|
|
analyzer.add_point(PhasePoint::new(vec![i as f64, i as f64], i)).unwrap();
|
|
}
|
|
|
|
assert_eq!(analyzer.trajectory_length(), 50);
|
|
analyzer.clear();
|
|
assert_eq!(analyzer.trajectory_length(), 0);
|
|
println!(" ✓ Attractor analyzer clear works");
|
|
|
|
// Test 2: Temporal solver trace clear
|
|
let mut solver = TemporalNeuralSolver::default();
|
|
|
|
for i in 0..20 {
|
|
let mut state = TemporalState::new(i, i * 100);
|
|
state.set_proposition("test", true);
|
|
solver.add_state(state);
|
|
}
|
|
|
|
assert_eq!(solver.trace_length(), 20);
|
|
solver.clear_trace();
|
|
assert_eq!(solver.trace_length(), 0);
|
|
println!(" ✓ Temporal solver clear works");
|
|
|
|
// Test 3: Strange loop reset
|
|
let mut strange_loop = StrangeLoop::default();
|
|
|
|
strange_loop.learn_at_level(MetaLevel::base(), &vec!["a".to_string()]).unwrap();
|
|
let before = strange_loop.get_summary();
|
|
assert!(before.total_knowledge > 0);
|
|
|
|
strange_loop.reset();
|
|
let after = strange_loop.get_summary();
|
|
assert_eq!(after.total_knowledge, 0);
|
|
println!(" ✓ Strange loop reset works");
|
|
|
|
// Test 4: Scheduler clear
|
|
let scheduler: RealtimeScheduler<String> = RealtimeScheduler::default();
|
|
|
|
for i in 0..10 {
|
|
scheduler.schedule(
|
|
format!("task_{}", i),
|
|
Deadline::from_millis(100),
|
|
Priority::Medium,
|
|
).unwrap();
|
|
}
|
|
|
|
assert_eq!(scheduler.queue_size(), 10);
|
|
scheduler.clear();
|
|
assert_eq!(scheduler.queue_size(), 0);
|
|
println!(" ✓ Scheduler clear works");
|
|
|
|
// Test 5: Temporal comparator cache clear
|
|
let comparator: TemporalComparator<i32> = TemporalComparator::new(100, 1000);
|
|
|
|
let mut seq1: Sequence<i32> = Sequence::new();
|
|
let mut seq2: Sequence<i32> = Sequence::new();
|
|
seq1.push(1, 0);
|
|
seq2.push(1, 0);
|
|
|
|
comparator.compare(&seq1, &seq2, ComparisonAlgorithm::DTW).unwrap();
|
|
let stats_before = comparator.cache_stats();
|
|
assert!(stats_before.size > 0 || stats_before.misses > 0);
|
|
|
|
comparator.clear_cache();
|
|
let stats_after = comparator.cache_stats();
|
|
assert_eq!(stats_after.size, 0);
|
|
println!(" ✓ Temporal comparator cache clear works");
|
|
|
|
println!("=== Test 9 PASSED ===\n");
|
|
}
|
|
|
|
/// Test 10: Deadline and Priority Handling
|
|
///
|
|
/// Scenario:
|
|
/// - Schedule tasks with various deadlines
|
|
/// - Verify priority-based execution order
|
|
/// - Test deadline miss detection
|
|
#[test]
|
|
fn test_deadline_priority_handling() {
|
|
println!("\n=== Test 10: Deadline and Priority Handling ===");
|
|
|
|
let scheduler: RealtimeScheduler<String> = RealtimeScheduler::default();
|
|
scheduler.start();
|
|
|
|
// Schedule tasks with different priorities
|
|
let low_id = scheduler.schedule(
|
|
"low_priority".to_string(),
|
|
Deadline::from_millis(100),
|
|
Priority::Low,
|
|
).unwrap();
|
|
|
|
let high_id = scheduler.schedule(
|
|
"high_priority".to_string(),
|
|
Deadline::from_millis(100),
|
|
Priority::High,
|
|
).unwrap();
|
|
|
|
let critical_id = scheduler.schedule(
|
|
"critical_priority".to_string(),
|
|
Deadline::from_millis(100),
|
|
Priority::Critical,
|
|
).unwrap();
|
|
|
|
// Verify priority ordering
|
|
let task1 = scheduler.next_task().unwrap();
|
|
assert_eq!(task1.id, critical_id, "Critical priority should execute first");
|
|
assert_eq!(task1.priority, Priority::Critical);
|
|
|
|
let task2 = scheduler.next_task().unwrap();
|
|
assert_eq!(task2.id, high_id, "High priority should execute second");
|
|
|
|
let task3 = scheduler.next_task().unwrap();
|
|
assert_eq!(task3.id, low_id, "Low priority should execute last");
|
|
|
|
println!(" ✓ Priority-based execution order verified");
|
|
|
|
// Test deadline miss detection
|
|
std::thread::sleep(Duration::from_millis(10));
|
|
let past_deadline = Deadline::from_micros(1);
|
|
|
|
scheduler.schedule(
|
|
"late_task".to_string(),
|
|
past_deadline,
|
|
Priority::High,
|
|
).unwrap();
|
|
|
|
let late_task = scheduler.next_task().unwrap();
|
|
scheduler.execute_task(late_task, |_payload| {
|
|
// Task execution
|
|
});
|
|
|
|
let stats = scheduler.stats();
|
|
println!(" ✓ Completed tasks: {}", stats.completed_tasks);
|
|
println!(" ✓ Average latency: {} ns", stats.average_latency_ns);
|
|
|
|
scheduler.stop();
|
|
assert!(!scheduler.is_running());
|
|
println!(" ✓ Scheduler lifecycle management works");
|
|
|
|
println!("=== Test 10 PASSED ===\n");
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod summary {
|
|
#[test]
|
|
fn print_test_summary() {
|
|
println!("\n");
|
|
println!("╔═══════════════════════════════════════════════════════════════╗");
|
|
println!("║ MidStream Integration Test Suite ║");
|
|
println!("╠═══════════════════════════════════════════════════════════════╣");
|
|
println!("║ ║");
|
|
println!("║ ✓ Test 1: Scheduler + Temporal Compare ║");
|
|
println!("║ ✓ Test 2: Scheduler + Attractor Analysis ║");
|
|
println!("║ ✓ Test 3: Attractor + Neural Solver ║");
|
|
println!("║ ✓ Test 4: Temporal Compare + Neural Solver ║");
|
|
println!("║ ✓ Test 5: Full System with Strange Loop ║");
|
|
println!("║ ✓ Test 6: Error Propagation ║");
|
|
println!("║ ✓ Test 7: Performance and Scalability ║");
|
|
println!("║ ✓ Test 8: Pattern Detection Pipeline ║");
|
|
println!("║ ✓ Test 9: State Management and Recovery ║");
|
|
println!("║ ✓ Test 10: Deadline and Priority Handling ║");
|
|
println!("║ ║");
|
|
println!("║ Coverage: ║");
|
|
println!("║ - Cross-crate integration: ✓ ║");
|
|
println!("║ - Real-world scenarios: ✓ ║");
|
|
println!("║ - Error handling: ✓ ║");
|
|
println!("║ - Performance validation: ✓ ║");
|
|
println!("║ - State management: ✓ ║");
|
|
println!("║ ║");
|
|
println!("╚═══════════════════════════════════════════════════════════════╝");
|
|
println!("\n");
|
|
}
|
|
}
|