use super::*;
use indicatrix::geometry::meet_solver::MeetConstraint;
use indicatrix_cut_core::PreformSpec;
use indicatrix_formats::asc::is_asc_safe_tier_name;
fn tier(name: &str, angle_deg: f64, constraint: MeetConstraint) -> ConstraintTier {
ConstraintTier {
angle_deg,
name: name.to_string(),
indices: vec![0.0, 12.0, 24.0, 36.0, 48.0, 60.0, 72.0, 84.0],
constraint,
imported_meet: None,
original_notes: None,
detached: Vec::new(),
}
}
fn named(names: &[&str]) -> MeetConstraint {
MeetConstraint::MeetNamed(names.iter().map(|name| (*name).to_string()).collect())
}
fn fresh_session() -> EditorSession {
let spec = crate::loading::parse_new_design_form(
96,
PreformSpec::cylinder(96, 1.5, 1.0, 1.5),
"8",
true,
0,
)
.expect("the default New Design form parses");
EditorSession::from_spec(spec)
}
fn session_with_two_tiers() -> EditorSession {
let mut session = fresh_session();
let mut crown = tier("C1", 41.0, MeetConstraint::ScaleReference(0.5));
crown.imported_meet = Some(MeetConstraint::MeetExisting);
session.design.tiers.push(crown);
session
.design
.tiers
.push(tier("P1", -41.0, MeetConstraint::ScaleReference(0.9)));
session
}
fn session_with_dependants() -> EditorSession {
let mut session = fresh_session();
let tiers = [
tier("P1", -40.0, MeetConstraint::ScaleReference(0.5)),
tier("P2", -42.0, named(&["P1"])),
tier("P3", -44.0, named(&["p1", "P2"])),
tier("C1", 41.0, MeetConstraint::ScaleReference(0.6)),
];
for (index, t) in tiers.into_iter().enumerate() {
session.apply(Edit::AddTier { index, tier: t }).unwrap();
}
session
}
fn tier_names(session: &EditorSession) -> Vec<&str> {
session
.design
.tiers
.iter()
.map(|t| t.name.as_str())
.collect()
}
#[test]
fn selection_follows_a_removal() {
assert_eq!(selection_after_remove(Some(2), 2), None);
assert_eq!(selection_after_remove(Some(3), 2), Some(2));
assert_eq!(selection_after_remove(Some(1), 2), Some(1));
assert_eq!(selection_after_remove(None, 2), None);
}
#[test]
fn duplicate_inserts_after_the_source_with_a_counted_name() {
let mut session = session_with_two_tiers();
let outcome = session.duplicate_tier(0).unwrap().expect("tier 0 exists");
assert_eq!(outcome.new_index, 1);
assert_eq!(outcome.source_label, "C1");
assert_eq!(outcome.duplicate_label, "C1 (2)");
assert_eq!(session.design.tiers[1].name, "C1 (2)");
assert!(session.design.tiers[1].imported_meet.is_none());
assert_eq!(session.design.tiers.len(), 3);
assert!(session.duplicate_tier(9).unwrap().is_none());
session.undo().unwrap();
assert_eq!(session.design.tiers.len(), 2);
}
#[test]
fn remove_reports_the_name_and_facet_count() {
let mut session = session_with_two_tiers();
let removed = session.remove_tier(1).unwrap();
assert_eq!(removed.name, "P1");
assert_eq!(removed.facet_count, 8);
assert!(session.remove_tier(5).is_err());
}
#[test]
fn removing_a_met_tier_is_refused_and_names_the_dependants() {
let mut session = session_with_dependants();
let generation = session.current_generation();
let err = session.remove_tier(0).unwrap_err();
let RemoveTierError::HasDependants {
subject,
dependants,
labels,
} = &err
else {
panic!("expected the dependants error, got {err:?}");
};
assert_eq!(subject, "P1");
assert_eq!(*dependants, vec![1, 2]);
assert_eq!(
*labels,
vec!["tier 2 (P2)".to_string(), "tier 3 (P3)".to_string()]
);
let message = err.to_string();
assert!(
message.contains("P1")
&& message.contains("tier 2 (P2)")
&& message.contains("tier 3 (P3)"),
"{message}"
);
assert_eq!(tier_names(&session), ["P1", "P2", "P3", "C1"]);
assert_eq!(session.current_generation(), generation, "nothing changed");
assert_eq!(session.remove_tier(3).unwrap().name, "C1");
assert!(matches!(
session.remove_tier(9).unwrap_err(),
RemoveTierError::Edit(_)
));
}
#[test]
fn a_cascading_removal_clears_the_references_in_one_undo_step() {
let mut session = session_with_dependants();
let removed = session.remove_tier_with(0, true).unwrap();
assert_eq!(removed.name, "P1");
assert_eq!(tier_names(&session), ["P2", "P3", "C1"]);
assert_eq!(
session.design.tiers[0].constraint,
MeetConstraint::MeetExisting
);
assert_eq!(session.design.tiers[1].constraint, named(&["P2"]));
assert!(session.undo().unwrap().is_some());
assert_eq!(tier_names(&session), ["P1", "P2", "P3", "C1"]);
assert_eq!(session.design.tiers[1].constraint, named(&["P1"]));
assert_eq!(session.design.tiers[2].constraint, named(&["p1", "P2"]));
}
#[test]
fn a_multi_delete_is_refused_while_an_unselected_tier_meets_a_selected_one() {
let mut session = session_with_dependants();
session.multi_selected.extend([0, 1]);
let err = session.remove_multi_selected().unwrap_err();
let RemoveTierError::HasDependants { dependants, .. } = &err else {
panic!("expected the dependants error, got {err:?}");
};
assert_eq!(*dependants, vec![2], "only P3 sits outside the selection");
assert_eq!(tier_names(&session), ["P1", "P2", "P3", "C1"]);
assert_eq!(session.multi_selected, BTreeSet::from([0, 1]));
session.multi_selected.insert(2);
assert_eq!(session.remove_multi_selected().unwrap(), 3);
assert_eq!(tier_names(&session), ["C1"]);
assert!(session.multi_selected.is_empty());
}
#[test]
fn a_cascading_multi_delete_clears_the_outside_references() {
let mut session = session_with_dependants();
session.multi_selected.extend([0, 1]);
assert_eq!(session.remove_multi_selected_with(true).unwrap(), 2);
assert_eq!(tier_names(&session), ["P3", "C1"]);
assert_eq!(
session.design.tiers[0].constraint,
MeetConstraint::MeetExisting
);
}
#[test]
fn move_stops_at_the_ends() {
let mut session = session_with_two_tiers();
assert!(session.move_tier(0, -1).unwrap().is_none());
assert!(session.move_tier(1, 1).unwrap().is_none());
let moved = session.move_tier(0, 1).unwrap().expect("can move down");
assert_eq!(moved.target, 1);
assert_eq!(session.design.tiers[1].name, "C1");
}
#[test]
fn adopt_switches_only_tiers_with_an_imported_meet() {
let mut session = session_with_two_tiers();
session.multi_selected.insert(1);
assert_eq!(session.adopt_selected_imported_meets().unwrap(), 0);
assert_eq!(session.adopt_all_imported_meets().unwrap(), 1);
assert_eq!(
session.design.tiers[0].constraint,
MeetConstraint::MeetExisting
);
}
#[test]
fn mirror_appends_the_negated_tier() {
let mut session = session_with_two_tiers();
let outcome = session
.mirror_tier_to_other_block(0, "'")
.unwrap()
.expect("tier 0 exists");
assert_eq!(outcome.new_index, 2);
assert!(session.design.tiers[2].angle_deg < 0.0);
assert_eq!(outcome.label, "C1'");
}
#[test]
fn mirroring_twice_never_repeats_a_name() {
let mut session = session_with_two_tiers();
let first = session.mirror_tier_to_other_block(0, "'").unwrap().unwrap();
let second = session.mirror_tier_to_other_block(0, "'").unwrap().unwrap();
assert_eq!(first.label, "C1'");
assert_eq!(second.label, "C1'2");
assert_eq!(session.design.tiers[second.new_index].name, "C1'2");
session.design.tiers[0].name = "x/p1'".to_string();
let third = session.mirror_tier_to_other_block(1, "'").unwrap().unwrap();
assert_eq!(third.label, "P1'2");
}
#[test]
fn a_mirrored_name_is_whitespace_free_and_an_unnamed_source_gets_a_block_name() {
let mut session = session_with_two_tiers();
session.design.tiers[0].name = "Crown Main".to_string();
let spaced = session
.mirror_tier_to_other_block(0, " a b")
.unwrap()
.unwrap();
assert_eq!(spaced.label, "Crown_Maina_b");
assert!(is_asc_safe_tier_name(&spaced.label));
session.design.tiers[1].name = String::new();
let unnamed = session.mirror_tier_to_other_block(1, "'").unwrap().unwrap();
assert_eq!(
unnamed.label, "C1",
"the mirror of a pavilion tier is a crown tier"
);
assert!(session.design.tiers[unnamed.new_index].angle_deg > 0.0);
}
#[test]
fn generate_appends_a_ladder_in_one_step() {
let mut session = session_with_two_tiers();
let series = session
.generate_step_series("Step", "30", "2", 3, "0", "")
.unwrap();
assert_eq!((series.start_index, series.added), (2, 3));
assert_eq!(session.design.tiers.len(), 5);
assert_eq!(
tier_names(&session),
["C1", "P1", "Step1", "Step2", "Step3"]
);
session.undo().unwrap();
assert_eq!(session.design.tiers.len(), 2);
assert!(
session
.generate_step_series("Step", "x", "2", 3, "0", "")
.is_err()
);
}
#[test]
fn a_second_ladder_with_the_same_prefix_continues_the_numbering() {
let mut session = session_with_two_tiers();
session
.generate_step_series("Step", "30", "2", 2, "0", "")
.unwrap();
session
.generate_step_series("step", "20", "2", 2, "0", "")
.unwrap();
assert_eq!(
tier_names(&session),
["C1", "P1", "Step1", "Step2", "step3", "step4"]
);
}
#[test]
fn a_blank_prefix_names_the_ladder_by_block() {
let mut session = session_with_two_tiers();
session
.generate_step_series("", "30", "2", 2, "0", "")
.unwrap();
assert_eq!(tier_names(&session), ["C1", "P1", "C2", "C3"]);
}
#[test]
fn generate_refuses_a_runaway_count_and_bad_angles_without_touching_the_design() {
let mut session = session_with_two_tiers();
for count in [0, 65, i32::MAX] {
let message = session
.generate_step_series("Step", "30", "1", count, "0", "")
.unwrap_err();
assert!(message.contains("1 to 64"), "{message}");
}
let past_ninety = session
.generate_step_series("Step", "80", "5", 4, "0", "")
.unwrap_err();
assert!(past_ninety.contains("Tier 4"), "{past_ninety}");
let crossing = session
.generate_step_series("Step", "-40", "30", 3, "0", "")
.unwrap_err();
assert!(crossing.contains("Tier 3"), "{crossing}");
assert_eq!(session.design.tiers.len(), 2);
assert_eq!(session.current_generation(), 0, "nothing was applied");
}
#[test]
fn inline_angle_text_is_a_no_op_when_bit_identical() {
let mut session = session_with_two_tiers();
let before = session.current_generation();
assert_eq!(
session.set_tier_angle_from_text(0, "41").unwrap(),
InlineAngle::NoChange
);
assert_eq!(session.current_generation(), before);
assert!(matches!(
session.set_tier_angle_from_text(0, "42.5").unwrap(),
InlineAngle::Applied(_)
));
assert_eq!(
session.design.tiers[0].angle_deg.to_bits(),
42.5_f64.to_bits()
);
assert_eq!(
session.set_tier_angle_from_text(9, "1").unwrap(),
InlineAngle::Missing
);
assert!(session.set_tier_angle_from_text(0, "abc").is_err());
}
#[test]
fn inline_angle_text_on_a_pavilion_tier_keeps_its_side() {
let mut session = session_with_two_tiers();
for (text, expected) in [
("38.5", -38.5),
("38.5 + 0.5", -39.0),
("-40", -40.0),
("C1 - 3", -38.0),
] {
assert!(
matches!(
session.set_tier_angle_from_text(1, text).unwrap(),
InlineAngle::Applied(_)
),
"{text}"
);
assert_eq!(session.design.tiers[1].angle_deg, expected, "{text}");
}
assert_eq!(
session.design.tiers[0].angle_deg, 41.0,
"the crown is untouched"
);
assert!(session.undo().unwrap().is_some());
assert_eq!(session.design.tiers[1].angle_deg, -40.0);
}
#[test]
fn inline_zero_keeps_the_side_of_the_tier_it_is_typed_on() {
let mut session = session_with_two_tiers();
session.set_tier_angle_from_text(1, "0").unwrap();
let pavilion = session.design.tiers[1].angle_deg;
assert!(pavilion == 0.0 && pavilion.is_sign_negative(), "{pavilion}");
session.set_tier_angle_from_text(0, "10 - 10").unwrap();
let crown = session.design.tiers[0].angle_deg;
assert!(crown == 0.0 && !crown.is_sign_negative(), "{crown}");
session.set_tier_angle_from_text(0, "-0").unwrap();
let culet = session.design.tiers[0].angle_deg;
assert!(culet == 0.0 && culet.is_sign_negative(), "{culet}");
session.set_tier_angle_from_text(1, "+0").unwrap();
let table = session.design.tiers[1].angle_deg;
assert!(table == 0.0 && !table.is_sign_negative(), "{table}");
}
fn session_with_concave_fixture() -> EditorSession {
let design = indicatrix_cut_core::Design::concave_fixture();
EditorSession::with_history(design, indicatrix_cut_core::History::default())
}
#[test]
fn concave_duplicate_remove_and_move_edit_only_the_concave_list() {
let mut session = session_with_concave_fixture();
let flat_before = session.design.tiers.clone();
let outcome = session
.duplicate_concave_tier(0)
.unwrap()
.expect("tier 0 exists");
assert_eq!(outcome.new_index, 1);
let copy_name = outcome.duplicate_label.clone();
assert!(outcome.change.concave_count_changed());
assert!(!outcome.change.tier_count_changed());
assert_eq!(session.design.concave_tiers.len(), 3);
assert_ne!(
session.design.concave_tiers[1].name, session.design.concave_tiers[0].name,
"the copy gets its own name"
);
let moved = session.move_concave_tier(1, 1).unwrap().expect("not last");
assert_eq!(moved.target, 2);
assert!(session.move_concave_tier(2, 1).unwrap().is_none());
assert!(session.move_concave_tier(0, -1).unwrap().is_none());
let removed = session.remove_concave_tier(2).unwrap().expect("exists");
assert_eq!(removed.name, copy_name, "the moved copy is last");
assert_eq!(removed.facet_count, 8);
assert!(session.remove_concave_tier(9).unwrap().is_none());
assert_eq!(session.design.tiers, flat_before);
for _ in 0..3 {
session.undo().unwrap();
}
assert_eq!(session.design.concave_tiers.len(), 2);
}
#[test]
fn the_concave_selection_follows_its_tier_and_clears_when_it_is_removed() {
let mut session = session_with_concave_fixture();
session.selected_concave = Some(1);
session.duplicate_concave_tier(0).unwrap();
assert_eq!(session.selected_concave, Some(2), "pushed down by the copy");
session.move_concave_tier(2, -1).unwrap();
assert_eq!(session.selected_concave, Some(1));
session.remove_concave_tier(1).unwrap();
assert_eq!(session.selected_concave, None);
}