summaryrefslogtreecommitdiff
path: root/vendor/indicatif/tests/render.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/indicatif/tests/render.rs')
-rw-r--r--vendor/indicatif/tests/render.rs1822
1 files changed, 1822 insertions, 0 deletions
diff --git a/vendor/indicatif/tests/render.rs b/vendor/indicatif/tests/render.rs
new file mode 100644
index 0000000..a891e72
--- /dev/null
+++ b/vendor/indicatif/tests/render.rs
@@ -0,0 +1,1822 @@
+#![cfg(feature = "in_memory")]
+
+use std::time::Duration;
+
+use indicatif::{
+ InMemoryTerm, MultiProgress, MultiProgressAlignment, ProgressBar, ProgressDrawTarget,
+ ProgressFinish, ProgressStyle, TermLike,
+};
+use pretty_assertions::assert_eq;
+
+#[test]
+fn basic_progress_bar() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let pb = ProgressBar::with_draw_target(
+ Some(10),
+ ProgressDrawTarget::term_like(Box::new(in_mem.clone())),
+ );
+
+ assert_eq!(in_mem.contents(), String::new());
+
+ pb.tick();
+ assert_eq!(
+ in_mem.contents(),
+ "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10"
+ );
+
+ pb.inc(1);
+ assert_eq!(
+ in_mem.contents(),
+ "███████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 1/10"
+ );
+
+ pb.finish();
+ assert_eq!(
+ in_mem.contents(),
+ "██████████████████████████████████████████████████████████████████████████ 10/10"
+ );
+}
+
+#[test]
+fn progress_bar_builder_method_order() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ // Test that `with_style` doesn't overwrite the message or prefix
+ let pb = ProgressBar::with_draw_target(
+ Some(10),
+ ProgressDrawTarget::term_like(Box::new(in_mem.clone())),
+ )
+ .with_message("crate")
+ .with_prefix("Downloading")
+ .with_style(
+ ProgressStyle::with_template("{prefix:>12.cyan.bold} {msg}: {wide_bar} {pos}/{len}")
+ .unwrap(),
+ );
+
+ assert_eq!(in_mem.contents(), String::new());
+
+ pb.tick();
+ assert_eq!(
+ in_mem.contents(),
+ " Downloading crate: ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10"
+ );
+}
+
+#[test]
+fn progress_bar_percent_with_no_length() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let pb = ProgressBar::with_draw_target(
+ None,
+ ProgressDrawTarget::term_like(Box::new(in_mem.clone())),
+ )
+ .with_style(ProgressStyle::with_template("{wide_bar} {percent}%").unwrap());
+
+ assert_eq!(in_mem.contents(), String::new());
+
+ pb.tick();
+
+ assert_eq!(
+ in_mem.contents(),
+ "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0%"
+ );
+
+ pb.set_length(10);
+
+ pb.inc(1);
+ assert_eq!(
+ in_mem.contents(),
+ "███████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 10%"
+ );
+
+ pb.finish();
+ assert_eq!(
+ in_mem.contents(),
+ "███████████████████████████████████████████████████████████████████████████ 100%"
+ );
+}
+
+#[test]
+fn multi_progress_single_bar_and_leave() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let pb1 = mp.add(ProgressBar::new(10).with_finish(ProgressFinish::AndLeave));
+
+ assert_eq!(in_mem.contents(), String::new());
+
+ pb1.tick();
+ assert_eq!(
+ in_mem.contents(),
+ r#"░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10"#
+ );
+
+ drop(pb1);
+ assert_eq!(
+ in_mem.contents(),
+ r#"██████████████████████████████████████████████████████████████████████████ 10/10"#
+ );
+}
+
+#[test]
+fn multi_progress_single_bar_and_clear() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let pb1 = mp.add(ProgressBar::new(10));
+
+ assert_eq!(in_mem.contents(), String::new());
+
+ pb1.tick();
+ assert_eq!(
+ in_mem.contents(),
+ r#"░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10"#
+ );
+
+ drop(pb1);
+ assert_eq!(in_mem.contents(), "");
+}
+#[test]
+fn multi_progress_two_bars() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let pb1 = mp.add(ProgressBar::new(10).with_finish(ProgressFinish::AndLeave));
+ let pb2 = mp.add(ProgressBar::new(5));
+
+ assert_eq!(in_mem.contents(), String::new());
+
+ pb1.tick();
+ assert_eq!(
+ in_mem.contents(),
+ r#"░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10"#
+ );
+
+ pb2.tick();
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/5"#
+ .trim_start()
+ );
+
+ drop(pb1);
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+██████████████████████████████████████████████████████████████████████████ 10/10
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/5"#
+ .trim_start()
+ );
+
+ drop(pb2);
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"██████████████████████████████████████████████████████████████████████████ 10/10"#
+ );
+}
+
+#[test]
+fn multi_progress() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let pb1 = mp.add(ProgressBar::new(10).with_finish(ProgressFinish::AndLeave));
+ let pb2 = mp.add(ProgressBar::new(5));
+ let pb3 = mp.add(ProgressBar::new(100));
+
+ assert_eq!(in_mem.contents(), String::new());
+
+ pb1.tick();
+ assert_eq!(
+ in_mem.contents(),
+ r#"░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10"#
+ );
+
+ pb2.tick();
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/5"#
+ .trim_start()
+ );
+
+ pb3.tick();
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/5
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/100"#
+ .trim_start()
+ );
+
+ drop(pb1);
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+██████████████████████████████████████████████████████████████████████████ 10/10
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/5
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/100"#
+ .trim_start()
+ );
+
+ drop(pb2);
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+██████████████████████████████████████████████████████████████████████████ 10/10
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/100"#
+ .trim_start()
+ );
+
+ drop(pb3);
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"██████████████████████████████████████████████████████████████████████████ 10/10"#
+ );
+}
+
+#[test]
+fn multi_progress_println() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let pb1 = mp.add(ProgressBar::new(10));
+ let pb2 = mp.add(ProgressBar::new(5));
+ let pb3 = mp.add(ProgressBar::new(100));
+
+ assert_eq!(in_mem.contents(), "");
+
+ pb1.inc(2);
+ mp.println("message printed :)").unwrap();
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+message printed :)
+███████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 2/10
+ "#
+ .trim()
+ );
+
+ mp.println("another great message!").unwrap();
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+message printed :)
+another great message!
+███████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 2/10
+ "#
+ .trim()
+ );
+
+ pb2.inc(1);
+ pb3.tick();
+ mp.println("one last message").unwrap();
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+message printed :)
+another great message!
+one last message
+███████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 2/10
+███████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 1/5
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/100
+ "#
+ .trim()
+ );
+
+ drop(pb1);
+ drop(pb2);
+ drop(pb3);
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+message printed :)
+another great message!
+one last message"#
+ .trim()
+ );
+}
+
+#[test]
+fn multi_progress_suspend() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let pb1 = mp.add(ProgressBar::new(10));
+ let pb2 = mp.add(ProgressBar::new(10));
+
+ assert_eq!(in_mem.contents(), "");
+
+ pb1.inc(2);
+ mp.println("message printed :)").unwrap();
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+message printed :)
+███████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 2/10
+ "#
+ .trim()
+ );
+
+ mp.suspend(|| {
+ in_mem.write_line("This is write_line output!").unwrap();
+ in_mem.write_line("And so is this").unwrap();
+ in_mem.move_cursor_down(1).unwrap();
+ });
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+message printed :)
+This is write_line output!
+And so is this
+
+███████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 2/10
+ "#
+ .trim()
+ );
+
+ pb2.inc(1);
+ mp.println("Another line printed").unwrap();
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+message printed :)
+This is write_line output!
+And so is this
+
+Another line printed
+███████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 2/10
+███████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 1/10
+ "#
+ .trim()
+ );
+
+ drop(pb1);
+ drop(pb2);
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+message printed :)
+This is write_line output!
+And so is this
+
+Another line printed"#
+ .trim()
+ );
+}
+
+#[test]
+fn ticker_drop() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let mut spinner: Option<ProgressBar> = None;
+
+ for i in 0..5 {
+ let new_spinner = mp.add(
+ ProgressBar::new_spinner()
+ .with_finish(ProgressFinish::AndLeave)
+ .with_message(format!("doing stuff {i}")),
+ );
+ new_spinner.enable_steady_tick(Duration::from_millis(100));
+ spinner.replace(new_spinner);
+ }
+
+ drop(spinner);
+ assert_eq!(
+ in_mem.contents(),
+ " doing stuff 0\n doing stuff 1\n doing stuff 2\n doing stuff 3\n doing stuff 4"
+ );
+}
+
+#[test]
+fn manually_inc_ticker() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let spinner = mp.add(ProgressBar::new_spinner().with_message("msg"));
+
+ assert_eq!(in_mem.contents(), "");
+
+ spinner.inc(1);
+ assert_eq!(in_mem.contents(), "⠁ msg");
+
+ spinner.inc(1);
+ assert_eq!(in_mem.contents(), "⠉ msg");
+
+ // set_message / set_prefix shouldn't increase tick
+ spinner.set_message("new message");
+ spinner.set_prefix("prefix");
+ assert_eq!(in_mem.contents(), "⠉ new message");
+}
+
+#[test]
+fn multi_progress_prune_zombies() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let pb0 = mp
+ .add(ProgressBar::new(10))
+ .with_finish(ProgressFinish::AndLeave);
+ let pb1 = mp.add(ProgressBar::new(15));
+ pb0.tick();
+ assert_eq!(
+ in_mem.contents(),
+ "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10"
+ );
+
+ pb0.inc(1);
+ assert_eq!(
+ in_mem.contents(),
+ "███████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 1/10"
+ );
+
+ drop(pb0);
+
+ // Clear the screen
+ mp.clear().unwrap();
+
+ // Write a line that we expect to remain. This helps ensure the adjustment to last_line_count is
+ // working as expected, and `MultiState` isn't erasing lines when it shouldn't.
+ in_mem.write_line("don't erase me plz").unwrap();
+
+ // pb0 is dead, so only pb1 should be drawn from now on
+ pb1.tick();
+ assert_eq!(
+ in_mem.contents(),
+ "don't erase me plz\n░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/15"
+ );
+}
+
+#[test]
+fn multi_progress_prune_zombies_2() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let pb1 = mp.add(ProgressBar::new(10).with_finish(ProgressFinish::AndLeave));
+ let pb2 = mp.add(ProgressBar::new(5));
+ let pb3 = mp
+ .add(ProgressBar::new(100))
+ .with_finish(ProgressFinish::Abandon);
+ let pb4 = mp
+ .add(ProgressBar::new(500))
+ .with_finish(ProgressFinish::AndLeave);
+ let pb5 = mp.add(ProgressBar::new(7));
+
+ assert_eq!(in_mem.contents(), String::new());
+
+ pb1.tick();
+ assert_eq!(
+ in_mem.contents(),
+ r#"░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10"#
+ );
+
+ pb2.tick();
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/5"#
+ .trim_start()
+ );
+
+ pb3.tick();
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/5
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/100"#
+ .trim_start()
+ );
+
+ drop(pb1);
+ drop(pb2);
+ drop(pb3);
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+██████████████████████████████████████████████████████████████████████████ 10/10
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/100"#
+ .trim_start()
+ );
+
+ mp.clear().unwrap();
+
+ assert_eq!(in_mem.contents(), "");
+
+ // A sacrificial line we expect shouldn't be touched
+ in_mem.write_line("don't erase plz").unwrap();
+
+ mp.println("Test friend :)").unwrap();
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+don't erase plz
+Test friend :)"#
+ .trim_start()
+ );
+
+ pb4.tick();
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+don't erase plz
+Test friend :)
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/500"#
+ .trim_start()
+ );
+
+ drop(pb4);
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+don't erase plz
+Test friend :)
+████████████████████████████████████████████████████████████████████████ 500/500"#
+ .trim_start()
+ );
+
+ mp.clear().unwrap();
+ assert_eq!(in_mem.contents(), "don't erase plz\nTest friend :)");
+
+ pb5.tick();
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+don't erase plz
+Test friend :)
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/7"#
+ .trim_start()
+ );
+
+ mp.println("not your friend, buddy").unwrap();
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+don't erase plz
+Test friend :)
+not your friend, buddy
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/7"#
+ .trim_start()
+ );
+
+ pb5.inc(1);
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+don't erase plz
+Test friend :)
+not your friend, buddy
+██████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 1/7"#
+ .trim_start()
+ );
+
+ mp.clear().unwrap();
+ in_mem.write_line("don't erase me either").unwrap();
+
+ pb5.inc(1);
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+don't erase plz
+Test friend :)
+not your friend, buddy
+don't erase me either
+█████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 2/7"#
+ .trim_start()
+ );
+
+ drop(pb5);
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+don't erase plz
+Test friend :)
+not your friend, buddy
+don't erase me either"#
+ .trim_start()
+ );
+}
+
+#[test]
+fn basic_tab_expansion() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let mut spinner = mp.add(ProgressBar::new_spinner().with_message("Test\t:)"));
+ spinner.tick();
+
+ // 8 is the default number of spaces
+ assert_eq!(in_mem.contents(), "⠁ Test :)");
+
+ spinner.set_tab_width(4);
+ assert_eq!(in_mem.contents(), "⠁ Test :)");
+}
+
+#[test]
+fn tab_expansion_in_template() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let mut spinner = mp.add(
+ ProgressBar::new_spinner()
+ .with_message("Test\t:)")
+ .with_prefix("Pre\tfix!")
+ .with_style(ProgressStyle::with_template("{spinner}{prefix}\t{msg}").unwrap()),
+ );
+
+ spinner.tick();
+ assert_eq!(in_mem.contents(), "⠁Pre fix! Test :)");
+
+ spinner.set_tab_width(4);
+ assert_eq!(in_mem.contents(), "⠁Pre fix! Test :)");
+
+ spinner.set_tab_width(2);
+ assert_eq!(in_mem.contents(), "⠁Pre fix! Test :)");
+}
+
+#[test]
+fn progress_style_tab_width_unification() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ // Style will have default of 8 spaces for tabs
+ let style = ProgressStyle::with_template("{msg}\t{msg}").unwrap();
+
+ let spinner = mp.add(
+ ProgressBar::new_spinner()
+ .with_message("OK")
+ .with_tab_width(4),
+ );
+
+ // Setting the spinner's style to |style| should override the style's tab width with that of bar
+ spinner.set_style(style);
+ spinner.tick();
+ assert_eq!(in_mem.contents(), "OK OK");
+}
+
+#[test]
+fn multi_progress_clear_println() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ mp.println("Test of println").unwrap();
+ // Should have no effect
+ mp.clear().unwrap();
+ assert_eq!(in_mem.contents(), "Test of println");
+}
+
+#[test]
+fn multi_progress_clear_zombies_no_ticks() {
+ _multi_progress_clear_zombies(0);
+}
+
+#[test]
+fn multi_progress_clear_zombies_one_tick() {
+ _multi_progress_clear_zombies(1);
+}
+
+#[test]
+fn multi_progress_clear_zombies_two_ticks() {
+ _multi_progress_clear_zombies(2);
+}
+
+// In the old (broken) implementation, zombie handling sometimes worked differently depending on
+// how many draws were between certain operations. Let's make sure that doesn't happen again.
+fn _multi_progress_clear_zombies(ticks: usize) {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+ let style = ProgressStyle::with_template("{msg}").unwrap();
+
+ let pb1 = mp.add(
+ ProgressBar::new_spinner()
+ .with_style(style.clone())
+ .with_message("pb1"),
+ );
+ pb1.tick();
+
+ let pb2 = mp.add(
+ ProgressBar::new_spinner()
+ .with_style(style)
+ .with_message("pb2"),
+ );
+
+ pb2.tick();
+ assert_eq!(in_mem.contents(), "pb1\npb2");
+
+ pb1.finish_with_message("pb1 done");
+ drop(pb1);
+ assert_eq!(in_mem.contents(), "pb1 done\npb2");
+
+ for _ in 0..ticks {
+ pb2.tick();
+ }
+
+ mp.clear().unwrap();
+ assert_eq!(in_mem.contents(), "");
+}
+
+// This test reproduces examples/multi.rs in a simpler form
+#[test]
+fn multi_zombie_handling() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+ let style = ProgressStyle::with_template("{msg}").unwrap();
+
+ let pb1 = mp.add(
+ ProgressBar::new_spinner()
+ .with_style(style.clone())
+ .with_message("pb1"),
+ );
+ pb1.tick();
+ let pb2 = mp.add(
+ ProgressBar::new_spinner()
+ .with_style(style.clone())
+ .with_message("pb2"),
+ );
+ pb2.tick();
+ let pb3 = mp.add(
+ ProgressBar::new_spinner()
+ .with_style(style)
+ .with_message("pb3"),
+ );
+ pb3.tick();
+
+ mp.println("pb1 done!").unwrap();
+ pb1.finish_with_message("done");
+ assert_eq!(in_mem.contents(), "pb1 done!\ndone\npb2\npb3");
+ drop(pb1);
+
+ assert_eq!(in_mem.contents(), "pb1 done!\ndone\npb2\npb3");
+
+ pb2.tick();
+ assert_eq!(in_mem.contents(), "pb1 done!\ndone\npb2\npb3");
+ pb3.tick();
+ assert_eq!(in_mem.contents(), "pb1 done!\ndone\npb2\npb3");
+
+ mp.println("pb3 done!").unwrap();
+ assert_eq!(in_mem.contents(), "pb1 done!\npb3 done!\npb2\npb3");
+
+ pb3.finish_with_message("done");
+ drop(pb3);
+
+ pb2.tick();
+
+ mp.println("pb2 done!").unwrap();
+ pb2.finish_with_message("done");
+ drop(pb2);
+
+ assert_eq!(
+ in_mem.contents(),
+ "pb1 done!\npb3 done!\npb2 done!\ndone\ndone"
+ );
+
+ mp.clear().unwrap();
+
+ assert_eq!(in_mem.contents(), "pb1 done!\npb3 done!\npb2 done!");
+}
+
+#[test]
+fn multi_progress_multiline_msg() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let pb1 = mp.add(ProgressBar::new_spinner().with_message("test1"));
+ let pb2 = mp.add(ProgressBar::new_spinner().with_message("test2"));
+
+ assert_eq!(in_mem.contents(), "");
+
+ pb1.inc(1);
+ pb2.inc(1);
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+⠁ test1
+⠁ test2
+ "#
+ .trim()
+ );
+
+ pb1.set_message("test1\n test1 line2\n test1 line3");
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+⠁ test1
+ test1 line2
+ test1 line3
+⠁ test2
+ "#
+ .trim()
+ );
+
+ pb1.inc(1);
+ pb2.inc(1);
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+⠉ test1
+ test1 line2
+ test1 line3
+⠉ test2
+ "#
+ .trim()
+ );
+
+ pb2.set_message("test2\n test2 line2");
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+⠉ test1
+ test1 line2
+ test1 line3
+⠉ test2
+ test2 line2
+ "#
+ .trim()
+ );
+
+ pb1.set_message("single line again");
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+⠉ single line again
+⠉ test2
+ test2 line2
+ "#
+ .trim()
+ );
+
+ pb1.finish_with_message("test1 done!");
+ pb2.finish_with_message("test2 done!");
+
+ assert_eq!(
+ in_mem.contents(),
+ r#" test1 done!
+ test2 done!"#
+ );
+}
+
+#[test]
+fn multi_progress_bottom_alignment() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+ mp.set_alignment(MultiProgressAlignment::Bottom);
+
+ let pb1 = mp.add(ProgressBar::new_spinner().with_message("test1"));
+ let pb2 = mp.add(ProgressBar::new_spinner().with_message("test2"));
+
+ pb1.tick();
+ pb2.tick();
+ pb1.finish_and_clear();
+
+ assert_eq!(in_mem.contents(), "\n⠁ test2");
+
+ pb2.finish_and_clear();
+ // `InMemoryTerm::contents` normally gets rid of trailing newlines, so write some text to ensure
+ // the newlines are seen.
+ in_mem.write_line("anchor").unwrap();
+ assert_eq!(in_mem.contents(), "\n\nanchor");
+}
+
+#[test]
+fn progress_bar_terminal_wrap() {
+ use std::cmp::min;
+ let in_mem = InMemoryTerm::new(10, 20);
+
+ let mut downloaded = 0;
+ let total_size = 231231231;
+
+ let pb = ProgressBar::with_draw_target(
+ None,
+ ProgressDrawTarget::term_like(Box::new(in_mem.clone())),
+ );
+ pb.set_style(ProgressStyle::default_bar()
+ .template("{msg:>12.cyan.bold} {spinner:.green} [{elapsed_precise}] [{bar:40.cyan/blue}] {bytes}/{total_bytes}").unwrap()
+ .progress_chars("#>-"));
+
+ pb.set_message("Downloading");
+ assert_eq!(
+ in_mem.contents(),
+ r#" Downloading ⠁ [00:0
+0:00] [-------------
+--------------------
+-------] 0 B/0 B"#
+ );
+
+ let new = min(downloaded + 223211, total_size);
+ downloaded = new;
+ pb.set_position(new);
+ assert_eq!(
+ in_mem.contents(),
+ r#" Downloading ⠁ [00:0
+0:00] [-------------
+--------------------
+-------] 217.98 KiB/
+217.98 KiB"#
+ );
+
+ let new = min(downloaded + 223211, total_size);
+ pb.set_position(new);
+ assert_eq!(
+ in_mem.contents(),
+ r#" Downloading ⠉ [00:0
+0:00] [-------------
+--------------------
+-------] 435.96 KiB/
+435.96 KiB"#
+ );
+
+ pb.set_style(
+ ProgressStyle::default_bar()
+ .template("{msg:>12.green.bold} downloading {total_bytes:.green} in {elapsed:.green}")
+ .unwrap(),
+ );
+ pb.finish_with_message("Finished");
+ assert_eq!(
+ in_mem.contents(),
+ r#" Finished downloa
+ding 435.96 KiB in 0
+s"#
+ );
+
+ println!("{:?}", in_mem.contents())
+}
+
+#[test]
+fn spinner_terminal_cleared_log_line_with_ansi_codes() {
+ let in_mem = InMemoryTerm::new(10, 100);
+
+ let pb = ProgressBar::with_draw_target(
+ Some(10),
+ ProgressDrawTarget::term_like(Box::new(in_mem.clone())),
+ );
+ pb.set_style(ProgressStyle::default_spinner());
+ assert_eq!(in_mem.contents(), String::new());
+
+ pb.finish_and_clear();
+ // Visually empty, but consists of an ANSII code
+ pb.println("\u{1b}[1m");
+
+ pb.println("text\u{1b}[0m");
+ assert_eq!(in_mem.contents(), "\ntext");
+}
+
+#[test]
+fn multi_progress_println_terminal_wrap() {
+ let in_mem = InMemoryTerm::new(10, 48);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let pb1 = mp.add(ProgressBar::new(10));
+ let pb2 = mp.add(ProgressBar::new(5));
+ let pb3 = mp.add(ProgressBar::new(100));
+
+ assert_eq!(in_mem.contents(), "");
+
+ pb1.inc(2);
+ mp.println("message printed that is longer than terminal width :)")
+ .unwrap();
+ assert_eq!(
+ in_mem.contents(),
+ r#"message printed that is longer than terminal wid
+th :)
+████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 2/10"#
+ );
+
+ mp.println("another great message!").unwrap();
+ assert_eq!(
+ in_mem.contents(),
+ r#"message printed that is longer than terminal wid
+th :)
+another great message!
+████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 2/10"#
+ );
+
+ pb2.inc(1);
+ pb3.tick();
+ mp.println("one last message but this one is also longer than terminal width")
+ .unwrap();
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"message printed that is longer than terminal wid
+th :)
+another great message!
+one last message but this one is also longer tha
+n terminal width
+████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 2/10
+████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 1/5
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/100"#
+ .trim()
+ );
+
+ drop(pb1);
+ drop(pb2);
+ drop(pb3);
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"message printed that is longer than terminal wid
+th :)
+another great message!
+one last message but this one is also longer tha
+n terminal width"#
+ .trim()
+ );
+}
+
+#[test]
+fn basic_progress_bar_newline() {
+ let in_mem = InMemoryTerm::new(10, 80);
+ let pb = ProgressBar::with_draw_target(
+ Some(10),
+ ProgressDrawTarget::term_like(Box::new(in_mem.clone())),
+ );
+
+ assert_eq!(in_mem.contents(), String::new());
+
+ pb.println("\nhello");
+ pb.tick();
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+hello
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10"#
+ );
+
+ pb.inc(1);
+ pb.println("");
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+hello
+
+███████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 1/10"#
+ );
+
+ pb.finish();
+ assert_eq!(
+ in_mem.contents(),
+ "
+hello
+
+██████████████████████████████████████████████████████████████████████████ 10/10"
+ );
+}
+
+#[test]
+fn multi_progress_many_bars() {
+ let in_mem = InMemoryTerm::new(4, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let pb1 = mp.add(ProgressBar::new(10).with_finish(ProgressFinish::AndLeave));
+ let mut spinners = vec![];
+ for i in 0..7 {
+ let spinner = ProgressBar::new_spinner().with_message(i.to_string());
+ mp.add(spinner.clone());
+ spinners.push(spinner);
+ }
+
+ assert_eq!(in_mem.contents(), String::new());
+
+ pb1.tick();
+ assert_eq!(
+ in_mem.contents(),
+ r#"░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10"#
+ );
+ assert_eq!(
+ in_mem.moves_since_last_check(),
+ r#"Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+Flush
+"#
+ );
+
+ for spinner in &spinners {
+ spinner.tick()
+ }
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10
+⠁ 0
+⠁ 1
+⠁ 2"#
+ .trim_start()
+ );
+ assert_eq!(
+ in_mem.moves_since_last_check(),
+ r#"Clear
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str(" ")
+Flush
+Up(1)
+Clear
+Down(1)
+Clear
+Up(1)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str("")
+NewLine
+Str("⠁ 1")
+Str(" ")
+Flush
+Up(2)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(2)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str("")
+NewLine
+Str("⠁ 1")
+Str("")
+NewLine
+Str("⠁ 2")
+Str(" ")
+Flush
+Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str("")
+NewLine
+Str("⠁ 1")
+Str("")
+NewLine
+Str("⠁ 2")
+Str("")
+Flush
+Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str("")
+NewLine
+Str("⠁ 1")
+Str("")
+NewLine
+Str("⠁ 2")
+Str("")
+Flush
+Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str("")
+NewLine
+Str("⠁ 1")
+Str("")
+NewLine
+Str("⠁ 2")
+Str("")
+Flush
+Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str("")
+NewLine
+Str("⠁ 1")
+Str("")
+NewLine
+Str("⠁ 2")
+Str("")
+Flush
+"#
+ );
+
+ drop(pb1);
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+██████████████████████████████████████████████████████████████████████████ 10/10
+⠁ 0
+⠁ 1
+⠁ 2"#
+ .trim_start()
+ );
+ assert_eq!(
+ in_mem.moves_since_last_check(),
+ r#"Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("██████████████████████████████████████████████████████████████████████████ 10/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str("")
+NewLine
+Str("⠁ 1")
+Str("")
+NewLine
+Str("⠁ 2")
+Str("")
+Flush
+"#
+ );
+
+ drop(spinners);
+
+ assert_eq!(in_mem.contents(), r#""#);
+ assert_eq!(
+ in_mem.moves_since_last_check(),
+ r#"Up(2)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(2)
+Str("⠁ 1")
+Str("")
+NewLine
+Str("⠁ 2")
+Str("")
+NewLine
+Str("⠁ 3")
+Str("")
+NewLine
+Str("⠁ 4")
+Str("")
+Flush
+Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("⠁ 2")
+Str("")
+NewLine
+Str("⠁ 3")
+Str("")
+NewLine
+Str("⠁ 4")
+Str("")
+NewLine
+Str("⠁ 5")
+Str("")
+Flush
+Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("⠁ 3")
+Str("")
+NewLine
+Str("⠁ 4")
+Str("")
+NewLine
+Str("⠁ 5")
+Str("")
+NewLine
+Str("⠁ 6")
+Str(" ")
+Flush
+Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("⠁ 4")
+Str("")
+NewLine
+Str("⠁ 5")
+Str("")
+NewLine
+Str("⠁ 6")
+Str(" ")
+Flush
+Up(2)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(2)
+Str("⠁ 5")
+Str("")
+NewLine
+Str("⠁ 6")
+Str(" ")
+Flush
+Up(1)
+Clear
+Down(1)
+Clear
+Up(1)
+Str("⠁ 6")
+Str(" ")
+Flush
+Clear
+Str("")
+Flush
+"#
+ );
+}
+
+#[test]
+fn multi_progress_many_spinners() {
+ let in_mem = InMemoryTerm::new(4, 80);
+ let mp =
+ MultiProgress::with_draw_target(ProgressDrawTarget::term_like(Box::new(in_mem.clone())));
+
+ let pb1 = mp.add(ProgressBar::new(10).with_finish(ProgressFinish::AndLeave));
+ let mut spinners = vec![];
+ for i in 0..7 {
+ let spinner = ProgressBar::new_spinner().with_message(i.to_string());
+ mp.add(spinner.clone());
+ spinners.push(spinner);
+ }
+
+ assert_eq!(in_mem.contents(), String::new());
+
+ pb1.tick();
+ assert_eq!(
+ in_mem.contents(),
+ r#"░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10"#
+ );
+ assert_eq!(
+ in_mem.moves_since_last_check(),
+ r#"Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+Flush
+"#
+ );
+
+ for spinner in &spinners {
+ spinner.tick()
+ }
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10
+⠁ 0
+⠁ 1
+⠁ 2"#
+ .trim_start()
+ );
+
+ assert_eq!(
+ in_mem.moves_since_last_check(),
+ r#"Clear
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str(" ")
+Flush
+Up(1)
+Clear
+Down(1)
+Clear
+Up(1)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str("")
+NewLine
+Str("⠁ 1")
+Str(" ")
+Flush
+Up(2)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(2)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str("")
+NewLine
+Str("⠁ 1")
+Str("")
+NewLine
+Str("⠁ 2")
+Str(" ")
+Flush
+Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str("")
+NewLine
+Str("⠁ 1")
+Str("")
+NewLine
+Str("⠁ 2")
+Str("")
+Flush
+Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str("")
+NewLine
+Str("⠁ 1")
+Str("")
+NewLine
+Str("⠁ 2")
+Str("")
+Flush
+Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str("")
+NewLine
+Str("⠁ 1")
+Str("")
+NewLine
+Str("⠁ 2")
+Str("")
+Flush
+Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str("")
+NewLine
+Str("⠁ 1")
+Str("")
+NewLine
+Str("⠁ 2")
+Str("")
+Flush
+"#
+ );
+
+ spinners.remove(3);
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10
+⠁ 0
+⠁ 1
+⠁ 2"#
+ .trim_start()
+ );
+
+ assert_eq!(
+ in_mem.moves_since_last_check(),
+ r#"Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str("")
+NewLine
+Str("⠁ 1")
+Str("")
+NewLine
+Str("⠁ 2")
+Str("")
+Flush
+"#
+ );
+
+ spinners.remove(4);
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"
+░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10
+⠁ 0
+⠁ 1
+⠁ 2"#
+ .trim_start()
+ );
+ assert_eq!(
+ in_mem.moves_since_last_check(),
+ r#"Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 0")
+Str("")
+NewLine
+Str("⠁ 1")
+Str("")
+NewLine
+Str("⠁ 2")
+Str("")
+Flush
+"#
+ );
+
+ drop(spinners);
+
+ assert_eq!(
+ in_mem.contents(),
+ r#"░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10"#
+ );
+ assert_eq!(
+ in_mem.moves_since_last_check(),
+ r#"Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 1")
+Str("")
+NewLine
+Str("⠁ 2")
+Str("")
+NewLine
+Str("⠁ 4")
+Str("")
+Flush
+Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 2")
+Str("")
+NewLine
+Str("⠁ 4")
+Str("")
+NewLine
+Str("⠁ 6")
+Str(" ")
+Flush
+Up(3)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(3)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 4")
+Str("")
+NewLine
+Str("⠁ 6")
+Str(" ")
+Flush
+Up(2)
+Clear
+Down(1)
+Clear
+Down(1)
+Clear
+Up(2)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+NewLine
+Str("⠁ 6")
+Str(" ")
+Flush
+Up(1)
+Clear
+Down(1)
+Clear
+Up(1)
+Str("░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 0/10")
+Str("")
+Flush
+"#
+ );
+}
+
+#[test]
+fn orphan_lines() {
+ let in_mem = InMemoryTerm::new(10, 80);
+
+ let pb = ProgressBar::with_draw_target(
+ Some(10),
+ ProgressDrawTarget::term_like(Box::new(in_mem.clone())),
+ );
+ assert_eq!(in_mem.contents(), String::new());
+
+ for i in 0..=10 {
+ if i != 0 {
+ pb.inc(1);
+ }
+
+ let n = 5 + i;
+
+ pb.println("\n".repeat(n));
+ }
+
+ pb.finish();
+}
+
+#[test]
+fn orphan_lines_message_above_progress_bar() {
+ let in_mem = InMemoryTerm::new(10, 80);
+
+ let pb = ProgressBar::with_draw_target(
+ Some(10),
+ ProgressDrawTarget::term_like(Box::new(in_mem.clone())),
+ );
+ assert_eq!(in_mem.contents(), String::new());
+
+ for i in 0..=10 {
+ if i != 0 {
+ pb.inc(1);
+ }
+
+ let n = 5 + i;
+
+ // Test with messages of differing numbers of lines. The messages have the form:
+ // n - 1 newlines followed by n * 11 dashes (`-`). The value of n ranges from 5
+ // (less than the terminal height) to 15 (greater than the terminal height). The
+ // number 11 is intentionally not a factor of the terminal width (80), but large
+ // enough that the strings of dashes eventually wrap.
+ pb.println(format!("{}{}", "\n".repeat(n - 1), "-".repeat(n * 11)));
+
+ // Check that the line above the progress bar is a string of dashes of length
+ // n * 11 mod the terminal width.
+ assert_eq!(
+ format!("{}", "-".repeat(n * 11 % 80)),
+ in_mem.contents().lines().rev().nth(1).unwrap(),
+ );
+ }
+
+ pb.finish();
+}
Copyright © 2024 Valentin A. Popov. All Rights Reverse Engineered.