Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

1 files changed, 798 insertions, 0 deletions

diff --git a/vendor/indicatif/src/state.rs b/vendor/indicatif/src/state.rs
new file mode 100644
index 0000000..3bcdc44
--- /dev/null
+++ b/vendor/indicatif/src/state.rs
@@ -0,0 +1,798 @@
+use std::borrow::Cow;
+use std::io;
+use std::sync::Arc;
+use std::time::Duration;
+#[cfg(not(target_arch = "wasm32"))]
+use std::time::Instant;
+
+#[cfg(target_arch = "wasm32")]
+use instant::Instant;
+use portable_atomic::{AtomicU64, AtomicU8, Ordering};
+
+use crate::draw_target::ProgressDrawTarget;
+use crate::style::ProgressStyle;
+
+pub(crate) struct BarState {
+    pub(crate) draw_target: ProgressDrawTarget,
+    pub(crate) on_finish: ProgressFinish,
+    pub(crate) style: ProgressStyle,
+    pub(crate) state: ProgressState,
+    pub(crate) tab_width: usize,
+}
+
+impl BarState {
+    pub(crate) fn new(
+        len: Option<u64>,
+        draw_target: ProgressDrawTarget,
+        pos: Arc<AtomicPosition>,
+    ) -> Self {
+        Self {
+            draw_target,
+            on_finish: ProgressFinish::default(),
+            style: ProgressStyle::default_bar(),
+            state: ProgressState::new(len, pos),
+            tab_width: DEFAULT_TAB_WIDTH,
+        }
+    }
+
+    /// Finishes the progress bar using the [`ProgressFinish`] behavior stored
+    /// in the [`ProgressStyle`].
+    pub(crate) fn finish_using_style(&mut self, now: Instant, finish: ProgressFinish) {
+        self.state.status = Status::DoneVisible;
+        match finish {
+            ProgressFinish::AndLeave => {
+                if let Some(len) = self.state.len {
+                    self.state.pos.set(len);
+                }
+            }
+            ProgressFinish::WithMessage(msg) => {
+                if let Some(len) = self.state.len {
+                    self.state.pos.set(len);
+                }
+                self.state.message = TabExpandedString::new(msg, self.tab_width);
+            }
+            ProgressFinish::AndClear => {
+                if let Some(len) = self.state.len {
+                    self.state.pos.set(len);
+                }
+                self.state.status = Status::DoneHidden;
+            }
+            ProgressFinish::Abandon => {}
+            ProgressFinish::AbandonWithMessage(msg) => {
+                self.state.message = TabExpandedString::new(msg, self.tab_width);
+            }
+        }
+
+        // There's no need to update the estimate here; once the `status` is no longer
+        // `InProgress`, we will use the length and elapsed time to estimate.
+        let _ = self.draw(true, now);
+    }
+
+    pub(crate) fn reset(&mut self, now: Instant, mode: Reset) {
+        // Always reset the estimator; this is the only reset that will occur if mode is
+        // `Reset::Eta`.
+        self.state.est.reset(now);
+
+        if let Reset::Elapsed | Reset::All = mode {
+            self.state.started = now;
+        }
+
+        if let Reset::All = mode {
+            self.state.pos.reset(now);
+            self.state.status = Status::InProgress;
+
+            for tracker in self.style.format_map.values_mut() {
+                tracker.reset(&self.state, now);
+            }
+
+            let _ = self.draw(false, now);
+        }
+    }
+
+    pub(crate) fn update(&mut self, now: Instant, f: impl FnOnce(&mut ProgressState), tick: bool) {
+        f(&mut self.state);
+        if tick {
+            self.tick(now);
+        }
+    }
+
+    pub(crate) fn set_length(&mut self, now: Instant, len: u64) {
+        self.state.len = Some(len);
+        self.update_estimate_and_draw(now);
+    }
+
+    pub(crate) fn inc_length(&mut self, now: Instant, delta: u64) {
+        if let Some(len) = self.state.len {
+            self.state.len = Some(len.saturating_add(delta));
+        }
+        self.update_estimate_and_draw(now);
+    }
+
+    pub(crate) fn set_tab_width(&mut self, tab_width: usize) {
+        self.tab_width = tab_width;
+        self.state.message.set_tab_width(tab_width);
+        self.state.prefix.set_tab_width(tab_width);
+        self.style.set_tab_width(tab_width);
+    }
+
+    pub(crate) fn set_style(&mut self, style: ProgressStyle) {
+        self.style = style;
+        self.style.set_tab_width(self.tab_width);
+    }
+
+    pub(crate) fn tick(&mut self, now: Instant) {
+        self.state.tick = self.state.tick.saturating_add(1);
+        self.update_estimate_and_draw(now);
+    }
+
+    pub(crate) fn update_estimate_and_draw(&mut self, now: Instant) {
+        let pos = self.state.pos.pos.load(Ordering::Relaxed);
+        self.state.est.record(pos, now);
+
+        for tracker in self.style.format_map.values_mut() {
+            tracker.tick(&self.state, now);
+        }
+
+        let _ = self.draw(false, now);
+    }
+
+    pub(crate) fn println(&mut self, now: Instant, msg: &str) {
+        let width = self.draw_target.width();
+        let mut drawable = match self.draw_target.drawable(true, now) {
+            Some(drawable) => drawable,
+            None => return,
+        };
+
+        let mut draw_state = drawable.state();
+        let lines: Vec<String> = msg.lines().map(Into::into).collect();
+        // Empty msg should trigger newline as we are in println
+        if lines.is_empty() {
+            draw_state.lines.push(String::new());
+        } else {
+            draw_state.lines.extend(lines);
+        }
+        draw_state.orphan_lines_count = draw_state.lines.len();
+        if !matches!(self.state.status, Status::DoneHidden) {
+            self.style
+                .format_state(&self.state, &mut draw_state.lines, width);
+        }
+
+        drop(draw_state);
+        let _ = drawable.draw();
+    }
+
+    pub(crate) fn suspend<F: FnOnce() -> R, R>(&mut self, now: Instant, f: F) -> R {
+        if let Some((state, _)) = self.draw_target.remote() {
+            return state.write().unwrap().suspend(f, now);
+        }
+
+        if let Some(drawable) = self.draw_target.drawable(true, now) {
+            let _ = drawable.clear();
+        }
+
+        let ret = f();
+        let _ = self.draw(true, Instant::now());
+        ret
+    }
+
+    pub(crate) fn draw(&mut self, mut force_draw: bool, now: Instant) -> io::Result<()> {
+        let width = self.draw_target.width();
+
+        // `|= self.is_finished()` should not be needed here, but we used to always draw for
+        // finished progress bars, so it's kept as to not cause compatibility issues in weird cases.
+        force_draw |= self.state.is_finished();
+        let mut drawable = match self.draw_target.drawable(force_draw, now) {
+            Some(drawable) => drawable,
+            None => return Ok(()),
+        };
+
+        let mut draw_state = drawable.state();
+
+        if !matches!(self.state.status, Status::DoneHidden) {
+            self.style
+                .format_state(&self.state, &mut draw_state.lines, width);
+        }
+
+        drop(draw_state);
+        drawable.draw()
+    }
+}
+
+impl Drop for BarState {
+    fn drop(&mut self) {
+        // Progress bar is already finished.  Do not need to do anything other than notify
+        // the `MultiProgress` that we're now a zombie.
+        if self.state.is_finished() {
+            self.draw_target.mark_zombie();
+            return;
+        }
+
+        self.finish_using_style(Instant::now(), self.on_finish.clone());
+
+        // Notify the `MultiProgress` that we're now a zombie.
+        self.draw_target.mark_zombie();
+    }
+}
+
+pub(crate) enum Reset {
+    Eta,
+    Elapsed,
+    All,
+}
+
+/// The state of a progress bar at a moment in time.
+#[non_exhaustive]
+pub struct ProgressState {
+    pos: Arc<AtomicPosition>,
+    len: Option<u64>,
+    pub(crate) tick: u64,
+    pub(crate) started: Instant,
+    status: Status,
+    est: Estimator,
+    pub(crate) message: TabExpandedString,
+    pub(crate) prefix: TabExpandedString,
+}
+
+impl ProgressState {
+    pub(crate) fn new(len: Option<u64>, pos: Arc<AtomicPosition>) -> Self {
+        let now = Instant::now();
+        Self {
+            pos,
+            len,
+            tick: 0,
+            status: Status::InProgress,
+            started: now,
+            est: Estimator::new(now),
+            message: TabExpandedString::NoTabs("".into()),
+            prefix: TabExpandedString::NoTabs("".into()),
+        }
+    }
+
+    /// Indicates that the progress bar finished.
+    pub fn is_finished(&self) -> bool {
+        match self.status {
+            Status::InProgress => false,
+            Status::DoneVisible => true,
+            Status::DoneHidden => true,
+        }
+    }
+
+    /// Returns the completion as a floating-point number between 0 and 1
+    pub fn fraction(&self) -> f32 {
+        let pos = self.pos.pos.load(Ordering::Relaxed);
+        let pct = match (pos, self.len) {
+            (_, None) => 0.0,
+            (_, Some(0)) => 1.0,
+            (0, _) => 0.0,
+            (pos, Some(len)) => pos as f32 / len as f32,
+        };
+        pct.clamp(0.0, 1.0)
+    }
+
+    /// The expected ETA
+    pub fn eta(&self) -> Duration {
+        if self.is_finished() {
+            return Duration::new(0, 0);
+        }
+
+        let len = match self.len {
+            Some(len) => len,
+            None => return Duration::new(0, 0),
+        };
+
+        let pos = self.pos.pos.load(Ordering::Relaxed);
+
+        let sps = self.est.steps_per_second(Instant::now());
+
+        // Infinite duration should only ever happen at the beginning, so in this case it's okay to
+        // just show an ETA of 0 until progress starts to occur.
+        if sps == 0.0 {
+            return Duration::new(0, 0);
+        }
+
+        secs_to_duration(len.saturating_sub(pos) as f64 / sps)
+    }
+
+    /// The expected total duration (that is, elapsed time + expected ETA)
+    pub fn duration(&self) -> Duration {
+        if self.len.is_none() || self.is_finished() {
+            return Duration::new(0, 0);
+        }
+        self.started.elapsed().saturating_add(self.eta())
+    }
+
+    /// The number of steps per second
+    pub fn per_sec(&self) -> f64 {
+        if let Status::InProgress = self.status {
+            self.est.steps_per_second(Instant::now())
+        } else {
+            let len = self.len.unwrap_or_else(|| self.pos());
+            len as f64 / self.started.elapsed().as_secs_f64()
+        }
+    }
+
+    pub fn elapsed(&self) -> Duration {
+        self.started.elapsed()
+    }
+
+    pub fn pos(&self) -> u64 {
+        self.pos.pos.load(Ordering::Relaxed)
+    }
+
+    pub fn set_pos(&mut self, pos: u64) {
+        self.pos.set(pos);
+    }
+
+    #[allow(clippy::len_without_is_empty)]
+    pub fn len(&self) -> Option<u64> {
+        self.len
+    }
+
+    pub fn set_len(&mut self, len: u64) {
+        self.len = Some(len);
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub(crate) enum TabExpandedString {
+    NoTabs(Cow<'static, str>),
+    WithTabs {
+        original: Cow<'static, str>,
+        expanded: String,
+        tab_width: usize,
+    },
+}
+
+impl TabExpandedString {
+    pub(crate) fn new(s: Cow<'static, str>, tab_width: usize) -> Self {
+        let expanded = s.replace('\t', &" ".repeat(tab_width));
+        if s == expanded {
+            Self::NoTabs(s)
+        } else {
+            Self::WithTabs {
+                original: s,
+                expanded,
+                tab_width,
+            }
+        }
+    }
+
+    pub(crate) fn expanded(&self) -> &str {
+        match &self {
+            Self::NoTabs(s) => {
+                debug_assert!(!s.contains('\t'));
+                s
+            }
+            Self::WithTabs { expanded, .. } => expanded,
+        }
+    }
+
+    pub(crate) fn set_tab_width(&mut self, new_tab_width: usize) {
+        if let Self::WithTabs {
+            original,
+            expanded,
+            tab_width,
+        } = self
+        {
+            if *tab_width != new_tab_width {
+                *tab_width = new_tab_width;
+                *expanded = original.replace('\t', &" ".repeat(new_tab_width));
+            }
+        }
+    }
+}
+
+/// Double-smoothed exponentially weighted estimator
+///
+/// This uses an exponentially weighted *time-based* estimator, meaning that it exponentially
+/// downweights old data based on its age. The rate at which this occurs is currently a constant
+/// value of 15 seconds for 90% weighting. This means that all data older than 15 seconds has a
+/// collective weight of 0.1 in the estimate, and all data older than 30 seconds has a collective
+/// weight of 0.01, and so on.
+///
+/// The primary value exposed by `Estimator` is `steps_per_second`. This value is doubly-smoothed,
+/// meaning that is the result of using an exponentially weighted estimator (as described above) to
+/// estimate the value of another exponentially weighted estimator, which estimates the value of
+/// the raw data.
+///
+/// The purpose of this extra smoothing step is to reduce instantaneous fluctations in the estimate
+/// when large updates are received. Without this, estimates might have a large spike followed by a
+/// slow asymptotic approach to zero (until the next spike).
+#[derive(Debug)]
+pub(crate) struct Estimator {
+    smoothed_steps_per_sec: f64,
+    double_smoothed_steps_per_sec: f64,
+    prev_steps: u64,
+    prev_time: Instant,
+    start_time: Instant,
+}
+
+impl Estimator {
+    fn new(now: Instant) -> Self {
+        Self {
+            smoothed_steps_per_sec: 0.0,
+            double_smoothed_steps_per_sec: 0.0,
+            prev_steps: 0,
+            prev_time: now,
+            start_time: now,
+        }
+    }
+
+    fn record(&mut self, new_steps: u64, now: Instant) {
+        // sanity check: don't record data if time or steps have not advanced
+        if new_steps <= self.prev_steps || now <= self.prev_time {
+            // Reset on backwards seek to prevent breakage from seeking to the end for length determination
+            // See https://github.com/console-rs/indicatif/issues/480
+            if new_steps < self.prev_steps {
+                self.prev_steps = new_steps;
+                self.reset(now);
+            }
+            return;
+        }
+
+        let delta_steps = new_steps - self.prev_steps;
+        let delta_t = duration_to_secs(now - self.prev_time);
+
+        // the rate of steps we saw in this update
+        let new_steps_per_second = delta_steps as f64 / delta_t;
+
+        // update the estimate: a weighted average of the old estimate and new data
+        let weight = estimator_weight(delta_t);
+        self.smoothed_steps_per_sec =
+            self.smoothed_steps_per_sec * weight + new_steps_per_second * (1.0 - weight);
+
+        // An iterative estimate like `smoothed_steps_per_sec` is supposed to be an exponentially
+        // weighted average from t=0 back to t=-inf; Since we initialize it to 0, we neglect the
+        // (non-existent) samples in the weighted average prior to the first one, so the resulting
+        // average must be normalized. We normalize the single estimate here in order to use it as
+        // a source for the double smoothed estimate. See comment on normalization in
+        // `steps_per_second` for details.
+        let delta_t_start = duration_to_secs(now - self.start_time);
+        let total_weight = 1.0 - estimator_weight(delta_t_start);
+        let normalized_smoothed_steps_per_sec = self.smoothed_steps_per_sec / total_weight;
+
+        // determine the double smoothed value (EWA smoothing of the single EWA)
+        self.double_smoothed_steps_per_sec = self.double_smoothed_steps_per_sec * weight
+            + normalized_smoothed_steps_per_sec * (1.0 - weight);
+
+        self.prev_steps = new_steps;
+        self.prev_time = now;
+    }
+
+    /// Reset the state of the estimator. Once reset, estimates will not depend on any data prior
+    /// to `now`. This does not reset the stored position of the progress bar.
+    pub(crate) fn reset(&mut self, now: Instant) {
+        self.smoothed_steps_per_sec = 0.0;
+        self.double_smoothed_steps_per_sec = 0.0;
+
+        // only reset prev_time, not prev_steps
+        self.prev_time = now;
+        self.start_time = now;
+    }
+
+    /// Average time per step in seconds, using double exponential smoothing
+    fn steps_per_second(&self, now: Instant) -> f64 {
+        // Because the value stored in the Estimator is only updated when the Estimator receives an
+        // update, this value will become stuck if progress stalls. To return an accurate estimate,
+        // we determine how much time has passed since the last update, and treat this as a
+        // pseudo-update with 0 steps.
+        let delta_t = duration_to_secs(now - self.prev_time);
+        let reweight = estimator_weight(delta_t);
+
+        // Normalization of estimates:
+        //
+        // The raw estimate is a single value (smoothed_steps_per_second) that is iteratively
+        // updated. At each update, the previous value of the estimate is downweighted according to
+        // its age, receiving the iterative weight W(t) = 0.1 ^ (t/15).
+        //
+        // Since W(Sum(t_n)) = Prod(W(t_n)), the total weight of a sample after a series of
+        // iterative steps is simply W(t_e) - W(t_b), where t_e is the time since the end of the
+        // sample, and t_b is the time since the beginning. The resulting estimate is therefore a
+        // weighted average with sample weights W(t_e) - W(t_b).
+        //
+        // Notice that the weighting function generates sample weights that sum to 1 only when the
+        // sample times span from t=0 to t=inf; but this is not the case. We have a first sample
+        // with finite, positive t_b = t_f. In the raw estimate, we handle times prior to t_f by
+        // setting an initial value of 0, meaning that these (non-existent) samples have no weight.
+        //
+        // Therefore, the raw estimate must be normalized by dividing it by the sum of the weights
+        // in the weighted average. This sum is just W(0) - W(t_f), where t_f is the time since the
+        // first sample, and W(0) = 1.
+        let delta_t_start = duration_to_secs(now - self.start_time);
+        let total_weight = 1.0 - estimator_weight(delta_t_start);
+
+        // Generate updated values for `smoothed_steps_per_sec` and `double_smoothed_steps_per_sec`
+        // (sps and dsps) without storing them. Note that we normalize sps when using it as a
+        // source to update dsps, and then normalize dsps itself before returning it.
+        let sps = self.smoothed_steps_per_sec * reweight / total_weight;
+        let dsps = self.double_smoothed_steps_per_sec * reweight + sps * (1.0 - reweight);
+        dsps / total_weight
+    }
+}
+
+pub(crate) struct AtomicPosition {
+    pub(crate) pos: AtomicU64,
+    capacity: AtomicU8,
+    prev: AtomicU64,
+    start: Instant,
+}
+
+impl AtomicPosition {
+    pub(crate) fn new() -> Self {
+        Self {
+            pos: AtomicU64::new(0),
+            capacity: AtomicU8::new(MAX_BURST),
+            prev: AtomicU64::new(0),
+            start: Instant::now(),
+        }
+    }
+
+    pub(crate) fn allow(&self, now: Instant) -> bool {
+        if now < self.start {
+            return false;
+        }
+
+        let mut capacity = self.capacity.load(Ordering::Acquire);
+        // `prev` is the number of ms after `self.started` we last returned `true`, in ns
+        let prev = self.prev.load(Ordering::Acquire);
+        // `elapsed` is the number of ns since `self.started`
+        let elapsed = (now - self.start).as_nanos() as u64;
+        // `diff` is the number of ns since we last returned `true`
+        let diff = elapsed.saturating_sub(prev);
+
+        // If `capacity` is 0 and not enough time (1ms) has passed since `prev`
+        // to add new capacity, return `false`. The goal of this method is to
+        // make this decision as efficient as possible.
+        if capacity == 0 && diff < INTERVAL {
+            return false;
+        }
+
+        // We now calculate `new`, the number of ms, in ns, since we last returned `true`,
+        // and `remainder`, which represents a number of ns less than 1ms which we cannot
+        // convert into capacity now, so we're saving it for later. We do this by
+        // substracting this from `elapsed` before storing it into `self.prev`.
+        let (new, remainder) = ((diff / INTERVAL), (diff % INTERVAL));
+        // We add `new` to `capacity`, subtract one for returning `true` from here,
+        // then make sure it does not exceed a maximum of `MAX_BURST`.
+        capacity = Ord::min(MAX_BURST as u128, (capacity as u128) + (new as u128) - 1) as u8;
+
+        // Then, we just store `capacity` and `prev` atomically for the next iteration
+        self.capacity.store(capacity, Ordering::Release);
+        self.prev.store(elapsed - remainder, Ordering::Release);
+        true
+    }
+
+    fn reset(&self, now: Instant) {
+        self.set(0);
+        let elapsed = (now.saturating_duration_since(self.start)).as_millis() as u64;
+        self.prev.store(elapsed, Ordering::Release);
+    }
+
+    pub(crate) fn inc(&self, delta: u64) {
+        self.pos.fetch_add(delta, Ordering::SeqCst);
+    }
+
+    pub(crate) fn set(&self, pos: u64) {
+        self.pos.store(pos, Ordering::Release);
+    }
+}
+
+const INTERVAL: u64 = 1_000_000;
+const MAX_BURST: u8 = 10;
+
+/// Behavior of a progress bar when it is finished
+///
+/// This is invoked when a [`ProgressBar`] or [`ProgressBarIter`] completes and
+/// [`ProgressBar::is_finished`] is false.
+///
+/// [`ProgressBar`]: crate::ProgressBar
+/// [`ProgressBarIter`]: crate::ProgressBarIter
+/// [`ProgressBar::is_finished`]: crate::ProgressBar::is_finished
+#[derive(Clone, Debug)]
+pub enum ProgressFinish {
+    /// Finishes the progress bar and leaves the current message
+    ///
+    /// Same behavior as calling [`ProgressBar::finish()`](crate::ProgressBar::finish).
+    AndLeave,
+    /// Finishes the progress bar and sets a message
+    ///
+    /// Same behavior as calling [`ProgressBar::finish_with_message()`](crate::ProgressBar::finish_with_message).
+    WithMessage(Cow<'static, str>),
+    /// Finishes the progress bar and completely clears it (this is the default)
+    ///
+    /// Same behavior as calling [`ProgressBar::finish_and_clear()`](crate::ProgressBar::finish_and_clear).
+    AndClear,
+    /// Finishes the progress bar and leaves the current message and progress
+    ///
+    /// Same behavior as calling [`ProgressBar::abandon()`](crate::ProgressBar::abandon).
+    Abandon,
+    /// Finishes the progress bar and sets a message, and leaves the current progress
+    ///
+    /// Same behavior as calling [`ProgressBar::abandon_with_message()`](crate::ProgressBar::abandon_with_message).
+    AbandonWithMessage(Cow<'static, str>),
+}
+
+impl Default for ProgressFinish {
+    fn default() -> Self {
+        Self::AndClear
+    }
+}
+
+/// Get the appropriate dilution weight for Estimator data given the data's age (in seconds)
+///
+/// Whenever an update occurs, we will create a new estimate using a weight `w_i` like so:
+///
+/// ```math
+/// <new estimate> = <previous estimate> * w_i + <new data> * (1 - w_i)
+/// ```
+///
+/// In other words, the new estimate is a weighted average of the previous estimate and the new
+/// data. We want to choose weights such that for any set of samples where `t_0, t_1, ...` are
+/// the durations of the samples:
+///
+/// ```math
+/// Sum(t_i) = ews ==> Prod(w_i) = 0.1
+/// ```
+///
+/// With this constraint it is easy to show that
+///
+/// ```math
+/// w_i = 0.1 ^ (t_i / ews)
+/// ```
+///
+/// Notice that the constraint implies that estimates are independent of the durations of the
+/// samples, a very useful feature.
+fn estimator_weight(age: f64) -> f64 {
+    const EXPONENTIAL_WEIGHTING_SECONDS: f64 = 15.0;
+    0.1_f64.powf(age / EXPONENTIAL_WEIGHTING_SECONDS)
+}
+
+fn duration_to_secs(d: Duration) -> f64 {
+    d.as_secs() as f64 + f64::from(d.subsec_nanos()) / 1_000_000_000f64
+}
+
+fn secs_to_duration(s: f64) -> Duration {
+    let secs = s.trunc() as u64;
+    let nanos = (s.fract() * 1_000_000_000f64) as u32;
+    Duration::new(secs, nanos)
+}
+
+#[derive(Debug)]
+pub(crate) enum Status {
+    InProgress,
+    DoneVisible,
+    DoneHidden,
+}
+
+pub(crate) const DEFAULT_TAB_WIDTH: usize = 8;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ProgressBar;
+
+    // https://github.com/rust-lang/rust-clippy/issues/10281
+    #[allow(clippy::uninlined_format_args)]
+    #[test]
+    fn test_steps_per_second() {
+        let test_rate = |items_per_second| {
+            let mut now = Instant::now();
+            let mut est = Estimator::new(now);
+            let mut pos = 0;
+
+            for _ in 0..20 {
+                pos += items_per_second;
+                now += Duration::from_secs(1);
+                est.record(pos, now);
+            }
+            let avg_steps_per_second = est.steps_per_second(now);
+
+            assert!(avg_steps_per_second > 0.0);
+            assert!(avg_steps_per_second.is_finite());
+
+            let absolute_error = (avg_steps_per_second - items_per_second as f64).abs();
+            let relative_error = absolute_error / items_per_second as f64;
+            assert!(
+                relative_error < 1.0 / 1e9,
+                "Expected rate: {}, actual: {}, relative error: {}",
+                items_per_second,
+                avg_steps_per_second,
+                relative_error
+            );
+        };
+
+        test_rate(1);
+        test_rate(1_000);
+        test_rate(1_000_000);
+        test_rate(1_000_000_000);
+        test_rate(1_000_000_001);
+        test_rate(100_000_000_000);
+        test_rate(1_000_000_000_000);
+        test_rate(100_000_000_000_000);
+        test_rate(1_000_000_000_000_000);
+    }
+
+    #[test]
+    fn test_double_exponential_ave() {
+        let mut now = Instant::now();
+        let mut est = Estimator::new(now);
+        let mut pos = 0;
+
+        // note: this is the default weight set in the Estimator
+        let weight = 15;
+
+        for _ in 0..weight {
+            pos += 1;
+            now += Duration::from_secs(1);
+            est.record(pos, now);
+        }
+        now += Duration::from_secs(weight);
+
+        // The first level EWA:
+        //   -> 90% weight @ 0 eps, 9% weight @ 1 eps, 1% weight @ 0 eps
+        //   -> then normalized by deweighting the 1% weight (before -30 seconds)
+        let single_target = 0.09 / 0.99;
+
+        // The second level EWA:
+        //   -> same logic as above, but using the first level EWA as the source
+        let double_target = (0.9 * single_target + 0.09) / 0.99;
+        assert_eq!(est.steps_per_second(now), double_target);
+    }
+
+    #[test]
+    fn test_estimator_rewind_position() {
+        let mut now = Instant::now();
+        let mut est = Estimator::new(now);
+
+        now += Duration::from_secs(1);
+        est.record(1, now);
+
+        // should not panic
+        now += Duration::from_secs(1);
+        est.record(0, now);
+
+        // check that reset occurred (estimator at 1 event per sec)
+        now += Duration::from_secs(1);
+        est.record(1, now);
+        assert_eq!(est.steps_per_second(now), 1.0);
+
+        // check that progress bar handles manual seeking
+        let pb = ProgressBar::hidden();
+        pb.set_length(10);
+        pb.set_position(1);
+        pb.tick();
+        // Should not panic.
+        pb.set_position(0);
+    }
+
+    #[test]
+    fn test_reset_eta() {
+        let mut now = Instant::now();
+        let mut est = Estimator::new(now);
+
+        // two per second, then reset
+        now += Duration::from_secs(1);
+        est.record(2, now);
+        est.reset(now);
+
+        // now one per second, and verify
+        now += Duration::from_secs(1);
+        est.record(3, now);
+        assert_eq!(est.steps_per_second(now), 1.0);
+    }
+
+    #[test]
+    fn test_duration_stuff() {
+        let duration = Duration::new(42, 100_000_000);
+        let secs = duration_to_secs(duration);
+        assert_eq!(secs_to_duration(secs), duration);
+    }
+
+    #[test]
+    fn test_atomic_position_large_time_difference() {
+        let atomic_position = AtomicPosition::new();
+        let later = atomic_position.start + Duration::from_nanos(INTERVAL * u64::from(u8::MAX));
+        // Should not panic.
+        atomic_position.allow(later);
+    }
+}