diff --git a/Cargo.lock b/Cargo.lock index b50e904a8..1010b064c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -14,16 +14,13 @@ dependencies = [ "criterion", "futures", "num-traits", - "proptest", "rand 0.8.5", "rust_decimal", "serde", "serde_json", "thiserror 1.0.69", "tokio", - "tokio-test", "tracing", - "tracing-subscriber", "uuid 1.18.1", ] @@ -8199,7 +8196,6 @@ dependencies = [ "serde_json", "sha2", "sqlx", - "tempfile", "thiserror 1.0.69", "tokio", "tokio-util", diff --git a/adaptive-strategy/Cargo.toml b/adaptive-strategy/Cargo.toml index 701b3cdcf..1f5dd2c93 100644 --- a/adaptive-strategy/Cargo.toml +++ b/adaptive-strategy/Cargo.toml @@ -64,11 +64,8 @@ minimal = [] # Minimal adaptive strategies without heavy ML # cuda, cudnn, gpu - MOVED TO ml_training_service [dev-dependencies] -tokio-test = { workspace = true } -proptest = { workspace = true } criterion = { workspace = true, features = ["html_reports", "async_tokio"] } futures = { workspace = true } -tracing-subscriber = { workspace = true } [[bench]] name = "tlob_performance" diff --git a/adaptive-strategy/src/execution/mod.rs b/adaptive-strategy/src/execution/mod.rs index 85009609f..3775ab71f 100644 --- a/adaptive-strategy/src/execution/mod.rs +++ b/adaptive-strategy/src/execution/mod.rs @@ -1261,10 +1261,10 @@ mod tests { #[test] fn test_execution_engine_creation() { let config = ExecutionConfig { - algorithm: crate::config::ExecutionAlgorithm::TWAP, + algorithm: ExecutionAlgorithm::TWAP, max_order_size: 10000.0, min_order_size: 100.0, - order_timeout: std::time::Duration::from_secs(30), + order_timeout: Duration::from_secs(30), max_slippage_bps: 10.0, smart_routing_enabled: true, dark_pool_preference: 0.3, @@ -1294,15 +1294,15 @@ mod tests { #[test] fn test_twap_algorithm() { - let mut twap = TWAPAlgorithm::new().unwrap(); - let mut order_manager = OrderManager::new(); + let twap = TWAPAlgorithm::new().unwrap(); + let _order_manager = OrderManager::new(); - let request = ExecutionRequest { + let _request = ExecutionRequest { id: "REQ001".to_string(), symbol: "BTC-USD".to_string(), side: OrderSide::Buy, quantity: 1000.0, - algorithm: crate::config::ExecutionAlgorithm::TWAP, + algorithm: ExecutionAlgorithm::TWAP, parameters: HashMap::new(), max_slippage_bps: 10.0, deadline: None, diff --git a/adaptive-strategy/src/lib.rs b/adaptive-strategy/src/lib.rs index b1c94fc1a..95ecc32fd 100644 --- a/adaptive-strategy/src/lib.rs +++ b/adaptive-strategy/src/lib.rs @@ -48,6 +48,10 @@ pub mod models; pub mod regime; pub mod risk; +// Silence unused crate dependencies warning for benchmark-only dependencies +#[cfg(test)] +use criterion as _; + // Import core types from common types crate use anyhow::Result; diff --git a/adaptive-strategy/src/risk/kelly_position_sizer.rs b/adaptive-strategy/src/risk/kelly_position_sizer.rs index ab4b0c12d..b894eb728 100644 --- a/adaptive-strategy/src/risk/kelly_position_sizer.rs +++ b/adaptive-strategy/src/risk/kelly_position_sizer.rs @@ -221,59 +221,78 @@ pub enum VolatilityRegime { /// Portfolio concentration monitoring #[derive(Debug)] +#[allow(dead_code)] pub(super) struct ConcentrationMonitor { /// Current position concentrations by symbol concentrations: HashMap, /// Sector concentrations + #[allow(dead_code)] sector_concentrations: HashMap, /// Geographic concentrations + #[allow(dead_code)] geographic_concentrations: HashMap, /// Asset class concentrations + #[allow(dead_code)] asset_class_concentrations: HashMap, /// Correlation matrix + #[allow(dead_code)] correlation_matrix: CorrelationMatrix, } /// Correlation matrix for position sizing adjustments #[derive(Debug, Clone)] +#[allow(dead_code)] pub(super) struct CorrelationMatrix { /// Symbols included in matrix + #[allow(dead_code)] symbols: Vec, /// Correlation coefficients (symmetric matrix) + #[allow(dead_code)] correlations: Vec>, /// Last update timestamp + #[allow(dead_code)] last_update: DateTime, /// Average correlation + #[allow(dead_code)] avg_correlation: f64, } /// Volatility-based position optimization #[derive(Debug)] +#[allow(dead_code)] pub(super) struct VolatilityOptimizer { /// Volatility estimates by symbol volatility_estimates: HashMap, /// Target portfolio volatility target_volatility: f64, /// Current portfolio volatility + #[allow(dead_code)] current_volatility: f64, /// Volatility forecasting model + #[allow(dead_code)] volatility_model: VolatilityModel, } /// Volatility estimate with confidence intervals #[derive(Debug, Clone)] +#[allow(dead_code)] pub struct VolatilityEstimate { /// Current volatility estimate (annualized) - current: f64, + pub(super) current: f64, /// 1-day ahead forecast + #[allow(dead_code)] forecast_1d: f64, /// 5-day ahead forecast + #[allow(dead_code)] forecast_5d: f64, /// Confidence interval (95%) + #[allow(dead_code)] confidence_interval: (f64, f64), /// Model used for estimation + #[allow(dead_code)] model_type: VolatilityModelType, /// Last update timestamp + #[allow(dead_code)] last_update: DateTime, } @@ -295,96 +314,131 @@ pub(super) enum VolatilityModelType { /// Volatility forecasting model #[derive(Debug)] +#[allow(dead_code)] pub(super) struct VolatilityModel { /// Model parameters + #[allow(dead_code)] parameters: HashMap, /// Model type + #[allow(dead_code)] model_type: VolatilityModelType, /// Calibration history + #[allow(dead_code)] calibration_history: Vec, } /// Volatility model calibration record #[derive(Debug, Clone)] +#[allow(dead_code)] pub(super) struct CalibrationRecord { /// Calibration timestamp + #[allow(dead_code)] timestamp: DateTime, /// Model parameters at calibration + #[allow(dead_code)] parameters: HashMap, /// In-sample error metrics + #[allow(dead_code)] in_sample_error: f64, /// Out-of-sample error metrics + #[allow(dead_code)] out_of_sample_error: Option, } /// Portfolio drawdown tracking #[derive(Debug)] +#[allow(dead_code)] pub struct DrawdownTracker { /// High water mark + #[allow(dead_code)] high_water_mark: f64, /// Current drawdown + #[allow(dead_code)] current_drawdown: f64, /// Maximum drawdown + #[allow(dead_code)] max_drawdown: f64, /// Drawdown start time + #[allow(dead_code)] drawdown_start: Option>, /// Recovery factor (how much to reduce risk during drawdowns) - recovery_factor: f64, + pub(super) recovery_factor: f64, } /// Performance tracking for Kelly optimization #[derive(Debug)] +#[allow(dead_code)] pub(super) struct PerformanceTracker { /// Daily returns history + #[allow(dead_code)] returns_history: Vec, /// Kelly sizing performance - kelly_performance: KellyPerformanceMetrics, + pub(super) kelly_performance: KellyPerformanceMetrics, /// Model accuracy tracking + #[allow(dead_code)] accuracy_tracker: AccuracyTracker, } /// Daily return record #[derive(Debug, Clone)] +#[allow(dead_code)] pub(super) struct DailyReturn { /// Date + #[allow(dead_code)] date: chrono::NaiveDate, /// Portfolio return + #[allow(dead_code)] portfolio_return: f64, /// Kelly-sized positions return + #[allow(dead_code)] kelly_return: f64, /// Attribution by position + #[allow(dead_code)] position_attribution: HashMap, } /// Kelly performance metrics #[derive(Debug, Clone)] +#[allow(dead_code)] pub struct KellyPerformanceMetrics { /// Sharpe ratio + #[allow(dead_code)] sharpe_ratio: f64, /// Sortino ratio + #[allow(dead_code)] sortino_ratio: f64, /// Maximum drawdown + #[allow(dead_code)] max_drawdown: f64, /// Calmar ratio + #[allow(dead_code)] calmar_ratio: f64, /// Win rate + #[allow(dead_code)] win_rate: f64, /// Average win/loss ratio + #[allow(dead_code)] win_loss_ratio: f64, /// Kelly criterion effectiveness + #[allow(dead_code)] kelly_effectiveness: f64, } /// Model accuracy tracking #[derive(Debug)] +#[allow(dead_code)] pub(super) struct AccuracyTracker { /// Prediction accuracy by horizon + #[allow(dead_code)] accuracy_by_horizon: HashMap, /// Calibration score + #[allow(dead_code)] calibration_score: f64, /// Information coefficient + #[allow(dead_code)] information_coefficient: f64, /// Hit rate + #[allow(dead_code)] hit_rate: f64, } @@ -1047,9 +1101,6 @@ mod tests { // Test symbol constants for generic testing const TEST_SYMBOL: &str = "TEST"; - const TEST_SYMBOL_ALT: &str = "TESTSYM"; - const TEST_PRICE: f64 = 100.0; - const TEST_PRICE_ALT: f64 = 150.0; #[tokio::test] async fn test_kelly_position_sizer_creation() { diff --git a/adaptive-strategy/src/risk/mod.rs b/adaptive-strategy/src/risk/mod.rs index 25531b327..41d7561d2 100644 --- a/adaptive-strategy/src/risk/mod.rs +++ b/adaptive-strategy/src/risk/mod.rs @@ -1349,7 +1349,7 @@ mod tests { #[tokio::test] async fn test_dynamic_risk_adjuster() { - let adjuster = kelly_position_sizer::DynamicRiskAdjuster::new(&kelly_position_sizer::KellyConfig::default()).unwrap(); + let adjuster = DynamicRiskAdjuster::new(&KellyConfig::default()).unwrap(); let position_metrics = PositionRiskMetrics { expected_return: 0.05, diff --git a/adaptive-strategy/src/risk/ppo_integration_test.rs b/adaptive-strategy/src/risk/ppo_integration_test.rs index 0df8425c4..c89c1d741 100644 --- a/adaptive-strategy/src/risk/ppo_integration_test.rs +++ b/adaptive-strategy/src/risk/ppo_integration_test.rs @@ -5,8 +5,9 @@ #[cfg(test)] mod tests { - use super::super::{RiskManager, ContinuousTrajectory}; + use super::super::RiskManager; use crate::config::{PositionSizingMethod, RiskConfig}; + use crate::risk::ContinuousTrajectory; use common::MarketRegime; /// Test PPO position sizer creation and basic functionality diff --git a/adaptive-strategy/src/risk/tests.rs b/adaptive-strategy/src/risk/tests.rs index 0895d1fa1..86d9e3598 100644 --- a/adaptive-strategy/src/risk/tests.rs +++ b/adaptive-strategy/src/risk/tests.rs @@ -11,7 +11,6 @@ use super::*; use crate::config::RiskConfig; use std::collections::HashMap; -use tokio_test; // Test symbol constants for generic testing const TEST_SYMBOL_1: &str = "TEST1"; diff --git a/common/src/types.rs b/common/src/types.rs index b02144ed9..2fa1ba5ac 100644 --- a/common/src/types.rs +++ b/common/src/types.rs @@ -4357,8 +4357,8 @@ mod tests { #[test] fn test_symbol_partial_eq_str() { let symbol = Symbol::from_str("AAPL").unwrap(); - assert_eq!(symbol, "AAPL"); assert_eq!("AAPL", symbol); + assert_eq!(symbol.as_str(), "AAPL"); } #[test] diff --git a/risk-data/src/compliance.rs b/risk-data/src/compliance.rs index 75e14177b..8d73fbc5d 100644 --- a/risk-data/src/compliance.rs +++ b/risk-data/src/compliance.rs @@ -879,7 +879,7 @@ mod tests { #[allow(unreachable_code)] #[test] fn test_compliance_event_validation() { - let repo = ComplianceRepositoryImpl { + let _repo = ComplianceRepositoryImpl { db_pool: panic!("Test DB connection not needed"), redis_conn: panic!("Mock Redis connection"), }; @@ -908,13 +908,13 @@ mod tests { regulator_reference: None, }; - assert!(repo.validate_event(&event).is_err()); + assert!(_repo.validate_event(&event).is_err()); } #[allow(unreachable_code)] #[test] fn test_risk_score_calculation() { - let repo = ComplianceRepositoryImpl { + let _repo = ComplianceRepositoryImpl { db_pool: panic!("Test DB connection not needed"), redis_conn: panic!("Mock Redis connection"), }; @@ -943,7 +943,7 @@ mod tests { regulator_reference: None, }; - let score = repo.calculate_risk_score(&event); + let score = _repo.calculate_risk_score(&event); assert!(score > Decimal::ZERO); assert!(score <= Decimal::from(100)); } diff --git a/risk-data/src/limits.rs b/risk-data/src/limits.rs index 1bb7eb90c..2dd60efcb 100644 --- a/risk-data/src/limits.rs +++ b/risk-data/src/limits.rs @@ -982,25 +982,25 @@ mod tests { #[allow(unreachable_code)] #[test] fn test_breach_severity_calculation() { - let repo = LimitsRepositoryImpl { + let _repo = LimitsRepositoryImpl { db_pool: panic!("Test DB connection not needed"), redis_conn: panic!("Mock Redis connection"), }; assert_eq!( - repo.calculate_breach_severity(Decimal::from(85)), + _repo.calculate_breach_severity(Decimal::from(85)), BreachSeverity::Warning ); assert_eq!( - repo.calculate_breach_severity(Decimal::from(95)), + _repo.calculate_breach_severity(Decimal::from(95)), BreachSeverity::Soft ); assert_eq!( - repo.calculate_breach_severity(Decimal::from(105)), + _repo.calculate_breach_severity(Decimal::from(105)), BreachSeverity::Hard ); assert_eq!( - repo.calculate_breach_severity(Decimal::from(125)), + _repo.calculate_breach_severity(Decimal::from(125)), BreachSeverity::Critical ); } @@ -1008,7 +1008,7 @@ mod tests { #[allow(unreachable_code)] #[test] fn test_limit_validation() { - let repo = LimitsRepositoryImpl { + let _repo = LimitsRepositoryImpl { db_pool: panic!("Test DB connection not needed"), redis_conn: panic!("Mock Redis connection"), }; @@ -1030,7 +1030,7 @@ mod tests { metadata: serde_json::json!({}), }; - assert!(repo.validate_limit(&valid_limit).is_ok()); + assert!(_repo.validate_limit(&valid_limit).is_ok()); // Test invalid limit (negative threshold) let invalid_limit = PositionLimit { @@ -1038,6 +1038,6 @@ mod tests { ..valid_limit }; - assert!(repo.validate_limit(&invalid_limit).is_err()); + assert!(_repo.validate_limit(&invalid_limit).is_err()); } } diff --git a/trading_engine/Cargo.toml b/trading_engine/Cargo.toml index bde04c6d4..4bf201614 100644 --- a/trading_engine/Cargo.toml +++ b/trading_engine/Cargo.toml @@ -87,7 +87,6 @@ tokio-util = { version = "0.7", features = ["io"], optional = true } [dev-dependencies] proptest.workspace = true -tempfile.workspace = true [features] default = ["serde", "simd", "std", "brokers", "persistence"] diff --git a/trading_engine/src/events/mod.rs b/trading_engine/src/events/mod.rs index c94c2cbe2..3906b8972 100644 --- a/trading_engine/src/events/mod.rs +++ b/trading_engine/src/events/mod.rs @@ -768,7 +768,7 @@ mod tests { #[tokio::test] async fn test_event_processor_creation() -> Result<()> { // Create test configuration with in-memory database - let config = EventProcessorConfig { + let _config = EventProcessorConfig { database_url: "postgresql://test:test@localhost/test_db".to_string(), buffer_count: 2, buffer_size: 64, diff --git a/trading_engine/src/events/postgres_writer.rs b/trading_engine/src/events/postgres_writer.rs index 1171c3480..2dec4a392 100644 --- a/trading_engine/src/events/postgres_writer.rs +++ b/trading_engine/src/events/postgres_writer.rs @@ -702,7 +702,7 @@ mod tests { async fn test_batch_processor_compression() { // This test would require a real PostgreSQL connection // In a real test environment, you would use a test database - let config = WriterConfig::default(); + let _config = WriterConfig::default(); // Create a mock pool (in real tests, use sqlx::testing or similar) // let db_pool = PgPool::connect("postgresql://test:test@localhost/test").await.unwrap(); @@ -729,14 +729,14 @@ mod tests { #[tokio::test] async fn test_batch_processor_query_building() { - let config = WriterConfig::default(); + let _config = WriterConfig::default(); // Mock database pool for testing // In real tests, you would use a proper test database // Create batch processor with mock dependencies - let metrics = Arc::new(super::super::EventMetrics::new()); - let stats = Arc::new(RwLock::new(WriterStats::new(0))); + let _metrics = Arc::new(EventMetrics::new()); + let _stats = Arc::new(RwLock::new(WriterStats::new(0))); // Test would create a processor and test query building // let processor = BatchProcessor::new(config, mock_pool, metrics, stats); diff --git a/trading_engine/src/lockfree/mod.rs b/trading_engine/src/lockfree/mod.rs index 4a3e81593..63046b030 100644 --- a/trading_engine/src/lockfree/mod.rs +++ b/trading_engine/src/lockfree/mod.rs @@ -258,7 +258,7 @@ mod tests { #[test] fn test_corrected_lock_free_ring_buffer() -> Result<(), Box> { - let buffer = ring_buffer::LockFreeRingBuffer::::new(1024)?; + let buffer = LockFreeRingBuffer::::new(1024)?; // Test push/pop with corrected implementation assert!(buffer.try_push(42).is_ok()); diff --git a/trading_engine/src/tests/performance_validation.rs b/trading_engine/src/tests/performance_validation.rs index 9b1baee1b..24586f9d1 100644 --- a/trading_engine/src/tests/performance_validation.rs +++ b/trading_engine/src/tests/performance_validation.rs @@ -69,7 +69,7 @@ mod performance_tests { failure_threshold: 0.5, // 50% failures allowed }; - let benchmarks = ComprehensivePerformanceBenchmarks::new(config); + let _benchmarks = ComprehensivePerformanceBenchmarks::new(config); // Just verify we can create the benchmark suite assert!(true); // If we get here, creation succeeded } @@ -85,7 +85,7 @@ mod performance_tests { prefetch_distance: 64, }; - let benchmarks = AdvancedMemoryBenchmarks::new(config); + let _benchmarks = AdvancedMemoryBenchmarks::new(config); // Just verify we can create the memory benchmark suite assert!(true); // If we get here, creation succeeded } @@ -101,7 +101,7 @@ mod performance_tests { verbose: false, }; - let runner = PerformanceTestRunner::new(config); + let _runner = PerformanceTestRunner::new(config); // Just verify we can create the test runner assert!(true); // If we get here, creation succeeded } @@ -148,11 +148,11 @@ mod performance_tests { // Integration test to verify the full benchmark suite can run (if enabled) #[cfg(test)] -#[ignore] // Ignored by default as it's slow - run with `cargo test -- --ignored` mod integration_tests { use crate::test_runner::{PerformanceTestRunner, TestRunnerConfig}; #[test] + #[ignore] // Ignored by default as it's slow - run with `cargo test -- --ignored` fn test_full_benchmark_suite_execution() { let config = TestRunnerConfig { run_comprehensive_benchmarks: true, @@ -191,6 +191,7 @@ mod integration_tests { } #[test] + #[ignore] // Ignored by default as it's slow - run with `cargo test -- --ignored` fn test_quick_validation_execution() { use crate::test_runner::run_quick_validation; diff --git a/trading_engine/src/tests/trading_tests.rs b/trading_engine/src/tests/trading_tests.rs index 2df495243..9f3cb6564 100644 --- a/trading_engine/src/tests/trading_tests.rs +++ b/trading_engine/src/tests/trading_tests.rs @@ -237,8 +237,8 @@ mod comprehensive_trading_tests { assert_eq!(size_of::(), 8); // Should be 8 bytes (u64) // Verify alignment - assert_eq!(std::mem::align_of::(), 8); - assert_eq!(std::mem::align_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(align_of::(), 8); // Verify enum sizes are reasonable assert!(size_of::() <= 4); // Should be small @@ -327,7 +327,7 @@ mod property_tests { #[cfg(test)] mod performance_tests { - use common::{Price, Quantity, OrderSide, OrderType}; + use common::Price; use std::time::Instant; #[test] diff --git a/trading_engine/src/trading/account_manager.rs b/trading_engine/src/trading/account_manager.rs index b42079dc3..a0c6c61a5 100644 --- a/trading_engine/src/trading/account_manager.rs +++ b/trading_engine/src/trading/account_manager.rs @@ -332,7 +332,7 @@ mod tests { quantity: Decimal::from(quantity), price: Decimal::from(price), time_in_force: TimeInForce::GoodTillCancel, - metadata: std::collections::HashMap::new(), + metadata: HashMap::new(), created_at: chrono::Utc::now(), submitted_at: None, executed_at: None, @@ -399,7 +399,7 @@ mod tests { quantity: Decimal::from(2), price: Decimal::new(5000001, 2), // 50000.01 time_in_force: TimeInForce::GoodTillCancel, - metadata: std::collections::HashMap::new(), + metadata: HashMap::new(), created_at: chrono::Utc::now(), submitted_at: None, executed_at: None, diff --git a/trading_engine/src/trading/broker_client.rs b/trading_engine/src/trading/broker_client.rs index 3a2118c07..cbcb263a0 100644 --- a/trading_engine/src/trading/broker_client.rs +++ b/trading_engine/src/trading/broker_client.rs @@ -1000,8 +1000,8 @@ mod tests { order_type: OrderType::Market, price: Decimal::ZERO, time_in_force: TimeInForce::Day, - metadata: std::collections::HashMap::new(), - created_at: chrono::Utc::now(), + metadata: HashMap::new(), + created_at: Utc::now(), submitted_at: None, executed_at: None, status: OrderStatus::Created, diff --git a/trading_engine/src/trading/engine.rs b/trading_engine/src/trading/engine.rs index db7a4cecd..9bc72e52a 100644 --- a/trading_engine/src/trading/engine.rs +++ b/trading_engine/src/trading/engine.rs @@ -304,7 +304,7 @@ pub struct AccountInfo { #[cfg(test)] mod tests { - use super::*; + #[tokio::test] async fn test_trading_engine_creation() { diff --git a/trading_engine/src/trading/order_manager.rs b/trading_engine/src/trading/order_manager.rs index b151e5886..6c4f2fe74 100644 --- a/trading_engine/src/trading/order_manager.rs +++ b/trading_engine/src/trading/order_manager.rs @@ -259,7 +259,7 @@ mod tests { quantity: Decimal::from(quantity), price: Decimal::from(price), time_in_force: TimeInForce::GoodTillCancel, - metadata: std::collections::HashMap::new(), + metadata: HashMap::new(), created_at: chrono::Utc::now(), submitted_at: None, executed_at: None, @@ -356,7 +356,7 @@ mod tests { quantity: Decimal::from(10), price: Decimal::from(3000), time_in_force: TimeInForce::ImmediateOrCancel, - metadata: std::collections::HashMap::new(), + metadata: HashMap::new(), created_at: chrono::Utc::now(), submitted_at: None, executed_at: None, diff --git a/trading_engine/src/types/events.rs b/trading_engine/src/types/events.rs index 065f786a2..2019e7f84 100644 --- a/trading_engine/src/types/events.rs +++ b/trading_engine/src/types/events.rs @@ -1075,7 +1075,7 @@ mod tests { use chrono::TimeZone; // CANONICAL TYPE IMPORTS - FromPrimitive available via types::prelude use anyhow::anyhow; - use crate::types::test_utils::test_symbols::{self, *}; + use crate::types::test_utils::test_symbols::*; // use crate::operations; // Available if needed // Type alias for backward compatibility with tests @@ -1620,15 +1620,15 @@ mod tests { assert!(peeked.is_some()); // Pop events in chronological order - let (popped_event1, popped_time1) = queue.pop().ok_or("Queue is empty")?; + let (_popped_event1, popped_time1) = queue.pop().ok_or("Queue is empty")?; assert_eq!(popped_time1, t2); assert_eq!(queue.current_time(), t2); - let (popped_event2, popped_time2) = queue.pop().ok_or("Queue is empty")?; + let (_popped_event2, popped_time2) = queue.pop().ok_or("Queue is empty")?; assert_eq!(popped_time2, t1); assert_eq!(queue.current_time(), t1); - let (popped_event3, popped_time3) = queue.pop().ok_or("Queue is empty")?; + let (_popped_event3, popped_time3) = queue.pop().ok_or("Queue is empty")?; assert_eq!(popped_time3, t3); assert_eq!(queue.current_time(), t3); @@ -1663,7 +1663,7 @@ mod tests { assert!(queue.is_empty()); // Verify events were drained in chronological order - for (i, (event, timestamp)) in drained_events.iter().enumerate() { + for (i, (_event, timestamp)) in drained_events.iter().enumerate() { assert_eq!(*timestamp, start_time + chrono::Duration::seconds(i as i64)); } diff --git a/trading_engine/src/types/metrics.rs b/trading_engine/src/types/metrics.rs index 3038b9435..ecc9595c7 100644 --- a/trading_engine/src/types/metrics.rs +++ b/trading_engine/src/types/metrics.rs @@ -1154,7 +1154,7 @@ mod tests { let histogram = LATENCY_HISTOGRAMS.with_label_values(&["order_processing", "trading_engine"]); let timer = LatencyTimer::new(histogram); - std::thread::sleep(std::time::Duration::from_millis(1)); + std::thread::sleep(Duration::from_millis(1)); let duration = timer.observe_and_stop(); assert!(duration.as_millis() >= 1); }