use std::time::Duration;
use limiteron::retry::delay_for_attempt;
#[must_use]
pub fn backoff_delay(attempt: u32, base_ms: u64, max_ms: u64) -> Duration {
if base_ms == 0 {
return Duration::ZERO;
}
if attempt == 0 {
return delay_for_attempt(
1,
Duration::from_millis(base_ms),
2.0,
Duration::from_millis(max_ms),
1.0,
);
}
delay_for_attempt(
attempt,
Duration::from_millis(base_ms),
2.0,
Duration::from_millis(max_ms),
1.0,
)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn delay_capped_at_max() {
let base_ms = 100u64;
let max_ms = 10_000u64;
for attempt in 0u32..6 {
for _ in 0..1000 {
let d = backoff_delay(attempt, base_ms, max_ms);
assert!(
d.as_millis() as u64 <= max_ms,
"attempt={}: delay {:?} exceeds max_ms {}",
attempt,
d,
max_ms
);
}
}
}
#[test]
fn higher_attempt_higher_mean() {
let base_ms = 100u64;
let max_ms = 10_000u64;
let mean_low = sample_mean(0, base_ms, max_ms, 1000);
let mean_high = sample_mean(5, base_ms, max_ms, 1000);
assert!(
mean_high > mean_low,
"expected higher attempt to have larger mean: high={}, low={}",
mean_high,
mean_low
);
}
#[test]
fn max_ms_caps_delay() {
let base_ms = 1_000u64;
let max_ms = 500u64;
for _ in 0..1000 {
let d = backoff_delay(3, base_ms, max_ms);
assert!(
d.as_millis() as u64 <= max_ms,
"delay {:?} exceeds max_ms {}",
d,
max_ms
);
}
}
#[test]
fn overflow_safe() {
let d = backoff_delay(100, 100, 60_000);
assert!(
d.as_millis() as u64 <= 60_000,
"overflow case: delay must be capped at max_ms"
);
}
#[test]
fn zero_base_returns_zero() {
let d = backoff_delay(5, 0, 1000);
assert_eq!(d, Duration::ZERO);
}
fn sample_mean(attempt: u32, base_ms: u64, max_ms: u64, n: usize) -> f64 {
let mut sum = 0u64;
for _ in 0..n {
sum += backoff_delay(attempt, base_ms, max_ms).as_millis() as u64;
}
sum as f64 / n as f64
}
}