use super::*;
use std::time::Duration;
fn style() -> Ink {
let mut ink = plain();
ink.content = Style::new().add_modifier(Modifier::BOLD);
ink.secondary = Style::new().add_modifier(Modifier::ITALIC);
ink.muted = Style::new().add_modifier(Modifier::DIM);
ink.danger = Style::new().add_modifier(Modifier::CROSSED_OUT);
ink
}
fn plain() -> Ink {
Ink::new(&bare_palette(), &PieceStyle::default())
}
fn bare_palette() -> Palette {
Palette::new(
Color::Reset,
Color::Reset,
Color::Reset,
Color::Reset,
Color::Reset,
crate::Fidelity::TrueColor,
)
}
#[test]
fn a_badge_is_round_and_a_chip_is_square() {
let style = style();
let badge = token("draft", Token::Badge, Tone::Neutral, false, false, &style);
assert_eq!(badge.to_string(), "(draft)");
let chip = token(
"rust",
Token::Chip { removable: false },
Tone::Neutral,
false,
false,
&style,
);
assert_eq!(chip.to_string(), "[rust]");
}
#[test]
fn a_filled_badge_is_an_edge_its_label_and_an_edge_in_the_same_two_cells() {
let palette = bare_palette().tones(
crate::Tones::NONE
.content(Color::White)
.danger(Color::LightRed)
.danger_surface(Color::Red),
);
let marks = PieceStyle {
badge_edges: ["<", ">"],
..PieceStyle::default()
};
let style = Ink::new(&palette, &marks);
let danger = style.badge(Tone::Danger).expect("the palette fills danger");
assert_eq!(danger.fill, Style::new().fg(Color::White).bg(Color::Red));
let badge = token("failed", Token::Badge, Tone::Danger, false, false, &style);
assert_eq!(badge.to_string(), "<failed>");
assert_eq!(badge.width(), "(failed)".len());
assert_eq!(badge.spans[1].style, danger.fill);
assert_eq!(badge.spans[0].style.fg, Some(Color::LightRed));
assert_eq!(badge.spans[0].style.bg, Some(Color::Red));
assert_eq!(badge.spans[2].style, badge.spans[0].style);
let chip = token(
"rust",
Token::Chip { removable: true },
Tone::Danger,
false,
false,
&style,
);
assert_eq!(chip.to_string(), "[rust]");
}
#[test]
fn a_latched_chip_reads_the_same_as_a_focused_one() {
let style = style();
let kind = Token::Chip { removable: false };
let latched = token("rust", kind, Tone::Neutral, true, false, &style);
let focused = token("rust", kind, Tone::Neutral, false, true, &style);
assert_eq!(latched.spans[0].style, focused.spans[0].style);
assert!(
latched.spans[0]
.style
.add_modifier
.contains(Modifier::REVERSED)
);
}
#[test]
fn a_tone_and_a_heading_map_without_a_fallback_arm() {
let style = style();
assert_eq!(style.tone(Tone::Neutral), style.content);
assert_eq!(style.tone(Tone::Danger), style.danger);
assert_eq!(style.heading(Heading::Page), style.page);
assert_eq!(style.heading(Heading::Subsection), style.subsection);
}
#[test]
fn the_default_style_carries_no_colour_at_all() {
let style = plain();
for painted in [style.content, style.danger, style.page, style.action] {
assert_eq!(painted.fg, None);
assert_eq!(painted.bg, None);
}
}
#[test]
fn the_three_states_of_a_wait_are_three_drawings() {
let style = plain();
let bare = awaiting(Awaiting::unmeasured(), Progress::default(), true, &style);
let sized = awaiting(Awaiting::of(41_943_040), Progress::default(), true, &style);
let watched = awaiting(
Awaiting::of(40),
Progress {
delivered: Some(20),
elapsed: Some(Duration::from_secs(4)),
},
true,
&style,
);
let read = |line: &Line<'_>| {
line.spans
.iter()
.map(|s| s.content.to_string())
.collect::<String>()
};
assert_eq!(read(&bare), "#");
assert_eq!(read(&sized), "# 41943040");
assert_eq!(
sized.spans[1].style, style.muted,
"the total in the reading's ink"
);
assert_eq!(read(&watched), "#####----- 20/40 4s");
}
#[test]
fn a_dark_mark_still_occupies_its_cell() {
let style = plain();
assert_eq!(activity(true, &style).content.chars().count(), 1);
assert_eq!(activity(false, &style).content.chars().count(), 1);
}
#[test]
fn an_over_delivered_wait_clamps_and_does_not_panic() {
let style = plain();
let over = awaiting(
Awaiting::of(4),
Progress {
delivered: Some(9),
elapsed: None,
},
true,
&style,
);
assert!(over.spans[0].content.chars().all(|c| c == '#'));
assert_eq!(over.spans[0].content.chars().count(), 10);
let empty = awaiting(
Awaiting::of(0),
Progress {
delivered: Some(9),
elapsed: None,
},
true,
&style,
);
assert!(empty.spans[0].content.starts_with('-'));
}
#[test]
fn a_toned_chip_says_its_tone_in_its_brackets_and_its_label_in_content() {
let style = style();
for kind in [Token::Chip { removable: false }, Token::Badge] {
let line = token("overdue", kind, Tone::Danger, false, false, &style);
let label = line
.spans
.iter()
.find(|span| span.content == "overdue")
.expect("the label is its own span");
assert_ne!(
label.style, style.danger,
"{kind:?}: the label is in the tone"
);
let [open, .., close] = &line.spans[..] else {
panic!("bracketed: {line:?}");
};
if kind == (Token::Chip { removable: false }) {
assert_eq!(label.style, style.content);
assert_eq!(open.style, style.danger);
assert_eq!(close.style, style.danger);
}
}
}
#[test]
fn a_heat_band_with_no_colour_adds_nothing() {
let ink = plain();
for band in 0..=makeover_layout::HEAT_BANDS {
assert_eq!(ink.heat(makeover_layout::Heat(band)), Style::new());
}
}
#[test]
fn a_band_reads_its_own_fill_and_one_past_the_last_reads_the_last() {
let mut ink = plain();
for (band, fill) in ink.heats.iter_mut().enumerate() {
*fill = Style::new().bg(Color::Indexed(band as u8));
}
let last = ink.heats[usize::from(HEAT_BANDS) - 1];
for band in 0..HEAT_BANDS {
assert_eq!(ink.heat(Heat(band)), ink.heats[usize::from(band)]);
}
assert_eq!(ink.heat(Heat(HEAT_BANDS)), last);
assert_eq!(ink.heat(Heat(u8::MAX)), last);
}