// tests/mod.rs - or put this inside your crate's tests module #![allow(unused_imports)] use std::arch::x86_64::_mm256_mask_inserti64x2; use std::str::FromStr; use crate::entity::{EffectApplication, EffectBounds, Entity, EntityDuration, EntityIdentifier}; use crate::epoch::epoch_traits::Diffable; use crate::epoch::{EpochInfo, epoch_info}; use crate::error::EpochError; use crate::stats::{self, EntityType, MetaStats, Position, StatPair, TownId, TypedLink}; use std::io::Write; use super::*; use crate::Displayable; use insta::{assert_debug_snapshot, assert_snapshot}; use uuid::Uuid; #[test] fn entity_duration_parses_permanent_and_done() { assert_eq!( EntityDuration::from_str("permanent").unwrap(), EntityDuration::Permanent ); assert_eq!( EntityDuration::from_str("PERMANENT").unwrap(), EntityDuration::Permanent ); assert_eq!( EntityDuration::from_str("perm").unwrap(), EntityDuration::Permanent ); assert_eq!( EntityDuration::from_str("done").unwrap(), EntityDuration::Done ); } #[test] fn entity_duration_parses_numeric_forms() { // bare number assert_eq!( EntityDuration::from_str("5").unwrap(), EntityDuration::Duration(5) ); // with leading zeros assert_eq!( EntityDuration::from_str("0005").unwrap(), EntityDuration::Duration(5) ); // duration: prefix assert_eq!( EntityDuration::from_str("duration:10").unwrap(), EntityDuration::Duration(10) ); // case-insensitive prefix assert_eq!( EntityDuration::from_str("DurAtIoN:20").unwrap(), EntityDuration::Duration(20) ); // zero value assert_eq!( EntityDuration::from_str("duration:0").unwrap(), EntityDuration::Duration(0) ); } #[test] fn entity_duration_parses_with_surrounding_whitespace() { assert_eq!( EntityDuration::from_str(" 7 ").unwrap(), EntityDuration::Duration(7) ); assert_eq!( EntityDuration::from_str(" PERMANENT ").unwrap(), EntityDuration::Permanent ); } #[test] fn entity_duration_returns_error_on_invalid_inputs() { // non-numeric bare string let err = EntityDuration::from_str("10a").unwrap_err(); match err { EpochError::ParsingDuration(msg, val) => { assert!(!msg.is_empty()); assert_eq!(val, "10a"); } _ => panic!("Expected ParsingDuration error"), } // malformed duration: form let err = EntityDuration::from_str("duration:invalid").unwrap_err(); match err { EpochError::ParsingDuration(msg, val) => { assert!(!msg.is_empty()); assert_eq!(val, "invalid"); } _ => panic!("Expected ParsingDuration error"), } // trailing spaces after the duration prefix - the numeric parser fails let err = EntityDuration::from_str("duration: 5").unwrap_err(); match err { EpochError::ParsingDuration(msg, val) => { assert_eq!(msg, "Invalid duration value"); assert_eq!(val, " 5"); } _ => panic!("Expected ParsingDuration error"), } // empty string let err = EntityDuration::from_str("").unwrap_err(); match err { EpochError::ParsingDuration(msg, val) => { assert!(!msg.is_empty()); assert_eq!(val, ""); } _ => panic!("Expected ParsingDuration error"), } } #[test] fn effect_bounds_parses_colon_and_dash_separated_values() { // colon let eb = EffectBounds::from_str("1:5").unwrap(); assert_eq!(eb.min, 1); assert_eq!(eb.max, 5); // dash let eb = EffectBounds::from_str("2-10").unwrap(); assert_eq!(eb.min, 2); assert_eq!(eb.max, 10); } #[test] fn effect_bounds_parses_with_whitespace_and_leading_zeros() { let eb = EffectBounds::from_str(" 01 : 05 ").unwrap(); assert_eq!(eb.min, 1); assert_eq!(eb.max, 5); } #[test] fn effect_bounds_returns_error_on_invalid_inputs() { // too many parts let err = EffectBounds::from_str("1:5:7").unwrap_err(); match err { EpochError::ParsingBounds(msg, val) => { assert_eq!(msg, "Invalid EffectBounds format"); assert_eq!(val, "1:5:7"); } _ => panic!("Expected ParsingBounds error"), } // missing one side let err = EffectBounds::from_str("1:").unwrap_err(); match err { EpochError::ParsingBounds(msg, val) => { assert_eq!(msg, "Could not parse number"); assert_eq!(val, "1:"); } _ => panic!("Expected ParsingBounds error"), } // non-numeric part let err = EffectBounds::from_str("a:5").unwrap_err(); match err { EpochError::ParsingBounds(msg, val) => { assert_eq!(msg, "Could not parse number"); assert_eq!(val, "a:5"); } _ => panic!("Expected ParsingBounds error"), } // no delimiter let err = EffectBounds::from_str("5").unwrap_err(); match err { EpochError::ParsingBounds(msg, val) => { assert_eq!(msg, "Invalid EffectBounds"); assert_eq!(val, "5"); } _ => panic!("Expected ParsingBounds error"), } } #[test] fn entity_identifier_parses_id_and_name() { // id let id = EntityIdentifier::from_str("@1234-5678-9012-3456-7890").unwrap(); match id { EntityIdentifier::Id(uuid) => assert_eq!(uuid, "1234-5678-9012-3456-7890"), _ => panic!("Expected Id variant"), } // name let name = EntityIdentifier::from_str("my_entity").unwrap(); match name { EntityIdentifier::Name(n) => assert_eq!(n, "my_entity"), _ => panic!("Expected Name variant"), } // empty name is still a valid Name let empty = EntityIdentifier::from_str("").unwrap(); match empty { EntityIdentifier::Name(n) => assert_eq!(n, ""), _ => panic!("Expected Name variant"), } } #[test] fn entity_identifier_errors_on_invalid_id() { // prefix with nothing after @ let err = EntityIdentifier::from_str("@").unwrap_err(); match err { EpochError::EmptyIdentifier => {} _ => panic!("Expected EmptyIdentifier error"), } // // prefix followed by whitespace only // let err = EntityIdentifier::from_str("@ ").unwrap_err(); // match err { // EpochError::EmptyIdentifier => {} // _ => panic!("Expected EmptyIdentifier error"), // } } fn init_snapshot_env() { colored::control::set_override(false); } fn full_entity() -> Entity { Entity { id: Uuid::from_u128_le(12), name: "Hero".into(), entity_type: EntityType::Character, metadata: MetaStats { capital: Some(stats::TownId(Uuid::from_u128_le(124))), governor: Some(stats::CharacterId(Uuid::from_u128_le(11))), prestige: stats::GenericStat(3), position: Position::from((2, 4)), faction: Some(crate::stats::FactionId(2)), links: vec![ stats::TypedLink::new(Uuid::from_u128_le(1212), stats::Role::Govern), stats::TypedLink::new(Uuid::from_u128_le(121), stats::Role::Govern), stats::TypedLink::new(Uuid::from_u128_le(121), stats::Role::Govern), ], reach: stats::Reach::Global, }, duration: EntityDuration::Duration(10), effect_nature: EffectApplication::Recurring, effect_bounds: EffectBounds::from((1, 5)), stats: stats::OverallStats::default(), temp_stats: Some(stats::OverallStats::default()), description: String::from("Bob"), } } #[test] fn effect_bound_testing() { let EffectBounds { min, max } = EffectBounds::from(0..1); let EffectBounds { min: min2, max: max2, } = EffectBounds::from((0, 1)); assert_eq!(min, min2); assert_eq!(max, max2); } #[test] fn snapshot_full_oneline_display() { init_snapshot_env(); let e = full_entity(); let mut epoch_info = EpochInfo::default(); let e2 = Entity { id: Uuid::from_u128_le(121), name: "Bobtown".to_string(), ..Default::default() }; let e3 = Entity { id: Uuid::from_u128_le(124), name: "Bobpital".to_string(), ..Default::default() }; epoch_info.towns.push(e2); epoch_info.towns.push(e3); assert_snapshot!(e.oneline_display()); assert_snapshot!(e.to_pretty_tree(&epoch_info)); } #[test] fn snapshot_minimal_oneline_display() { init_snapshot_env(); let e = Entity::default(); assert_snapshot!(e.oneline_display()); assert_snapshot!(e.to_pretty_tree(&EpochInfo::default())); } #[test] fn snapshot_print_full_output() { init_snapshot_env(); let e = full_entity(); // Capture stdout into a buffer let buffer = Vec::new(); { // let stdout = std::io::stdout(); // let mut handle = stdout.lock(); // // Temporarily swap the real stdout for our buffer. // let original = std::mem::replace(&mut handle, &mut buffer); // Run the method we want to snapshot. e.print_full(&EpochInfo::default()); // Restore the original stdout. // std::mem::replace(&mut handle, original); } // Convert buffer → UTF-8 string and snapshot it. let output = String::from_utf8_lossy(&buffer); assert_snapshot!(output); } #[test] fn snapshot_full_stats_no_temp() { init_snapshot_env(); let mut e = full_entity(); e.temp_stats = None; let table = e.full_stats_to_table().expect("table generation failed"); assert_snapshot!(format!("{}", table)); let table = e.stats_to_table().expect("table generation failed"); assert_snapshot!(format!("{}", table)); } #[test] fn snapshot_full_stats_with_temp() { init_snapshot_env(); let mut e = full_entity(); e.temp_stats = Some(OverallStats::default()); let table = e.full_stats_to_table().expect("table generation failed"); assert_snapshot!(format!("{}", table)); let table = e.stats_to_table().expect("table generation failed"); assert_snapshot!(format!("{}", table)); } /// ------------------------------------------------------------------ /// 1. Helpers - `overwrite_stat` & `add_to_stat` /// ------------------------------------------------------------------ #[test] fn snapshot_overwrite_stat() { init_snapshot_env(); let mut entity = Entity::default(); let stats = OverallStats::linear(0); entity.stats = stats; entity.change_stat_strict(StatPair { stat: stats::ListStats::Population, value: stats::GenericStat(33), }); assert_snapshot!(format!("{:#?}", entity.stats)); } // #[test] // fn snapshot_add_to_stat_saturating_add() { // init_snapshot_env(); // let mut stats = stats_from_values(u32::MAX as i32 - 1, 20, 30); // let pair = pair("health", 5); // add_to_stat(&mut stats, pair); // // The saturated addition should clamp to `u32::MAX`. // assert_snapshot!(format!("{}\n", stats)); // } /// ------------------------------------------------------------------ /// 2. `Diffable` - `Entity::delta` /// ------------------------------------------------------------------ #[test] fn snapshot_entity_delta() { init_snapshot_env(); // Build two slightly different entities let e1 = Entity { id: uuid::Uuid::nil(), name: "Alice".into(), stats: OverallStats::linear(2), temp_stats: None, metadata: MetaStats { position: Position::from((44, 666)), capital: Some(stats::TownId(Uuid::from_u128_le(124))), governor: Some(stats::CharacterId(Uuid::from_u128_le(12))), faction: Some(stats::FactionId(44)), links: vec![TypedLink::new(Uuid::from_u128_le(141), stats::Role::Govern)], prestige: stats::GenericStat(3), reach: stats::Reach::Local(12), }, entity_type: EntityType::Monster, duration: EntityDuration::Permanent, effect_nature: EffectApplication::Recurring, effect_bounds: EffectBounds::from(0..33), description: "Ello".to_string(), }; let e2 = Entity { id: uuid::Uuid::nil(), name: "Bob".into(), stats: OverallStats::linear(44), temp_stats: Some(OverallStats::linear(4)), metadata: MetaStats { position: Position::from_str("33,4").unwrap(), capital: Some(stats::TownId(Uuid::from_u128_le(121))), governor: Some(stats::CharacterId(Uuid::from_u128_le(18))), faction: Some(stats::FactionId(5)), links: vec![TypedLink::new(Uuid::from_u128_le(121), stats::Role::Govern)], prestige: stats::GenericStat(5), reach: stats::Reach::Faction(stats::FactionId(2)), }, entity_type: EntityType::Town, duration: EntityDuration::Permanent, effect_nature: EffectApplication::Recurring, effect_bounds: EffectBounds::from(0..3), description: "Ilo".to_string(), }; // Compute the delta let mut delta = e1.delta(&e2); let mut delta2 = e2.delta(&e2); let mut delta3 = e2.delta(&e1); delta.id = Uuid::nil(); delta2.id = Uuid::nil(); delta3.id = Uuid::nil(); assert_snapshot!(format!( "{:#?}{}", &delta, delta.full_stats_to_table().unwrap() )); assert_snapshot!(format!( "{:#?}{}", delta2, delta2.full_stats_to_table().unwrap() )); assert_snapshot!(format!( "{:#?}{}", delta3, delta3.full_stats_to_table().unwrap() )); } #[test] fn snapshot_option_stats_delta() { init_snapshot_env(); let a = OverallStats::linear(32); let b = OverallStats::linear(22); let opt_a = Some(a.clone()); let opt_b = Some(b.clone()); // `delta` is commutative for the purpose of the snapshot let delta = opt_a.delta(&opt_b); let delta2 = None.delta(&opt_b); let delta3 = opt_a.delta(&None); let delta4 = None::.delta(&None); assert_snapshot!(format!("{:#?}", delta)); assert_snapshot!(format!("{:#?}", delta2)); assert_snapshot!(format!("{:#?}", delta3)); assert_snapshot!(format!("{:#?}", delta4)); } #[test] fn snapshot_meta_stats_delta() { init_snapshot_env(); let meta1 = MetaStats { position: Position::from((1, 11)), capital: Some(stats::TownId(Uuid::from_u128_le(1000))), governor: Some(stats::CharacterId(Uuid::from_u128_le(522))), faction: Some(stats::FactionId(1)), links: vec![TypedLink::new(Uuid::from_u128_le(12), stats::Role::Govern)], prestige: stats::GenericStat(3), reach: stats::Reach::Global, }; let meta2 = MetaStats { position: Position::from((44, 555)), capital: Some(stats::TownId(Uuid::from_u128_le(12))), governor: Some(stats::CharacterId(Uuid::from_u128_le(882))), faction: Some(stats::FactionId(33)), links: vec![TypedLink::new(Uuid::from_u128_le(42), stats::Role::Govern)], prestige: stats::GenericStat(1), reach: stats::Reach::None, }; let meta3 = MetaStats { position: Position::from((44, 555)), capital: None, governor: Some(stats::CharacterId(Uuid::from_u128_le(1221))), faction: Some(stats::FactionId(33)), links: vec![TypedLink::new(Uuid::from_u128_le(2), stats::Role::Govern)], prestige: stats::GenericStat(1), reach: stats::Reach::Faction(stats::FactionId(12)), }; let delta = meta1.delta(&meta2); let delta2 = meta2.delta(&meta3); let delta3 = meta3.delta(&meta3); assert_snapshot!(format!("{:#?}", delta)); assert_snapshot!(format!("{:#?}", delta2)); assert_snapshot!(format!("{:#?}", delta3)); } #[test] fn snapshot_delta_stat_positive() { init_snapshot_env(); let mut e = Entity::default(); e.delta_stat(StatPair::from_str("health:4").unwrap()); e.id = Uuid::nil(); assert_snapshot!(format!("{:#?}", e)); } #[test] fn snapshot_modify_duration() { init_snapshot_env(); let mut e = Entity::default(); e.modify_duration(EntityDuration::Duration(33)); e.id = Uuid::nil(); assert_snapshot!(format!("{:#?}", e)); } #[test] fn snapshot_modify_effect_application() { init_snapshot_env(); let mut e = Entity::default(); e.modify_effect_application(EffectApplication::PermanentEffectApplied); e.id = Uuid::nil(); assert_snapshot!(format!("{:#?}", e)); } #[test] fn snapshot_modify_effect_bounds() { init_snapshot_env(); let mut e = Entity::default(); e.modify_effect_bounds(EffectBounds::from(33..33)); e.id = Uuid::nil(); assert_snapshot!(format!("{:#?}", e)); } #[test] fn test_rng() { Entity::create_rng(&EntityType::Character, &crate::utils::RngLevel::Zero).unwrap(); Entity::create_rng(&EntityType::Player, &crate::utils::RngLevel::Low).unwrap(); Entity::create_rng(&EntityType::Town, &crate::utils::RngLevel::Med).unwrap(); Entity::create_rng(&EntityType::Monster, &crate::utils::RngLevel::High).unwrap(); Entity::create_rng(&EntityType::Blocker, &crate::utils::RngLevel::Legendary).unwrap(); Entity::create_rng(&EntityType::Event, &crate::utils::RngLevel::Mixed).unwrap(); Entity::create_rng(&EntityType::Event, &crate::utils::RngLevel::Flawed).unwrap(); } /// All the inputs we want to test, in the same order the original /// `match` evaluates them. The key is the snapshot name, the /// value is the input string. const TEST_CASES: &[(&str, &str)] = &[ ("recurring", "re"), ("when_present_wh", "wh"), ("when_present_present", "present"), ("when_present_toap", "toap"), ("when_present_appl", "appl"), ("permanent_effect_applied_done", "done"), ("permanent_effect_applied_ok", "ok"), ("permanent_effect_to_apply", "todo"), ("parse_error", "unknown"), ]; #[test] fn effect_application_from_str_snapshots() { let mut collect = String::new(); for (snapshot_name, input) in TEST_CASES { let result: Result = ::from_str(input); collect = format!("{}\n{} = {:?}", collect, snapshot_name, result); } assert_snapshot!(collect); }