use tradefloor::economy::{create_initial_economy_state, InitialEconomyOptions};
use tradefloor::market::{
reset_daily_prices, simulate_market_tick, OrderVolume, SettleDrawPolicy,
TickCompany, TickInputs, TickStock, MARKET_FACTOR_SIGMA,
};
use tradefloor::rng::{GameRng, Rng};
struct Counting {
inner: GameRng,
count: usize,
}
impl Rng for Counting {
fn next_f64(&mut self) -> f64 {
self.count += 1;
self.inner.next_f64()
}
fn next_normal(&mut self) -> f64 {
self.count += 1;
self.inner.next_normal()
}
}
fn company(id: &str, price: f64, avg_volume: f64, shares: f64) -> TickCompany {
let stock = {
let mut tick_stock = TickStock::new(price, shares);
tick_stock.avg_volume = avg_volume;
tick_stock.garch_variance = 0.015 * 0.015;
tick_stock.garch_cascade = [0.015 * 0.015; tradefloor::market::garch::CASCADE_MAX];
tick_stock.beta = Some(1.0);
tick_stock
};
let mut tick_company = TickCompany::new(id, id, "technology", stock);
tick_company.sector_volatility = Some(1.0);
tick_company.sector_avg_pe = Some(32.0);
tick_company.eps = Some(price / 25.0);
tick_company.book_value_per_share = Some(price * 0.5);
tick_company.revenue_growth = Some(0.1);
tick_company
}
fn run_world(policy: SettleDrawPolicy, trader_flow: f64) -> (Vec<f64>, usize) {
let mut companies = vec![
company("THIN", 40.0, 250.0, 1.0e4),
company("B", 100.0, 1.0e6, 1.0e8),
company("C", 220.0, 1.0e6, 1.0e8),
];
let economy = create_initial_economy_state(&InitialEconomyOptions::default());
let sector_keys = vec!["technology".to_string()];
let order_volumes = vec![(
"THIN".to_string(),
OrderVolume::new(trader_flow, 0.0),
)];
let mut rng = Counting {
inner: GameRng::new(2026, 99),
count: 0,
};
reset_daily_prices(&mut companies);
for _ in 0..120 {
simulate_market_tick(
&mut companies,
&{
let mut tick_inputs = TickInputs::new(&economy, &tradefloor::params::PT_V1);
tick_inputs.prev_day_down = false;
tick_inputs.prev_day_factor = 0.0;
tick_inputs.universe_stress = 0.0;
tick_inputs.intraday_t = 0.5;
tick_inputs.volatility_multiplier = 0.7;
tick_inputs.order_volumes = &order_volumes;
tick_inputs.sector_keys = §or_keys;
tick_inputs.market_sigma_daily = MARKET_FACTOR_SIGMA;
tick_inputs.vix_anchor = tradefloor::params::PT_V1.market_vol_vix_anchor;
tick_inputs.settle_draws = policy;
tick_inputs.settle_depth_counterfactual = false;
tick_inputs.nominal_output_base = economy.gdp * economy.cpi;
tick_inputs.crisis_epicentre = None;
tick_inputs
},
&mut rng,
);
}
(
companies.iter().map(|c| c.stock.price).collect(),
rng.count,
)
}
#[test]
fn the_constructed_flow_flips_a_settlement_guard() {
let (_, quiet_draws) = run_world(SettleDrawPolicy::FourOrZero, 0.0);
let (_, traded_draws) = run_world(SettleDrawPolicy::FourOrZero, 10_000.0);
assert_ne!(
quiet_draws, traded_draws,
"the scenario no longer flips a settle guard; the alignment tests \
below are not demonstrating anything — retune the thin company"
);
}
#[test]
fn under_the_conditional_schedule_untouched_names_diverge() {
let (quiet, _) = run_world(SettleDrawPolicy::FourOrZero, 0.0);
let (traded, _) = run_world(SettleDrawPolicy::FourOrZero, 10_000.0);
assert!(
quiet[1].to_bits() != traded[1].to_bits()
|| quiet[2].to_bits() != traded[2].to_bits(),
"expected the shifted stream to reach the untraded names"
);
}
#[test]
fn under_the_fixed_schedule_only_the_traded_name_moves() {
let (quiet, quiet_draws) = run_world(SettleDrawPolicy::FourAlways, 0.0);
let (traded, traded_draws) = run_world(SettleDrawPolicy::FourAlways, 10_000.0);
assert_eq!(
quiet_draws, traded_draws,
"the fixed schedule must be flow-invariant"
);
assert_ne!(
quiet[0].to_bits(),
traded[0].to_bits(),
"the trade had no impact at all, so confinement is vacuous"
);
assert_eq!(
quiet[1].to_bits(),
traded[1].to_bits(),
"an untraded name moved: the counterfactual leaked"
);
assert_eq!(
quiet[2].to_bits(),
traded[2].to_bits(),
"an untraded name moved: the counterfactual leaked"
);
}