diff options
Diffstat (limited to 'vendor/indicatif/src/state.rs')
| -rw-r--r-- | vendor/indicatif/src/state.rs | 798 |
1 files changed, 0 insertions, 798 deletions
diff --git a/vendor/indicatif/src/state.rs b/vendor/indicatif/src/state.rs deleted file mode 100644 index 3bcdc44..0000000 --- a/vendor/indicatif/src/state.rs +++ /dev/null @@ -1,798 +0,0 @@ -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); - } -} |