use std::cell::RefCell; use std::collections::{BTreeMap, BTreeSet}; use std::rc::Rc; use chrono::{NaiveDate, NaiveDateTime}; use fidc_core::{ BacktestConfig, BacktestEngine, BenchmarkSnapshot, BrokerSimulator, CandidateEligibility, ChinaAShareCostModel, ChinaEquityRuleHooks, DailyFactorSnapshot, DailyMarketSnapshot, DataSet, Instrument, IntradayExecutionQuote, OrderIntent, PriceField, ProcessEventKind, ScheduleRule, ScheduleStage, ScheduleTimeRule, Strategy, StrategyContext, StrategyDecision, }; fn d(year: i32, month: u32, day: u32) -> NaiveDate { NaiveDate::from_ymd_opt(year, month, day).expect("valid date") } fn dt(year: i32, month: u32, day: u32, hour: u32, minute: u32, second: u32) -> NaiveDateTime { d(year, month, day) .and_hms_opt(hour, minute, second) .expect("valid datetime") } fn bool_flags(values: Vec) -> String { values .into_iter() .map(|value| if value { "1" } else { "0" }) .collect::>() .join(",") } struct HookProbeStrategy { log: Rc>>, } impl Strategy for HookProbeStrategy { fn name(&self) -> &str { "hook-probe" } fn before_trading( &mut self, ctx: &StrategyContext<'_>, ) -> Result<(), fidc_core::BacktestError> { self.log .borrow_mut() .push(format!("before:{}", ctx.execution_date)); Ok(()) } fn open_auction( &mut self, ctx: &StrategyContext<'_>, ) -> Result { self.log .borrow_mut() .push(format!("auction:{}", ctx.execution_date)); Ok(StrategyDecision::default()) } fn on_day( &mut self, ctx: &StrategyContext<'_>, ) -> Result { self.log .borrow_mut() .push(format!("on_day:{}", ctx.execution_date)); Ok(StrategyDecision { rebalance: false, target_weights: BTreeMap::new(), exit_symbols: BTreeSet::new(), order_intents: Vec::new(), notes: Vec::new(), diagnostics: Vec::new(), }) } fn after_trading(&mut self, ctx: &StrategyContext<'_>) -> Result<(), fidc_core::BacktestError> { self.log .borrow_mut() .push(format!("after:{}", ctx.execution_date)); Ok(()) } fn on_settlement(&mut self, ctx: &StrategyContext<'_>) -> Result<(), fidc_core::BacktestError> { self.log .borrow_mut() .push(format!("settlement:{}", ctx.execution_date)); Ok(()) } } struct AuctionOrderStrategy { saw_quantity_in_on_day: Rc>>, } impl Strategy for AuctionOrderStrategy { fn name(&self) -> &str { "auction-order" } fn open_auction( &mut self, _ctx: &StrategyContext<'_>, ) -> Result { Ok(StrategyDecision { rebalance: false, target_weights: BTreeMap::new(), exit_symbols: BTreeSet::new(), order_intents: vec![fidc_core::OrderIntent::Value { symbol: "000001.SZ".to_string(), value: 1_000.0, reason: "auction_buy".to_string(), }], notes: Vec::new(), diagnostics: Vec::new(), }) } fn on_day( &mut self, ctx: &StrategyContext<'_>, ) -> Result { let quantity = ctx .portfolio .position("000001.SZ") .map(|position| position.quantity) .unwrap_or(0); *self.saw_quantity_in_on_day.borrow_mut() = Some(quantity); Ok(StrategyDecision::default()) } } struct ScheduledProbeStrategy { log: Rc>>, process_log: Rc>>, } struct ProcessContextProbeStrategy { snapshots: Rc>>, } struct LimitCarryStrategy { issued: bool, } struct UniverseDirectiveStrategy { snapshots: Rc>>, } struct TickProbeStrategy { seen_ticks: Rc>>, ordered: bool, } struct DataApiProbeStrategy { target_date: NaiveDate, snapshots: Rc>>, } impl Strategy for ScheduledProbeStrategy { fn name(&self) -> &str { "scheduled-probe" } fn on_process_event( &mut self, _ctx: &StrategyContext<'_>, event: &fidc_core::ProcessEvent, ) -> Result<(), fidc_core::BacktestError> { self.process_log .borrow_mut() .push(format!("{:?}:{}", event.kind, event.detail)); Ok(()) } fn schedule_rules(&self) -> Vec { vec![ ScheduleRule::daily("daily_before_trading", ScheduleStage::BeforeTrading) .with_time_rule(ScheduleTimeRule::before_trading()), ScheduleRule::daily("daily_market_open", ScheduleStage::OpenAuction) .with_time_rule(ScheduleTimeRule::market_open(0, 0)), ScheduleRule::weekly_by_weekday("friday_on_day", 5, ScheduleStage::OnDay) .with_time_rule(ScheduleTimeRule::physical_time(10, 18)), ScheduleRule::monthly("first_trading_day_on_day", 1, ScheduleStage::OnDay) .with_time_rule(ScheduleTimeRule::physical_time(10, 18)), ] } fn on_scheduled( &mut self, ctx: &StrategyContext<'_>, rule: &ScheduleRule, ) -> Result { self.log .borrow_mut() .push(format!("scheduled:{}:{}", rule.name, ctx.execution_date)); Ok(StrategyDecision::default()) } fn on_day( &mut self, _ctx: &StrategyContext<'_>, ) -> Result { Ok(StrategyDecision::default()) } } impl Strategy for LimitCarryStrategy { fn name(&self) -> &str { "limit-carry" } fn on_day( &mut self, _ctx: &StrategyContext<'_>, ) -> Result { if self.issued { return Ok(StrategyDecision::default()); } self.issued = true; Ok(StrategyDecision { rebalance: false, target_weights: BTreeMap::new(), exit_symbols: BTreeSet::new(), order_intents: vec![OrderIntent::LimitShares { symbol: "000001.SZ".to_string(), quantity: 200, limit_price: 9.8, reason: "carry_limit".to_string(), }], notes: Vec::new(), diagnostics: Vec::new(), }) } } impl Strategy for ProcessContextProbeStrategy { fn name(&self) -> &str { "process-context-probe" } fn on_process_event( &mut self, ctx: &StrategyContext<'_>, _event: &fidc_core::ProcessEvent, ) -> Result<(), fidc_core::BacktestError> { self.snapshots.borrow_mut().push(format!( "{}:{}:{}", ctx.current_process_event_kind(), ctx.latest_process_event_kind(), ctx.process_event_count() )); Ok(()) } fn on_day( &mut self, _ctx: &StrategyContext<'_>, ) -> Result { Ok(StrategyDecision::default()) } } impl Strategy for UniverseDirectiveStrategy { fn name(&self) -> &str { "universe-directive-probe" } fn on_day( &mut self, ctx: &StrategyContext<'_>, ) -> Result { let eligible = ctx .eligible_universe_on(ctx.execution_date) .into_iter() .map(|row| row.symbol) .collect::>() .join(","); self.snapshots.borrow_mut().push(format!( "{}:{}:{}:{}", ctx.execution_date, ctx.dynamic_universe_count(), ctx.subscription_count(), eligible )); let order_intents = match ctx.execution_date { date if date == d(2025, 1, 2) => vec![ OrderIntent::UpdateUniverse { symbols: BTreeSet::from(["000002.SZ".to_string()]), reason: "focus_single_symbol".to_string(), }, OrderIntent::Subscribe { symbols: BTreeSet::from(["000001.SZ".to_string()]), reason: "subscribe_probe".to_string(), }, ], date if date == d(2025, 1, 3) => vec![OrderIntent::Unsubscribe { symbols: BTreeSet::from(["000001.SZ".to_string()]), reason: "unsubscribe_probe".to_string(), }], _ => Vec::new(), }; Ok(StrategyDecision { rebalance: false, target_weights: BTreeMap::new(), exit_symbols: BTreeSet::new(), order_intents, notes: Vec::new(), diagnostics: Vec::new(), }) } } impl Strategy for TickProbeStrategy { fn name(&self) -> &str { "tick-probe" } fn on_day( &mut self, _ctx: &StrategyContext<'_>, ) -> Result { Ok(StrategyDecision { rebalance: false, target_weights: BTreeMap::new(), exit_symbols: BTreeSet::new(), order_intents: vec![OrderIntent::Subscribe { symbols: BTreeSet::from(["000001.SZ".to_string()]), reason: "subscribe_tick_probe".to_string(), }], notes: Vec::new(), diagnostics: Vec::new(), }) } fn on_tick( &mut self, ctx: &StrategyContext<'_>, quote: &IntradayExecutionQuote, ) -> Result { let visible_last = ctx .history_bars("e.symbol, 9, "tick", "last", true) .iter() .map(|value| format!("{value:.2}")) .collect::>() .join(","); let previous_last = ctx .history_bars("e.symbol, 9, "tick", "last", false) .iter() .map(|value| format!("{value:.2}")) .collect::>() .join(","); self.seen_ticks.borrow_mut().push(format!( "{}:{}:{}:visible={visible_last}:previous={previous_last}", quote.symbol, quote.timestamp.time(), ctx.is_subscribed("e.symbol) )); if self.ordered { return Ok(StrategyDecision::default()); } self.ordered = true; Ok(StrategyDecision { rebalance: false, target_weights: BTreeMap::new(), exit_symbols: BTreeSet::new(), order_intents: vec![OrderIntent::Shares { symbol: quote.symbol.clone(), quantity: 100, reason: "tick_buy".to_string(), }], notes: Vec::new(), diagnostics: Vec::new(), }) } } impl Strategy for DataApiProbeStrategy { fn name(&self) -> &str { "data-api-probe" } fn on_day( &mut self, ctx: &StrategyContext<'_>, ) -> Result { if ctx.execution_date == self.target_date { let daily_close = ctx .history_bars("000001.SZ", 2, "1d", "close", true) .iter() .map(|value| format!("{value:.2}")) .collect::>() .join(","); let previous_close = ctx .history_bars("000001.SZ", 2, "daily", "close", false) .iter() .map(|value| format!("{value:.2}")) .collect::>() .join(","); let tick_last = ctx .history_bars("000001.SZ", 2, "1m", "last", true) .iter() .map(|value| format!("{value:.2}")) .collect::>() .join(","); let previous_tick_last = ctx .history_bars("000001.SZ", 2, "1m", "last", false) .iter() .map(|value| format!("{value:.2}")) .collect::>() .join(","); let current_close = ctx .current_snapshot("000001.SZ") .map(|snapshot| format!("{:.2}", snapshot.close)) .unwrap_or_default(); let instrument_name = ctx .instrument("000001.SZ") .map(|instrument| instrument.name.clone()) .unwrap_or_default(); let prev_date = ctx .get_previous_trading_date(ctx.execution_date, 1) .map(|date| date.to_string()) .unwrap_or_default(); let next_date = ctx .get_next_trading_date(d(2025, 1, 3), 1) .map(|date| date.to_string()) .unwrap_or_default(); let trading_date_count = ctx .get_trading_dates(d(2025, 1, 2), ctx.execution_date) .len(); let suspended = bool_flags(ctx.is_suspended("000001.SZ", 3)); let st_flags = bool_flags(ctx.is_st_stock("000001.SZ", 3)); let daily_price_count = ctx .get_price("000001.SZ", d(2025, 1, 3), ctx.execution_date, "1d") .len(); let tick_price_count = ctx .get_price("000001.SZ", d(2025, 1, 3), ctx.execution_date, "tick") .len(); self.snapshots.borrow_mut().push(format!( "daily={daily_close};previous={previous_close};tick={tick_last};previous_tick={previous_tick_last};current={current_close};instrument={instrument_name};all={};range={trading_date_count};prev={prev_date};next={next_date};suspended={suspended};st={st_flags};price_daily={daily_price_count};price_tick={tick_price_count}", ctx.all_instruments().len() )); } Ok(StrategyDecision::default()) } } #[test] fn engine_runs_strategy_hooks_in_daily_order() { let date1 = d(2025, 1, 2); let date2 = d(2025, 1, 3); let data = DataSet::from_components( vec![Instrument { symbol: "000001.SZ".to_string(), name: "Anchor".to_string(), board: "SZ".to_string(), round_lot: 100, listed_at: Some(d(2020, 1, 1)), delisted_at: None, status: "active".to_string(), }], vec![ DailyMarketSnapshot { date: date1, symbol: "000001.SZ".to_string(), timestamp: Some("2025-01-02 10:18:00".to_string()), day_open: 10.0, open: 10.0, high: 10.0, low: 10.0, close: 10.0, last_price: 10.0, bid1: 10.0, ask1: 10.0, prev_close: 10.0, volume: 100_000, tick_volume: 100_000, bid1_volume: 100_000, ask1_volume: 100_000, trading_phase: Some("continuous".to_string()), paused: false, upper_limit: 11.0, lower_limit: 9.0, price_tick: 0.01, }, DailyMarketSnapshot { date: date2, symbol: "000001.SZ".to_string(), timestamp: Some("2025-01-03 10:18:00".to_string()), day_open: 10.1, open: 10.1, high: 10.1, low: 10.1, close: 10.1, last_price: 10.1, bid1: 10.1, ask1: 10.1, prev_close: 10.0, volume: 110_000, tick_volume: 110_000, bid1_volume: 110_000, ask1_volume: 110_000, trading_phase: Some("continuous".to_string()), paused: false, upper_limit: 11.0, lower_limit: 9.0, price_tick: 0.01, }, ], vec![ DailyFactorSnapshot { date: date1, symbol: "000001.SZ".to_string(), market_cap_bn: 20.0, free_float_cap_bn: 18.0, pe_ttm: 10.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }, DailyFactorSnapshot { date: date2, symbol: "000001.SZ".to_string(), market_cap_bn: 21.0, free_float_cap_bn: 19.0, pe_ttm: 10.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }, ], vec![ CandidateEligibility { date: date1, symbol: "000001.SZ".to_string(), is_st: false, is_new_listing: false, is_paused: false, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }, CandidateEligibility { date: date2, symbol: "000001.SZ".to_string(), is_st: false, is_new_listing: false, is_paused: false, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }, ], vec![ BenchmarkSnapshot { date: date1, benchmark: "000300.SH".to_string(), open: 100.0, close: 100.0, prev_close: 99.0, volume: 1_000_000, }, BenchmarkSnapshot { date: date2, benchmark: "000300.SH".to_string(), open: 101.0, close: 101.0, prev_close: 100.0, volume: 1_100_000, }, ], ) .expect("dataset"); let log = Rc::new(RefCell::new(Vec::new())); let strategy = HookProbeStrategy { log: log.clone() }; let broker = BrokerSimulator::new_with_execution_price( ChinaAShareCostModel::default(), ChinaEquityRuleHooks::default(), PriceField::Open, ); let mut engine = BacktestEngine::new( data, strategy, broker, BacktestConfig { initial_cash: 100_000.0, benchmark_code: "000300.SH".to_string(), start_date: Some(date1), end_date: Some(date2), decision_lag_trading_days: 0, execution_price_field: PriceField::Open, }, ); let result = engine.run().expect("backtest succeeds"); assert_eq!( log.borrow().as_slice(), [ "before:2025-01-02", "auction:2025-01-02", "on_day:2025-01-02", "after:2025-01-02", "settlement:2025-01-02", "before:2025-01-03", "auction:2025-01-03", "on_day:2025-01-03", "after:2025-01-03", "settlement:2025-01-03", ] ); assert_eq!(result.process_events.len(), 36); assert_eq!( result.process_events[..18] .iter() .map(|event| &event.kind) .collect::>(), vec![ &ProcessEventKind::PreBeforeTrading, &ProcessEventKind::BeforeTrading, &ProcessEventKind::PostBeforeTrading, &ProcessEventKind::PreOpenAuction, &ProcessEventKind::OpenAuction, &ProcessEventKind::PostOpenAuction, &ProcessEventKind::PreOnDay, &ProcessEventKind::OnDay, &ProcessEventKind::PreBar, &ProcessEventKind::Bar, &ProcessEventKind::PostOnDay, &ProcessEventKind::PostBar, &ProcessEventKind::PreAfterTrading, &ProcessEventKind::AfterTrading, &ProcessEventKind::PostAfterTrading, &ProcessEventKind::PreSettlement, &ProcessEventKind::Settlement, &ProcessEventKind::PostSettlement, ] ); } #[test] fn engine_executes_open_auction_decisions_before_on_day() { let date = d(2025, 1, 2); let data = DataSet::from_components( vec![Instrument { symbol: "000001.SZ".to_string(), name: "Anchor".to_string(), board: "SZ".to_string(), round_lot: 100, listed_at: Some(d(2020, 1, 1)), delisted_at: None, status: "active".to_string(), }], vec![DailyMarketSnapshot { date, symbol: "000001.SZ".to_string(), timestamp: Some("2025-01-02 09:25:00".to_string()), day_open: 10.0, open: 10.0, high: 10.0, low: 10.0, close: 10.0, last_price: 10.0, bid1: 10.0, ask1: 10.0, prev_close: 10.0, volume: 100_000, tick_volume: 100_000, bid1_volume: 100_000, ask1_volume: 100_000, trading_phase: Some("open_auction".to_string()), paused: false, upper_limit: 11.0, lower_limit: 9.0, price_tick: 0.01, }], vec![DailyFactorSnapshot { date, symbol: "000001.SZ".to_string(), market_cap_bn: 20.0, free_float_cap_bn: 18.0, pe_ttm: 10.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }], vec![CandidateEligibility { date, symbol: "000001.SZ".to_string(), is_st: false, is_new_listing: false, is_paused: false, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }], vec![BenchmarkSnapshot { date, benchmark: "000300.SH".to_string(), open: 100.0, close: 100.0, prev_close: 99.0, volume: 1_000_000, }], ) .expect("dataset"); let observed_quantity = Rc::new(RefCell::new(None)); let strategy = AuctionOrderStrategy { saw_quantity_in_on_day: observed_quantity.clone(), }; let broker = BrokerSimulator::new_with_execution_price( ChinaAShareCostModel::default(), ChinaEquityRuleHooks::default(), PriceField::DayOpen, ); let mut engine = BacktestEngine::new( data, strategy, broker, BacktestConfig { initial_cash: 10_000.0, benchmark_code: "000300.SH".to_string(), start_date: Some(date), end_date: Some(date), decision_lag_trading_days: 0, execution_price_field: PriceField::DayOpen, }, ); let result = engine.run().expect("backtest run"); assert_eq!(*observed_quantity.borrow(), Some(100)); assert_eq!(result.fills.len(), 1); assert_eq!(result.fills[0].reason, "auction_buy"); assert_eq!(result.fills[0].quantity, 100); } #[test] fn engine_runs_subscribed_tick_hooks_and_executes_tick_orders() { let date = d(2025, 1, 2); let data = DataSet::from_components_with_actions_and_quotes( vec![Instrument { symbol: "000001.SZ".to_string(), name: "Anchor".to_string(), board: "SZ".to_string(), round_lot: 100, listed_at: Some(d(2020, 1, 1)), delisted_at: None, status: "active".to_string(), }], vec![DailyMarketSnapshot { date, symbol: "000001.SZ".to_string(), timestamp: Some("2025-01-02 10:18:00".to_string()), day_open: 10.0, open: 10.0, high: 10.4, low: 9.9, close: 10.3, last_price: 10.2, bid1: 10.1, ask1: 10.2, prev_close: 10.0, volume: 100_000, tick_volume: 100_000, bid1_volume: 100_000, ask1_volume: 100_000, trading_phase: Some("continuous".to_string()), paused: false, upper_limit: 11.0, lower_limit: 9.0, price_tick: 0.01, }], vec![DailyFactorSnapshot { date, symbol: "000001.SZ".to_string(), market_cap_bn: 20.0, free_float_cap_bn: 18.0, pe_ttm: 10.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }], vec![CandidateEligibility { date, symbol: "000001.SZ".to_string(), is_st: false, is_new_listing: false, is_paused: false, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }], vec![BenchmarkSnapshot { date, benchmark: "000300.SH".to_string(), open: 100.0, close: 100.0, prev_close: 99.0, volume: 1_000_000, }], Vec::new(), vec![ IntradayExecutionQuote { date, symbol: "000001.SZ".to_string(), timestamp: dt(2025, 1, 2, 10, 18, 0), last_price: 10.2, bid1: 10.1, ask1: 10.2, bid1_volume: 1_000, ask1_volume: 1_000, volume_delta: 1_000, amount_delta: 10_200.0, trading_phase: Some("continuous".to_string()), }, IntradayExecutionQuote { date, symbol: "000001.SZ".to_string(), timestamp: dt(2025, 1, 2, 10, 19, 0), last_price: 10.3, bid1: 10.2, ask1: 10.3, bid1_volume: 1_000, ask1_volume: 1_000, volume_delta: 1_000, amount_delta: 10_300.0, trading_phase: Some("continuous".to_string()), }, ], ) .expect("dataset"); let seen_ticks = Rc::new(RefCell::new(Vec::new())); let strategy = TickProbeStrategy { seen_ticks: seen_ticks.clone(), ordered: false, }; let broker = BrokerSimulator::new_with_execution_price( ChinaAShareCostModel::default(), ChinaEquityRuleHooks::default(), PriceField::Last, ); let mut engine = BacktestEngine::new( data, strategy, broker, BacktestConfig { initial_cash: 10_000.0, benchmark_code: "000300.SH".to_string(), start_date: Some(date), end_date: Some(date), decision_lag_trading_days: 0, execution_price_field: PriceField::Last, }, ); let result = engine.run().expect("backtest run"); assert_eq!( seen_ticks.borrow().as_slice(), [ "000001.SZ:10:18:00:true:visible=10.20:previous=", "000001.SZ:10:19:00:true:visible=10.20,10.30:previous=10.20" ] ); assert_eq!(result.fills.len(), 1); assert_eq!(result.fills[0].reason, "tick_buy"); assert_eq!(result.fills[0].quantity, 100); assert!( result .process_events .iter() .any(|event| event.kind == ProcessEventKind::PreTick) ); assert!( result .process_events .iter() .any(|event| event.kind == ProcessEventKind::Tick) ); assert!( result .process_events .iter() .any(|event| event.kind == ProcessEventKind::PostTick) ); } #[test] fn strategy_context_exposes_rqalpha_style_data_helpers() { let date1 = d(2025, 1, 2); let date2 = d(2025, 1, 3); let date3 = d(2025, 1, 6); let instrument = Instrument { symbol: "000001.SZ".to_string(), name: "Anchor".to_string(), board: "SZ".to_string(), round_lot: 100, listed_at: Some(d(2020, 1, 1)), delisted_at: None, status: "active".to_string(), }; let market = [ (date1, 10.0, 10.0, 10.0, 100_000), (date2, 10.1, 10.1, 10.0, 110_000), (date3, 10.2, 10.2, 10.1, 120_000), ] .into_iter() .map( |(date, open, close, prev_close, volume)| DailyMarketSnapshot { date, symbol: "000001.SZ".to_string(), timestamp: Some(format!("{date} 10:18:00")), day_open: open, open, high: close + 0.2, low: close - 0.2, close, last_price: close, bid1: close - 0.01, ask1: close + 0.01, prev_close, volume, tick_volume: volume, bid1_volume: volume, ask1_volume: volume, trading_phase: Some("continuous".to_string()), paused: false, upper_limit: prev_close * 1.1, lower_limit: prev_close * 0.9, price_tick: 0.01, }, ) .collect::>(); let factors = [date1, date2, date3] .into_iter() .map(|date| DailyFactorSnapshot { date, symbol: "000001.SZ".to_string(), market_cap_bn: 20.0, free_float_cap_bn: 18.0, pe_ttm: 10.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }) .collect::>(); let candidates = [ (date1, false, false), (date2, true, true), (date3, false, false), ] .into_iter() .map(|(date, is_paused, is_st)| CandidateEligibility { date, symbol: "000001.SZ".to_string(), is_st, is_new_listing: false, is_paused, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }) .collect::>(); let benchmarks = [ (date1, 100.0, 99.0), (date2, 101.0, 100.0), (date3, 102.0, 101.0), ] .into_iter() .map(|(date, close, prev_close)| BenchmarkSnapshot { date, benchmark: "000300.SH".to_string(), open: close, close, prev_close, volume: 1_000_000, }) .collect::>(); let quotes = vec![ IntradayExecutionQuote { date: date2, symbol: "000001.SZ".to_string(), timestamp: dt(2025, 1, 3, 14, 30, 0), last_price: 10.15, bid1: 10.14, ask1: 10.15, bid1_volume: 1000, ask1_volume: 1000, volume_delta: 1000, amount_delta: 10_150.0, trading_phase: Some("continuous".to_string()), }, IntradayExecutionQuote { date: date3, symbol: "000001.SZ".to_string(), timestamp: dt(2025, 1, 6, 10, 18, 0), last_price: 10.25, bid1: 10.24, ask1: 10.25, bid1_volume: 1000, ask1_volume: 1000, volume_delta: 1000, amount_delta: 10_250.0, trading_phase: Some("continuous".to_string()), }, IntradayExecutionQuote { date: date3, symbol: "000001.SZ".to_string(), timestamp: dt(2025, 1, 6, 10, 19, 0), last_price: 10.26, bid1: 10.25, ask1: 10.26, bid1_volume: 1000, ask1_volume: 1000, volume_delta: 1000, amount_delta: 10_260.0, trading_phase: Some("continuous".to_string()), }, ]; let data = DataSet::from_components_with_actions_and_quotes( vec![instrument], market, factors, candidates, benchmarks, Vec::new(), quotes, ) .expect("dataset"); let snapshots = Rc::new(RefCell::new(Vec::new())); let strategy = DataApiProbeStrategy { target_date: date3, snapshots: snapshots.clone(), }; let broker = BrokerSimulator::new_with_execution_price( ChinaAShareCostModel::default(), ChinaEquityRuleHooks::default(), PriceField::Open, ); let mut engine = BacktestEngine::new( data, strategy, broker, BacktestConfig { initial_cash: 10_000.0, benchmark_code: "000300.SH".to_string(), start_date: Some(date1), end_date: Some(date3), decision_lag_trading_days: 0, execution_price_field: PriceField::Open, }, ); engine.run().expect("backtest run"); assert_eq!( snapshots.borrow().as_slice(), [ "daily=10.10,10.20;previous=10.00,10.10;tick=10.15,10.25;previous_tick=10.15;current=10.20;instrument=Anchor;all=1;range=3;prev=2025-01-03;next=2025-01-06;suspended=0,1,0;st=0,1,0;price_daily=2;price_tick=3" ] ); } #[test] fn engine_rejects_pending_limit_orders_at_market_close() { let date1 = d(2025, 1, 2); let date2 = d(2025, 1, 3); let data = DataSet::from_components( vec![Instrument { symbol: "000001.SZ".to_string(), name: "Anchor".to_string(), board: "SZ".to_string(), round_lot: 100, listed_at: Some(d(2020, 1, 1)), delisted_at: None, status: "active".to_string(), }], vec![ DailyMarketSnapshot { date: date1, symbol: "000001.SZ".to_string(), timestamp: Some("2025-01-02 10:18:00".to_string()), day_open: 10.0, open: 10.0, high: 10.1, low: 9.9, close: 10.0, last_price: 10.0, bid1: 10.0, ask1: 10.0, prev_close: 10.0, volume: 100_000, tick_volume: 100_000, bid1_volume: 100_000, ask1_volume: 100_000, trading_phase: Some("continuous".to_string()), paused: false, upper_limit: 11.0, lower_limit: 9.0, price_tick: 0.01, }, DailyMarketSnapshot { date: date2, symbol: "000001.SZ".to_string(), timestamp: Some("2025-01-03 10:18:00".to_string()), day_open: 9.7, open: 9.7, high: 9.8, low: 9.6, close: 9.7, last_price: 9.7, bid1: 9.7, ask1: 9.7, prev_close: 10.0, volume: 100_000, tick_volume: 100_000, bid1_volume: 100_000, ask1_volume: 100_000, trading_phase: Some("continuous".to_string()), paused: false, upper_limit: 10.67, lower_limit: 9.0, price_tick: 0.01, }, ], vec![ DailyFactorSnapshot { date: date1, symbol: "000001.SZ".to_string(), market_cap_bn: 20.0, free_float_cap_bn: 18.0, pe_ttm: 10.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }, DailyFactorSnapshot { date: date2, symbol: "000001.SZ".to_string(), market_cap_bn: 21.0, free_float_cap_bn: 19.0, pe_ttm: 10.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }, ], vec![ CandidateEligibility { date: date1, symbol: "000001.SZ".to_string(), is_st: false, is_new_listing: false, is_paused: false, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }, CandidateEligibility { date: date2, symbol: "000001.SZ".to_string(), is_st: false, is_new_listing: false, is_paused: false, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }, ], vec![ BenchmarkSnapshot { date: date1, benchmark: "000300.SH".to_string(), open: 100.0, close: 100.0, prev_close: 99.0, volume: 1_000_000, }, BenchmarkSnapshot { date: date2, benchmark: "000300.SH".to_string(), open: 101.0, close: 101.0, prev_close: 100.0, volume: 1_100_000, }, ], ) .expect("dataset"); let broker = BrokerSimulator::new_with_execution_price( ChinaAShareCostModel::default(), ChinaEquityRuleHooks::default(), PriceField::Open, ); let strategy = LimitCarryStrategy { issued: false }; let mut engine = BacktestEngine::new( data, strategy, broker, BacktestConfig { initial_cash: 100_000.0, benchmark_code: "000300.SH".to_string(), start_date: Some(date1), end_date: Some(date2), decision_lag_trading_days: 0, execution_price_field: PriceField::Open, }, ); let result = engine.run().expect("backtest run"); assert!(result.fills.is_empty()); assert!(result.holdings_summary.is_empty()); assert!( result.order_events.iter().any(|event| { event.date == date1 && event.status == fidc_core::OrderStatus::Pending }) ); assert!(result.order_events.iter().any(|event| { event.date == date1 && event.status == fidc_core::OrderStatus::Rejected && event.reason.contains("Market close") })); assert!(result.process_events.iter().any(|event| { event.date == date1 && event.kind == ProcessEventKind::OrderUnsolicitedUpdate })); } #[test] fn engine_runs_scheduled_rules_for_daily_weekly_and_monthly_triggers() { let date1 = d(2025, 1, 30); let date2 = d(2025, 1, 31); let date3 = d(2025, 2, 3); let data = DataSet::from_components( vec![Instrument { symbol: "000001.SZ".to_string(), name: "Anchor".to_string(), board: "SZ".to_string(), round_lot: 100, listed_at: Some(d(2020, 1, 1)), delisted_at: None, status: "active".to_string(), }], vec![ DailyMarketSnapshot { date: date1, symbol: "000001.SZ".to_string(), timestamp: Some("2025-01-30 09:25:00".to_string()), day_open: 10.0, open: 10.0, high: 10.1, low: 9.9, close: 10.0, last_price: 10.0, bid1: 10.0, ask1: 10.0, prev_close: 9.9, volume: 100_000, tick_volume: 100_000, bid1_volume: 100_000, ask1_volume: 100_000, trading_phase: Some("open_auction".to_string()), paused: false, upper_limit: 11.0, lower_limit: 9.0, price_tick: 0.01, }, DailyMarketSnapshot { date: date2, symbol: "000001.SZ".to_string(), timestamp: Some("2025-01-31 09:25:00".to_string()), day_open: 10.1, open: 10.1, high: 10.2, low: 10.0, close: 10.1, last_price: 10.1, bid1: 10.1, ask1: 10.1, prev_close: 10.0, volume: 110_000, tick_volume: 110_000, bid1_volume: 110_000, ask1_volume: 110_000, trading_phase: Some("open_auction".to_string()), paused: false, upper_limit: 11.1, lower_limit: 9.1, price_tick: 0.01, }, DailyMarketSnapshot { date: date3, symbol: "000001.SZ".to_string(), timestamp: Some("2025-02-03 09:25:00".to_string()), day_open: 10.2, open: 10.2, high: 10.3, low: 10.1, close: 10.2, last_price: 10.2, bid1: 10.2, ask1: 10.2, prev_close: 10.1, volume: 120_000, tick_volume: 120_000, bid1_volume: 120_000, ask1_volume: 120_000, trading_phase: Some("open_auction".to_string()), paused: false, upper_limit: 11.2, lower_limit: 9.2, price_tick: 0.01, }, ], vec![ DailyFactorSnapshot { date: date1, symbol: "000001.SZ".to_string(), market_cap_bn: 20.0, free_float_cap_bn: 18.0, pe_ttm: 10.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }, DailyFactorSnapshot { date: date2, symbol: "000001.SZ".to_string(), market_cap_bn: 21.0, free_float_cap_bn: 19.0, pe_ttm: 10.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }, DailyFactorSnapshot { date: date3, symbol: "000001.SZ".to_string(), market_cap_bn: 22.0, free_float_cap_bn: 20.0, pe_ttm: 10.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }, ], vec![ CandidateEligibility { date: date1, symbol: "000001.SZ".to_string(), is_st: false, is_new_listing: false, is_paused: false, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }, CandidateEligibility { date: date2, symbol: "000001.SZ".to_string(), is_st: false, is_new_listing: false, is_paused: false, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }, CandidateEligibility { date: date3, symbol: "000001.SZ".to_string(), is_st: false, is_new_listing: false, is_paused: false, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }, ], vec![ BenchmarkSnapshot { date: date1, benchmark: "000300.SH".to_string(), open: 100.0, close: 100.0, prev_close: 99.0, volume: 1_000_000, }, BenchmarkSnapshot { date: date2, benchmark: "000300.SH".to_string(), open: 101.0, close: 101.0, prev_close: 100.0, volume: 1_100_000, }, BenchmarkSnapshot { date: date3, benchmark: "000300.SH".to_string(), open: 102.0, close: 102.0, prev_close: 101.0, volume: 1_200_000, }, ], ) .expect("dataset"); let log = Rc::new(RefCell::new(Vec::new())); let process_log = Rc::new(RefCell::new(Vec::new())); let strategy = ScheduledProbeStrategy { log: log.clone(), process_log: process_log.clone(), }; let broker = BrokerSimulator::new_with_execution_price( ChinaAShareCostModel::default(), ChinaEquityRuleHooks::default(), PriceField::DayOpen, ); let mut engine = BacktestEngine::new( data, strategy, broker, BacktestConfig { initial_cash: 100_000.0, benchmark_code: "000300.SH".to_string(), start_date: Some(date1), end_date: Some(date3), decision_lag_trading_days: 0, execution_price_field: PriceField::DayOpen, }, ); engine.run().expect("backtest run"); assert_eq!( log.borrow().as_slice(), [ "scheduled:daily_before_trading:2025-01-30", "scheduled:daily_market_open:2025-01-30", "scheduled:first_trading_day_on_day:2025-01-30", "scheduled:daily_before_trading:2025-01-31", "scheduled:daily_market_open:2025-01-31", "scheduled:friday_on_day:2025-01-31", "scheduled:daily_before_trading:2025-02-03", "scheduled:daily_market_open:2025-02-03", "scheduled:first_trading_day_on_day:2025-02-03", ] ); let process_log = process_log.borrow(); assert!( process_log.iter().any(|item| { item == "PreScheduled:scheduled:daily_before_trading:before_trading:pre" }) ); assert!( process_log .iter() .any(|item| { item == "PostScheduled:scheduled:daily_market_open:open_auction:post" }) ); assert!( process_log .iter() .any(|item| { item == "PreScheduled:scheduled:friday_on_day:on_day:pre" }) ); assert!( process_log .iter() .any(|item| { item == "PostScheduled:scheduled:first_trading_day_on_day:on_day:post" }) ); } #[test] fn engine_dispatches_process_events_to_external_bus_listeners() { let date1 = d(2025, 1, 30); let date2 = d(2025, 1, 31); let date3 = d(2025, 2, 3); let data = DataSet::from_components( vec![Instrument { symbol: "000001.SZ".to_string(), name: "Anchor".to_string(), board: "SZ".to_string(), round_lot: 100, listed_at: Some(d(2020, 1, 1)), delisted_at: None, status: "active".to_string(), }], vec![ DailyMarketSnapshot { date: date1, symbol: "000001.SZ".to_string(), timestamp: Some("2025-01-30 09:25:00".to_string()), day_open: 10.0, open: 10.0, high: 10.1, low: 9.9, close: 10.0, last_price: 10.0, bid1: 10.0, ask1: 10.0, prev_close: 9.9, volume: 100_000, tick_volume: 100_000, bid1_volume: 100_000, ask1_volume: 100_000, trading_phase: Some("open_auction".to_string()), paused: false, upper_limit: 11.0, lower_limit: 9.0, price_tick: 0.01, }, DailyMarketSnapshot { date: date2, symbol: "000001.SZ".to_string(), timestamp: Some("2025-01-31 09:25:00".to_string()), day_open: 10.1, open: 10.1, high: 10.2, low: 10.0, close: 10.1, last_price: 10.1, bid1: 10.1, ask1: 10.1, prev_close: 10.0, volume: 110_000, tick_volume: 110_000, bid1_volume: 110_000, ask1_volume: 110_000, trading_phase: Some("open_auction".to_string()), paused: false, upper_limit: 11.1, lower_limit: 9.1, price_tick: 0.01, }, DailyMarketSnapshot { date: date3, symbol: "000001.SZ".to_string(), timestamp: Some("2025-02-03 09:25:00".to_string()), day_open: 10.2, open: 10.2, high: 10.3, low: 10.1, close: 10.2, last_price: 10.2, bid1: 10.2, ask1: 10.2, prev_close: 10.1, volume: 120_000, tick_volume: 120_000, bid1_volume: 120_000, ask1_volume: 120_000, trading_phase: Some("open_auction".to_string()), paused: false, upper_limit: 11.2, lower_limit: 9.2, price_tick: 0.01, }, ], vec![ DailyFactorSnapshot { date: date1, symbol: "000001.SZ".to_string(), market_cap_bn: 20.0, free_float_cap_bn: 18.0, pe_ttm: 10.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }, DailyFactorSnapshot { date: date2, symbol: "000001.SZ".to_string(), market_cap_bn: 21.0, free_float_cap_bn: 19.0, pe_ttm: 10.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }, DailyFactorSnapshot { date: date3, symbol: "000001.SZ".to_string(), market_cap_bn: 22.0, free_float_cap_bn: 20.0, pe_ttm: 10.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }, ], vec![ CandidateEligibility { date: date1, symbol: "000001.SZ".to_string(), is_st: false, is_new_listing: false, is_paused: false, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }, CandidateEligibility { date: date2, symbol: "000001.SZ".to_string(), is_st: false, is_new_listing: false, is_paused: false, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }, CandidateEligibility { date: date3, symbol: "000001.SZ".to_string(), is_st: false, is_new_listing: false, is_paused: false, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }, ], vec![ BenchmarkSnapshot { date: date1, benchmark: "000300.SH".to_string(), open: 100.0, close: 100.0, prev_close: 99.0, volume: 1_000_000, }, BenchmarkSnapshot { date: date2, benchmark: "000300.SH".to_string(), open: 101.0, close: 101.0, prev_close: 100.0, volume: 1_100_000, }, BenchmarkSnapshot { date: date3, benchmark: "000300.SH".to_string(), open: 102.0, close: 102.0, prev_close: 101.0, volume: 1_200_000, }, ], ) .expect("dataset"); let log = Rc::new(RefCell::new(Vec::new())); let process_log = Rc::new(RefCell::new(Vec::new())); let strategy = ScheduledProbeStrategy { log, process_log }; let broker = BrokerSimulator::new_with_execution_price( ChinaAShareCostModel::default(), ChinaEquityRuleHooks::default(), PriceField::DayOpen, ); let mut engine = BacktestEngine::new( data, strategy, broker, BacktestConfig { initial_cash: 100_000.0, benchmark_code: "000300.SH".to_string(), start_date: Some(date1), end_date: Some(date3), decision_lag_trading_days: 0, execution_price_field: PriceField::DayOpen, }, ); let external_log = Rc::new(RefCell::new(Vec::new())); engine.add_process_listener(ProcessEventKind::PreScheduled, { let external_log = external_log.clone(); move |event| { external_log .borrow_mut() .push(format!("{:?}:{}", event.kind, event.detail)); } }); engine.add_process_listener(ProcessEventKind::PostScheduled, { let external_log = external_log.clone(); move |event| { external_log .borrow_mut() .push(format!("{:?}:{}", event.kind, event.detail)); } }); engine.run().expect("backtest run"); let external_log = external_log.borrow(); assert!( external_log.iter().any(|item| { item == "PreScheduled:scheduled:daily_before_trading:before_trading:pre" }) ); assert!( external_log .iter() .any(|item| { item == "PostScheduled:scheduled:first_trading_day_on_day:on_day:post" }) ); } #[test] fn engine_applies_dynamic_universe_and_subscription_directives() { let dates = [d(2025, 1, 2), d(2025, 1, 3), d(2025, 1, 6)]; let snapshots = Rc::new(RefCell::new(Vec::new())); let strategy = UniverseDirectiveStrategy { snapshots: snapshots.clone(), }; let instruments = vec![ Instrument { symbol: "000001.SZ".to_string(), name: "One".to_string(), board: "SZ".to_string(), round_lot: 100, listed_at: Some(d(2020, 1, 1)), delisted_at: None, status: "active".to_string(), }, Instrument { symbol: "000002.SZ".to_string(), name: "Two".to_string(), board: "SZ".to_string(), round_lot: 100, listed_at: Some(d(2020, 1, 1)), delisted_at: None, status: "active".to_string(), }, ]; let markets = dates .iter() .flat_map(|date| { [ DailyMarketSnapshot { date: *date, symbol: "000001.SZ".to_string(), timestamp: Some(format!("{date} 10:18:00")), day_open: 10.0, open: 10.0, high: 10.1, low: 9.9, close: 10.0, last_price: 10.0, bid1: 9.99, ask1: 10.01, prev_close: 9.95, volume: 100_000, tick_volume: 5_000, bid1_volume: 2_000, ask1_volume: 2_000, trading_phase: Some("continuous".to_string()), paused: false, upper_limit: 11.0, lower_limit: 9.0, price_tick: 0.01, }, DailyMarketSnapshot { date: *date, symbol: "000002.SZ".to_string(), timestamp: Some(format!("{date} 10:18:00")), day_open: 20.0, open: 20.0, high: 20.1, low: 19.9, close: 20.0, last_price: 20.0, bid1: 19.99, ask1: 20.01, prev_close: 19.95, volume: 100_000, tick_volume: 5_000, bid1_volume: 2_000, ask1_volume: 2_000, trading_phase: Some("continuous".to_string()), paused: false, upper_limit: 22.0, lower_limit: 18.0, price_tick: 0.01, }, ] }) .collect::>(); let factors = dates .iter() .flat_map(|date| { [ DailyFactorSnapshot { date: *date, symbol: "000001.SZ".to_string(), market_cap_bn: 10.0, free_float_cap_bn: 8.0, pe_ttm: 10.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }, DailyFactorSnapshot { date: *date, symbol: "000002.SZ".to_string(), market_cap_bn: 12.0, free_float_cap_bn: 10.0, pe_ttm: 12.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }, ] }) .collect::>(); let candidates = dates .iter() .flat_map(|date| { [ CandidateEligibility { date: *date, symbol: "000001.SZ".to_string(), is_st: false, is_new_listing: false, is_paused: false, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }, CandidateEligibility { date: *date, symbol: "000002.SZ".to_string(), is_st: false, is_new_listing: false, is_paused: false, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }, ] }) .collect::>(); let benchmarks = dates .iter() .map(|date| BenchmarkSnapshot { date: *date, benchmark: "000852.SH".to_string(), open: 1000.0, close: 1000.0, prev_close: 999.0, volume: 100_000, }) .collect::>(); let data = DataSet::from_components(instruments, markets, factors, candidates, benchmarks) .expect("dataset"); let broker = BrokerSimulator::new_with_execution_price( ChinaAShareCostModel::default(), ChinaEquityRuleHooks::default(), PriceField::Open, ); let mut engine = BacktestEngine::new( data, strategy, broker, BacktestConfig { initial_cash: 1_000_000.0, benchmark_code: "000852.SH".to_string(), start_date: Some(dates[0]), end_date: Some(dates[2]), decision_lag_trading_days: 0, execution_price_field: PriceField::Open, }, ); let result = engine.run().expect("backtest result"); assert_eq!( snapshots.borrow().as_slice(), &[ "2025-01-02:0:0:000001.SZ,000002.SZ", "2025-01-03:1:1:000002.SZ", "2025-01-06:1:0:000002.SZ", ] ); assert!( result .process_events .iter() .any(|event| event.kind == ProcessEventKind::UniverseUpdated) ); assert!( result .process_events .iter() .any(|event| event.kind == ProcessEventKind::UniverseSubscribed) ); assert!( result .process_events .iter() .any(|event| event.kind == ProcessEventKind::UniverseUnsubscribed) ); } #[test] fn engine_exposes_current_process_context_to_strategies() { let date = d(2025, 1, 2); let data = DataSet::from_components( vec![Instrument { symbol: "000001.SZ".to_string(), name: "Anchor".to_string(), board: "SZ".to_string(), round_lot: 100, listed_at: Some(d(2020, 1, 1)), delisted_at: None, status: "active".to_string(), }], vec![DailyMarketSnapshot { date, symbol: "000001.SZ".to_string(), timestamp: Some("2025-01-02 10:18:00".to_string()), day_open: 10.0, open: 10.0, high: 10.1, low: 9.9, close: 10.0, last_price: 10.0, bid1: 10.0, ask1: 10.0, prev_close: 9.9, volume: 100_000, tick_volume: 100_000, bid1_volume: 100_000, ask1_volume: 100_000, trading_phase: Some("continuous".to_string()), paused: false, upper_limit: 11.0, lower_limit: 9.0, price_tick: 0.01, }], vec![DailyFactorSnapshot { date, symbol: "000001.SZ".to_string(), market_cap_bn: 20.0, free_float_cap_bn: 18.0, pe_ttm: 10.0, turnover_ratio: Some(1.0), effective_turnover_ratio: Some(1.0), extra_factors: BTreeMap::new(), }], vec![CandidateEligibility { date, symbol: "000001.SZ".to_string(), is_st: false, is_new_listing: false, is_paused: false, allow_buy: true, allow_sell: true, is_kcb: false, is_one_yuan: false, }], vec![BenchmarkSnapshot { date, benchmark: "000300.SH".to_string(), open: 100.0, close: 100.0, prev_close: 99.0, volume: 1_000_000, }], ) .expect("dataset"); let snapshots = Rc::new(RefCell::new(Vec::new())); let strategy = ProcessContextProbeStrategy { snapshots: snapshots.clone(), }; let broker = BrokerSimulator::new_with_execution_price( ChinaAShareCostModel::default(), ChinaEquityRuleHooks::default(), PriceField::Last, ); let mut engine = BacktestEngine::new( data, strategy, broker, BacktestConfig { initial_cash: 100_000.0, benchmark_code: "000300.SH".to_string(), start_date: Some(date), end_date: Some(date), decision_lag_trading_days: 0, execution_price_field: PriceField::Last, }, ); engine.run().expect("backtest run"); let snapshots = snapshots.borrow(); assert_eq!( snapshots.first().map(String::as_str), Some("pre_before_trading:pre_before_trading:1") ); assert!(snapshots.iter().any(|item| item == "on_day:on_day:8")); }