use std::{
path::{Path, PathBuf},
sync::{
Mutex,
atomic::{AtomicU64, Ordering},
},
time::{Duration, Instant},
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ScanPhase {
Discovery,
Resolution,
Analysis,
Reporting,
CleanupPreview,
CleanupSimulate,
CleanupExecute,
}
pub trait ProgressObserver: Send + Sync {
fn phase(&self, _phase: ScanPhase) {}
fn dirs_visited(&self, _batch: u64) {}
fn dirs_pruned(&self, _batch: u64) {}
fn manifests_found(&self, _batch: u64) {}
fn discovery_issues(&self, _count: u64) {}
fn workspaces_resolved(&self, _batch: u64) {}
fn cargo_failure(&self) {}
fn empty_skipped(&self) {}
fn active_skipped(&self) {}
fn group_measured(&self, _bytes: u64) {}
fn reportable_group(&self, _path: &Path, _bytes: u64) {}
fn units_total(&self, _phase: ScanPhase, _total: u64) {}
fn unit_completed(&self, _phase: ScanPhase) {}
}
#[derive(Debug, Default)]
pub struct NoopObserver;
impl ProgressObserver for NoopObserver {}
#[derive(Debug, Default)]
pub struct TestObserver {
pub phases: Mutex<Vec<ScanPhase>>,
pub visited: AtomicU64,
pub pruned: AtomicU64,
pub manifests: AtomicU64,
pub discovery_issues: AtomicU64,
pub workspaces: AtomicU64,
pub cargo_failures: AtomicU64,
pub empty_skipped: AtomicU64,
pub active_skipped: AtomicU64,
pub groups_measured: AtomicU64,
pub bytes_measured: AtomicU64,
pub reportable: Mutex<Vec<(PathBuf, u64)>>,
pub totals: Mutex<Vec<(ScanPhase, u64)>>,
pub completed: Mutex<Vec<ScanPhase>>,
}
impl TestObserver {
pub fn new() -> Self {
Self::default()
}
pub fn total_for(&self, phase: ScanPhase) -> Option<u64> {
self.totals
.lock()
.unwrap_or_else(|e| e.into_inner())
.iter()
.rev()
.find(|(p, _)| *p == phase)
.map(|(_, t)| *t)
}
pub fn completed_count(&self, phase: ScanPhase) -> usize {
self.completed
.lock()
.unwrap_or_else(|e| e.into_inner())
.iter()
.filter(|p| **p == phase)
.count()
}
}
impl ProgressObserver for TestObserver {
fn phase(&self, phase: ScanPhase) {
self.phases
.lock()
.unwrap_or_else(|e| e.into_inner())
.push(phase);
}
fn dirs_visited(&self, batch: u64) {
self.visited.fetch_add(batch, Ordering::Relaxed);
}
fn dirs_pruned(&self, batch: u64) {
self.pruned.fetch_add(batch, Ordering::Relaxed);
}
fn manifests_found(&self, batch: u64) {
self.manifests.fetch_add(batch, Ordering::Relaxed);
}
fn discovery_issues(&self, count: u64) {
self.discovery_issues.fetch_add(count, Ordering::Relaxed);
}
fn workspaces_resolved(&self, batch: u64) {
self.workspaces.fetch_add(batch, Ordering::Relaxed);
}
fn cargo_failure(&self) {
self.cargo_failures.fetch_add(1, Ordering::Relaxed);
}
fn empty_skipped(&self) {
self.empty_skipped.fetch_add(1, Ordering::Relaxed);
}
fn active_skipped(&self) {
self.active_skipped.fetch_add(1, Ordering::Relaxed);
}
fn group_measured(&self, bytes: u64) {
self.groups_measured.fetch_add(1, Ordering::Relaxed);
self.bytes_measured.fetch_add(bytes, Ordering::Relaxed);
}
fn reportable_group(&self, path: &Path, bytes: u64) {
self.reportable
.lock()
.unwrap_or_else(|e| e.into_inner())
.push((path.to_path_buf(), bytes));
}
fn units_total(&self, phase: ScanPhase, total: u64) {
self.totals
.lock()
.unwrap_or_else(|e| e.into_inner())
.push((phase, total));
}
fn unit_completed(&self, phase: ScanPhase) {
self.completed
.lock()
.unwrap_or_else(|e| e.into_inner())
.push(phase);
}
}
pub fn should_show_progress(no_progress: bool) -> bool {
if no_progress {
return false;
}
if term_is_dumb() {
return false;
}
#[allow(clippy::needless_bool)]
if !stderr_is_terminal() {
return false;
}
true
}
fn term_is_dumb() -> bool {
std::env::var_os("TERM").is_some_and(|v| v == "dumb")
}
fn stderr_is_terminal() -> bool {
use std::io::IsTerminal;
std::io::stderr().is_terminal()
}
fn spinner_style() -> indicatif::ProgressStyle {
indicatif::ProgressStyle::with_template("{spinner} {wide_msg}")
.expect("spinner template is a static string")
}
pub struct IndicatifRenderer {
hidden: bool,
verbose: bool,
multi: Option<indicatif::MultiProgress>,
main: Option<indicatif::ProgressBar>,
top: Mutex<Vec<(PathBuf, u64)>>,
last_draw: Mutex<Option<Instant>>,
pub refreshes: AtomicU64,
visited: AtomicU64,
pruned: AtomicU64,
manifests: AtomicU64,
discovery_issues: AtomicU64,
workspaces: AtomicU64,
cargo_failures: AtomicU64,
eligible: AtomicU64,
determinate_total: AtomicU64,
determinate_done: AtomicU64,
current_phase: Mutex<Option<ScanPhase>>,
}
impl IndicatifRenderer {
fn assemble(
hidden: bool,
verbose: bool,
multi: Option<indicatif::MultiProgress>,
main: Option<indicatif::ProgressBar>,
) -> Self {
Self {
hidden,
verbose,
multi,
main,
top: Mutex::new(Vec::new()),
last_draw: Mutex::new(None),
refreshes: AtomicU64::new(0),
visited: AtomicU64::new(0),
pruned: AtomicU64::new(0),
manifests: AtomicU64::new(0),
discovery_issues: AtomicU64::new(0),
workspaces: AtomicU64::new(0),
cargo_failures: AtomicU64::new(0),
eligible: AtomicU64::new(0),
determinate_total: AtomicU64::new(0),
determinate_done: AtomicU64::new(0),
current_phase: Mutex::new(None),
}
}
pub fn new(hidden: bool, verbose: bool) -> Self {
if hidden {
return Self::assemble(true, verbose, None, None);
}
let multi = indicatif::MultiProgress::with_draw_target(
indicatif::ProgressDrawTarget::stderr_with_hz(10),
);
let main = multi.add(indicatif::ProgressBar::new_spinner());
main.set_style(spinner_style());
main.enable_steady_tick(Duration::from_millis(100));
main.set_message("scanning…");
Self::assemble(false, verbose, Some(multi), Some(main))
}
pub fn new_in_memory_for_test(verbose: bool) -> (Self, indicatif::InMemoryTerm) {
let term = indicatif::InMemoryTerm::new(24, 120);
let multi = indicatif::MultiProgress::with_draw_target(
indicatif::ProgressDrawTarget::term_like_with_hz(Box::new(term.clone()), 10),
);
let main = multi.add(indicatif::ProgressBar::new_spinner());
main.set_style(spinner_style());
main.set_message("scanning…");
(
Self::assemble(false, verbose, Some(multi), Some(main)),
term,
)
}
pub fn is_hidden(&self) -> bool {
self.hidden
}
pub fn coordinated_bar_count(&self) -> usize {
if self.hidden {
return 0;
}
usize::from(self.main.is_some())
}
pub fn has_shared_draw_target(&self) -> bool {
if self.hidden {
return false;
}
self.multi.is_some()
}
pub fn set_determinate_total(&self, total: u64) {
self.determinate_total.store(total, Ordering::Relaxed);
}
fn reset_totals_for_phase(&self, phase: ScanPhase) {
let mut current = self.current_phase.lock().unwrap_or_else(|e| e.into_inner());
if *current != Some(phase) {
*current = Some(phase);
self.determinate_total.store(0, Ordering::Relaxed);
self.determinate_done.store(0, Ordering::Relaxed);
}
}
fn apply_total(&self, total: u64) {
self.determinate_total.store(total, Ordering::Relaxed);
self.determinate_done.store(0, Ordering::Relaxed);
}
fn apply_completed(&self) {
self.determinate_done.fetch_add(1, Ordering::Relaxed);
}
fn phase_label(phase: ScanPhase) -> &'static str {
match phase {
ScanPhase::Discovery => "scanning",
ScanPhase::Resolution => "resolving workspaces",
ScanPhase::Analysis => "analyzing output",
ScanPhase::Reporting => "reporting",
ScanPhase::CleanupPreview => "previewing cleanup",
ScanPhase::CleanupSimulate => "simulating cleanup",
ScanPhase::CleanupExecute => "cleaning",
}
}
fn compose_message(&self) -> String {
let phase = *self.current_phase.lock().unwrap_or_else(|e| e.into_inner());
let label = Self::phase_label(phase.unwrap_or(ScanPhase::Discovery));
let done = self.determinate_done.load(Ordering::Relaxed);
let total = self.determinate_total.load(Ordering::Relaxed);
let fraction = if total > 0 {
format!(" {done}/{total}")
} else {
String::new()
};
if !self.verbose {
return format!("{label}{fraction}…");
}
let visited = self.visited.load(Ordering::Relaxed);
let pruned = self.pruned.load(Ordering::Relaxed);
let manifests = self.manifests.load(Ordering::Relaxed);
let discovery_issues = self.discovery_issues.load(Ordering::Relaxed);
let workspaces = self.workspaces.load(Ordering::Relaxed);
let cargo_failures = self.cargo_failures.load(Ordering::Relaxed);
let eligible = self.eligible.load(Ordering::Relaxed);
format!(
"{label}{fraction}… visited {visited} pruned {pruned} manifests {manifests} workspaces {workspaces} discovery-errors {discovery_issues} cargo-failures {cargo_failures} eligible {eligible}"
)
}
fn maybe_draw(&self) {
if self.hidden {
return;
}
let mut last = self.last_draw.lock().unwrap_or_else(|e| e.into_inner());
let now = Instant::now();
if let Some(prev) = *last
&& now.duration_since(prev) < Duration::from_millis(100)
{
return;
}
*last = Some(now);
drop(last);
self.refreshes.fetch_add(1, Ordering::Relaxed);
let msg = self.compose_message();
if let Some(main) = &self.main {
main.set_message(msg);
main.tick();
let total = self.determinate_total.load(Ordering::Relaxed);
if total > 0 {
let done = self.determinate_done.load(Ordering::Relaxed);
main.set_position(done.min(total));
}
}
}
pub fn finish_and_clear(&self) {
if self.hidden {
return;
}
if let Some(main) = &self.main {
main.disable_steady_tick();
}
if let Some(multi) = &self.multi {
let _ = multi.clear();
}
if let Some(main) = &self.main {
main.finish_and_clear();
}
}
pub fn refresh_count(&self) -> u64 {
self.refreshes.load(Ordering::Relaxed)
}
pub fn top_groups(&self) -> Vec<(PathBuf, u64)> {
self.top.lock().unwrap_or_else(|e| e.into_inner()).clone()
}
pub fn determinate_total_value(&self) -> u64 {
self.determinate_total.load(Ordering::Relaxed)
}
pub fn determinate_done_value(&self) -> u64 {
self.determinate_done.load(Ordering::Relaxed)
}
}
impl ProgressObserver for IndicatifRenderer {
fn phase(&self, phase: ScanPhase) {
self.reset_totals_for_phase(phase);
if self.hidden {
return;
}
self.maybe_draw();
}
fn dirs_visited(&self, batch: u64) {
self.visited.fetch_add(batch, Ordering::Relaxed);
self.maybe_draw();
}
fn dirs_pruned(&self, batch: u64) {
self.pruned.fetch_add(batch, Ordering::Relaxed);
self.maybe_draw();
}
fn manifests_found(&self, batch: u64) {
self.manifests.fetch_add(batch, Ordering::Relaxed);
self.maybe_draw();
}
fn discovery_issues(&self, count: u64) {
self.discovery_issues.fetch_add(count, Ordering::Relaxed);
self.maybe_draw();
}
fn workspaces_resolved(&self, batch: u64) {
self.workspaces.fetch_add(batch, Ordering::Relaxed);
self.maybe_draw();
}
fn cargo_failure(&self) {
self.cargo_failures.fetch_add(1, Ordering::Relaxed);
self.maybe_draw();
}
fn empty_skipped(&self) {
self.maybe_draw();
}
fn active_skipped(&self) {
self.maybe_draw();
}
fn group_measured(&self, _bytes: u64) {
self.maybe_draw();
}
fn reportable_group(&self, path: &Path, bytes: u64) {
self.eligible.fetch_add(1, Ordering::Relaxed);
{
let mut top = self.top.lock().unwrap_or_else(|e| e.into_inner());
top.push((path.to_path_buf(), bytes));
top.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
top.truncate(5);
}
self.maybe_draw();
}
fn units_total(&self, phase: ScanPhase, total: u64) {
self.reset_totals_for_phase(phase);
self.apply_total(total);
self.maybe_draw();
}
fn unit_completed(&self, phase: ScanPhase) {
self.reset_totals_for_phase(phase);
self.apply_completed();
self.maybe_draw();
}
}
#[cfg(test)]
pub(crate) mod test_env {
pub(crate) fn run_in_child(marker: &str, probe: &str) -> std::process::Output {
let exe = std::env::current_exe().unwrap();
std::process::Command::new(exe)
.args([probe, "--exact", "--nocapture"])
.env(marker, "1")
.output()
.unwrap()
}
pub(crate) fn assert_probe_ran(out: &std::process::Output) {
let stdout = String::from_utf8_lossy(&out.stdout);
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(
out.status.success(),
"probe child failed: {stdout}\n{stderr}"
);
assert!(
stdout.contains("1 passed"),
"probe must execute exactly once (filter premise): {stdout}\n{stderr}"
);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn noop_observer_is_free_and_hidden_renderer_emits_nothing() {
let noop = NoopObserver;
noop.dirs_visited(100);
noop.reportable_group(Path::new("/tmp/x"), 10);
noop.units_total(ScanPhase::Analysis, 3);
noop.unit_completed(ScanPhase::Analysis);
let hidden = IndicatifRenderer::new(true, false);
assert!(hidden.is_hidden());
assert_eq!(hidden.refresh_count(), 0);
assert_eq!(hidden.coordinated_bar_count(), 0);
assert!(!hidden.has_shared_draw_target());
hidden.dirs_visited(1000);
assert_eq!(hidden.refresh_count(), 0);
hidden.reportable_group(Path::new("/tmp/a"), 5);
assert_eq!(hidden.top_groups().len(), 1);
hidden.finish_and_clear();
}
#[test]
fn coordinated_renderer_owns_exactly_one_bar_on_one_draw_target() {
let (r, _term) = IndicatifRenderer::new_in_memory_for_test(false);
assert!(!r.is_hidden());
assert_eq!(r.coordinated_bar_count(), 1);
assert!(r.has_shared_draw_target());
r.finish_and_clear();
}
#[test]
fn in_memory_frame_contains_exactly_one_progress_line_naming_the_phase() {
let (r, term) = IndicatifRenderer::new_in_memory_for_test(false);
r.phase(ScanPhase::Analysis);
r.discovery_issues(7);
r.cargo_failure();
r.cargo_failure();
r.units_total(ScanPhase::Analysis, 6);
r.unit_completed(ScanPhase::Analysis);
for i in 0..6 {
r.reportable_group(&PathBuf::from(format!("/tmp/g{i}")), (i as u64 + 1) * 100);
std::thread::sleep(Duration::from_millis(110));
}
std::thread::sleep(Duration::from_millis(150));
let contents = term.contents();
let non_empty: Vec<&str> = contents.lines().filter(|l| !l.trim().is_empty()).collect();
assert!(
non_empty.len() <= 1,
"the composed frame must be one line, got {}: {contents:?}",
non_empty.len()
);
assert!(
contents.contains("analyzing output"),
"the phase must be visible on the drawn line: {contents:?}"
);
assert!(
contents.contains("1/6"),
"the done fraction must be visible once the total is known: {contents:?}"
);
for _ in 0..20 {
r.dirs_visited(1);
std::thread::sleep(Duration::from_millis(110));
}
std::thread::sleep(Duration::from_millis(150));
let after = term.contents();
let after_lines: Vec<&str> = after.lines().filter(|l| !l.trim().is_empty()).collect();
assert!(
after_lines.len() <= 1,
"refreshes must not scroll unboundedly: {after:?}"
);
r.finish_and_clear();
}
#[test]
fn the_verbose_surface_adds_counters_to_the_same_single_line() {
let (r, term) = IndicatifRenderer::new_in_memory_for_test(true);
r.phase(ScanPhase::Analysis);
r.units_total(ScanPhase::Analysis, 6);
std::thread::sleep(Duration::from_millis(110));
r.discovery_issues(7);
r.cargo_failure();
r.cargo_failure();
std::thread::sleep(Duration::from_millis(110));
r.maybe_draw();
std::thread::sleep(Duration::from_millis(150));
let contents = term.contents();
let non_empty: Vec<&str> = contents.lines().filter(|l| !l.trim().is_empty()).collect();
assert!(
non_empty.len() <= 1,
"the verbose frame must still be one line, got {}: {contents:?}",
non_empty.len()
);
assert!(
contents.contains("discovery-errors 7"),
"the verbose line carries the counters: {contents:?}"
);
assert!(
contents.contains("cargo-failures 2"),
"the verbose line carries the counters: {contents:?}"
);
assert!(
contents.contains("analyzing output"),
"the verbose line still names the phase: {contents:?}"
);
r.finish_and_clear();
}
#[test]
fn the_quiet_surface_carries_no_counters() {
let (r, term) = IndicatifRenderer::new_in_memory_for_test(false);
r.phase(ScanPhase::Analysis);
r.units_total(ScanPhase::Analysis, 6);
std::thread::sleep(Duration::from_millis(110));
r.discovery_issues(7);
r.cargo_failure();
std::thread::sleep(Duration::from_millis(110));
r.maybe_draw();
std::thread::sleep(Duration::from_millis(150));
let contents = term.contents();
assert!(
!contents.contains("visited") && !contents.contains("cargo-failures"),
"the quiet surface carries no counters: {contents:?}"
);
assert!(contents.contains("analyzing output"), "{contents:?}");
r.finish_and_clear();
}
#[test]
fn renderer_caps_the_observed_candidates_at_five_largest_first() {
let r = IndicatifRenderer::new(true, false);
for i in 0..10 {
r.reportable_group(&PathBuf::from(format!("/tmp/g{i}")), i * 100);
}
let top = r.top_groups();
assert_eq!(top.len(), 5);
assert_eq!(top[0].1, 900);
assert_eq!(top[4].1, 500);
}
#[test]
fn test_observer_records_semantic_events() {
let o = TestObserver::new();
o.phase(ScanPhase::Discovery);
o.dirs_visited(3);
o.manifests_found(1);
o.reportable_group(Path::new("/a"), 7);
o.units_total(ScanPhase::Analysis, 4);
o.unit_completed(ScanPhase::Analysis);
assert_eq!(o.visited.load(Ordering::Relaxed), 3);
assert_eq!(
o.reportable.lock().unwrap_or_else(|e| e.into_inner()).len(),
1
);
assert_eq!(o.total_for(ScanPhase::Analysis), Some(4));
assert_eq!(o.completed_count(ScanPhase::Analysis), 1);
}
#[test]
fn should_show_progress_respects_flag_and_dumb_term() {
assert!(!should_show_progress(true), "the explicit flag is absolute");
let out = crate::progress::test_env::run_in_child(
"PROGRESS_ENV_PROBE_ARMED",
"progress::tests::term_is_dumb_probe",
);
crate::progress::test_env::assert_probe_ran(&out);
}
#[test]
fn term_is_dumb_probe() {
if std::env::var("PROGRESS_ENV_PROBE_ARMED").is_err() {
return;
}
unsafe { std::env::set_var("TERM", "dumb") };
assert!(term_is_dumb(), "TERM=dumb must refuse progress");
unsafe { std::env::set_var("TERM", "xterm-256color") };
assert!(!term_is_dumb(), "only the literal `dumb` refuses progress");
}
#[test]
fn renderer_refresh_bounded_independently_of_entry_count() {
let hidden = IndicatifRenderer::new(true, false);
for _ in 0..10_000 {
hidden.dirs_visited(1);
}
assert_eq!(hidden.refresh_count(), 0);
}
#[test]
fn discovery_begins_indeterminate_then_analysis_determinate() {
let r = IndicatifRenderer::new(true, false);
r.phase(ScanPhase::Discovery);
assert_eq!(
r.determinate_total_value(),
0,
"discovery must not set a total (would require wasteful pre-scan)"
);
r.units_total(ScanPhase::Analysis, 7);
assert_eq!(r.determinate_total_value(), 7);
r.phase(ScanPhase::Analysis);
assert_eq!(r.determinate_total_value(), 7);
r.units_total(ScanPhase::Analysis, 7);
r.group_measured(100);
assert_eq!(r.determinate_done_value(), 0);
r.unit_completed(ScanPhase::Analysis);
assert_eq!(r.determinate_done_value(), 1);
}
#[test]
fn unit_events_rescope_totals_on_a_phase_change_without_an_explicit_phase_call() {
let r = IndicatifRenderer::new(true, false);
r.units_total(ScanPhase::Analysis, 5);
r.unit_completed(ScanPhase::Analysis);
r.unit_completed(ScanPhase::Analysis);
assert_eq!(r.determinate_total_value(), 5);
assert_eq!(r.determinate_done_value(), 2);
r.units_total(ScanPhase::CleanupExecute, 2);
assert_eq!(r.determinate_total_value(), 2);
assert_eq!(r.determinate_done_value(), 0);
r.unit_completed(ScanPhase::CleanupExecute);
assert_eq!(r.determinate_done_value(), 1);
}
#[test]
fn phase_total_resets_so_cleanup_cannot_reuse_analysis_counts() {
let r = IndicatifRenderer::new(true, false);
r.phase(ScanPhase::Analysis);
r.units_total(ScanPhase::Analysis, 5);
r.unit_completed(ScanPhase::Analysis);
assert_eq!(r.determinate_total_value(), 5);
r.phase(ScanPhase::CleanupSimulate);
assert_eq!(r.determinate_total_value(), 0);
assert_eq!(r.determinate_done_value(), 0);
r.units_total(ScanPhase::CleanupSimulate, 2);
r.unit_completed(ScanPhase::CleanupSimulate);
assert_eq!(r.determinate_total_value(), 2);
assert_eq!(r.determinate_done_value(), 1);
}
#[test]
fn sizes_render_in_top_rows_and_clear_before_report() {
let r = IndicatifRenderer::new(true, false);
r.reportable_group(Path::new("/tmp/big"), 2048);
let top = r.top_groups();
assert_eq!(top.len(), 1);
assert!(crate::report::format_bytes(2048).contains("2.00"));
r.finish_and_clear();
r.finish_and_clear();
}
#[test]
fn renderer_error_falls_back_without_failing_scan() {
let hidden = IndicatifRenderer::new(true, false);
hidden.phase(ScanPhase::Discovery);
hidden.dirs_visited(10);
hidden.reportable_group(Path::new("/a"), 1);
hidden.finish_and_clear();
assert_eq!(hidden.refresh_count(), 0);
}
fn draw_cleanup_bar(renderer: &IndicatifRenderer) {
renderer.phase(ScanPhase::CleanupExecute);
renderer.units_total(ScanPhase::CleanupExecute, 2);
renderer.dirs_visited(3);
renderer.reportable_group(Path::new("/tmp/group-a"), 4096);
renderer.unit_completed(ScanPhase::CleanupExecute);
}
fn flush_draw_target() {
std::thread::sleep(Duration::from_millis(150));
}
fn live_bars(renderer: &IndicatifRenderer) -> usize {
std::iter::once(renderer.main.as_ref())
.flatten()
.filter(|bar| !bar.is_finished())
.count()
}
#[test]
fn finish_and_clear_leaves_no_live_bar_for_a_later_error_or_drop() {
let (r, term) = IndicatifRenderer::new_in_memory_for_test(false);
draw_cleanup_bar(&r);
flush_draw_target();
assert!(
!term.contents().trim().is_empty(),
"the cleanup bar must draw before the clear is exercised"
);
assert_eq!(
live_bars(&r),
1,
"the single coordinated bar is live before the clear"
);
let cleanup: Result<(), crate::error::AppError> = Err(crate::error::AppError::Io(
std::io::Error::other("cleanup failed"),
));
r.finish_and_clear();
assert_eq!(
term.contents().trim(),
"",
"the clear must take the drawn frame down"
);
assert_eq!(
live_bars(&r),
0,
"the clear must leave no live bar for drop to finish into a retained line"
);
let refreshes = r.refresh_count();
let outcome = cleanup;
assert!(outcome.is_err(), "the simulated cleanup must fail");
assert_eq!(
live_bars(&r),
0,
"an error raised after the clear must not leave a live bar"
);
assert_eq!(
r.refresh_count(),
refreshes,
"an error raised after the clear must not redraw"
);
drop(r);
flush_draw_target();
assert_eq!(term.contents().trim(), "");
}
}