chrono_machines 0.2.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8617cc9e32d231563c1f075a8446728ff851ec0ec6c755aa00e807de5adde85d
-  data.tar.gz: de5c482f0bb089ce720f5cd3f3019a88fa6b149e83061b729d4d6287161601a3
+  metadata.gz: 3186aa3d77c3687efa8dcf51f9612c15997f9f5bdd51cf801a87d0a7ea7d28e6
+  data.tar.gz: ec4ea0d3b9c8c27828317617ca89e6404587958ba55105e44c57ecdb599d69f6
 SHA512:
-  metadata.gz: 482988d7dd362bb4159af9e9651312b84c3a4e2633d9f4e48f00d9208991328d89ff66bcabd9001c3144c29a347b98f7476849499e310cd6530c08066e0b8f4a
-  data.tar.gz: 99c5ed6434f2e18236257efb87a652094354c24711d3c7aed651dcfd20b0a0fade2ae15214fbf3ea002730e814f696951dfd7f8af964942937ff0d8b1d91f723
+  metadata.gz: f7e5f45ab6660cde57d0f6e101ffb0be54c64ad22a73b7ca39c1a13b74f854e9583355e41934b453211a435b0cf7dd716afbaf747c7e20458340f69eb6d76d51
+  data.tar.gz: 1fc648e0d7fe4252ecf94482981bfd278612707cc9efba0c2f13a5b6166b3cc49f1ab02732dde83ddf2292fc42f8d6cefb8d2850fc30a4b72d4d523df87e9f22

data/CHANGELOG.md

@@ -1,5 +1,72 @@
 ## [Unreleased]
 
+## [0.5.0](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.4.4...chrono_machines/v0.5.0) (2026-06-24)
+
+
+### Features
+
+* **native:** make core crate no_std capable ([#15](https://github.com/seuros/chrono_machines/issues/15)) ([76129a3](https://github.com/seuros/chrono_machines/commit/76129a31ad75142641e4a29a82424ad26fb9ecd6))
+
+
+### Bug Fixes
+
+* **native:** use workspace dependency for chrono-machines in ffi ([fdeca2f](https://github.com/seuros/chrono_machines/commit/fdeca2f938e2647107793cfcf4c5c7c77e62e09b))
+
+## [0.4.4](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.4.3...chrono_machines/v0.4.4) (2026-06-16)
+
+
+### Bug Fixes
+
+* Upgrade setup-java action to version 5 ([f6dcecc](https://github.com/seuros/chrono_machines/commit/f6dcecc233d4d4f74bacad8bfe893eff981a4737))
+
+## [0.4.3](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.4.2...chrono_machines/v0.4.3) (2026-06-15)
+
+
+### Bug Fixes
+
+* **native:** deduplicate backoff jitter, fibonacci, and retry-failure logic ([46f861a](https://github.com/seuros/chrono_machines/commit/46f861acc7e29024fc35dafb39aaec22db33440d))
+
+## [0.4.2](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.4.1...chrono_machines/v0.4.2) (2026-05-25)
+
+
+### Bug Fixes
+
+* remove unused Magnus embed feature ([3b0877a](https://github.com/seuros/chrono_machines/commit/3b0877a11f768a135c877980320cae53fa58cd3d))
+
+## [0.4.1](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.4.0...chrono_machines/v0.4.1) (2026-03-19)
+
+
+### Bug Fixes
+
+* **native:** upgrade rand to 0.10 ([#10](https://github.com/seuros/chrono_machines/issues/10)) ([d7e2738](https://github.com/seuros/chrono_machines/commit/d7e2738552a98e4f528055f671cfdfbdb02b0c7a))
+
+## [0.4.0](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.3.0...chrono_machines/v0.4.0) (2025-12-19)
+
+
+### Features
+
+* add async support, error classification ([#6](https://github.com/seuros/chrono_machines/issues/6)) ([3d6d2c6](https://github.com/seuros/chrono_machines/commit/3d6d2c6e06de58247c74cdcef94e78a099b11e31))
+* add constant and fibonacci backoff strategies with native acceleration ([582ba9c](https://github.com/seuros/chrono_machines/commit/582ba9ccd84072ec4ccf5d3340eced27cc4d1925))
+
+
+### Bug Fixes
+
+* add Ruby 4.0.0-preview3 to test matrix ([#9](https://github.com/seuros/chrono_machines/issues/9)) ([df8a3a2](https://github.com/seuros/chrono_machines/commit/df8a3a23acf5ea37b115ab7d05936331b4ae2018))
+
+## [0.3.0](https://github.com/seuros/chrono_machines/compare/chrono_machines/v0.2.0...chrono_machines/v0.3.0) (2025-10-14)
+
+
+### Features
+
+* add COSS (Contribution Open Source Standard) metadata ([de5b64a](https://github.com/seuros/chrono_machines/commit/de5b64af5c443d8987909199a69030fa332fa323))
+* add GitHub Packages native compilation workflow ([0d7e950](https://github.com/seuros/chrono_machines/commit/0d7e9502d13a8de6b47756c27d682339435fe663))
+* Add Rust native speedup with fluent retry DSL ([#4](https://github.com/seuros/chrono_machines/issues/4)) ([ac980bf](https://github.com/seuros/chrono_machines/commit/ac980bfda450b4e63739e4dc3c19513dd989e819))
+
+
+### Bug Fixes
+
+* CI compilation using extconf.rb instead of rb_sys task ([bd844a5](https://github.com/seuros/chrono_machines/commit/bd844a594f25745edb407695ef36f7e214a29347))
+
 ## [0.2.0](https://github.com/seuros/chrono_machines/compare/chrono_machines-v0.1.0...chrono_machines/v0.2.0) (2025-07-20)
 
 

data/README.md

@@ -613,6 +613,6 @@ MIT License. See [LICENSE](LICENSE) file for details.
 
 ## Author
 
-Built with time and coffee by temporal engineers fighting entropy one retry at a time.
+Built with time and Brawndo (it's got electrolytes) by temporal engineers fighting entropy one retry at a time.
 
 **Remember: In the fabric of spacetime, nobody can hear your API timeout. But they can feel your exponential backoff working as intended.**

data/ext/chrono_machines_native/core/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "chrono-machines"
+version = "0.4.0"
+edition = "2024"
+authors = ["Abdelkader Boudih <terminale@gmail.com>"]
+license = "MIT"
+description = "Exponential, constant, and Fibonacci backoff retry library with full jitter support - no_std compatible"
+repository = "https://github.com/seuros/chrono_machines"
+keywords = ["retry", "backoff", "exponential", "jitter", "resilience"]
+categories = ["no-std", "algorithms"]
+readme = "README.md"
+
+[lib]
+name = "chrono_machines"
+crate-type = ["lib"]
+
+[features]
+default = ["std"]
+std = ["alloc", "rand/std", "rand/thread_rng"]
+alloc = []
+async = ["std", "dep:async-trait"]
+
+[dependencies]
+rand = { version = "0.10", default-features = false, features = ["std_rng"] }
+async-trait = { version = "0.1", optional = true }
+
+[dev-dependencies]
+tokio = { version = "1", features = ["rt", "macros", "time"] }

data/ext/chrono_machines_native/core/src/backoff.rs

@@ -0,0 +1,516 @@
+//! Backoff strategy implementations for retry mechanisms
+//!
+//! This module provides various backoff strategies to control delay timing
+//! between retry attempts.
+
+use rand::Rng;
+use rand::RngExt;
+
+/// `f64::powi`, implemented by hand so it works in `core` (`no_std`).
+#[inline]
+pub(crate) fn powi_f64(base: f64, exp: i32) -> f64 {
+    if exp == 0 {
+        return 1.0;
+    }
+    let mut acc = 1.0_f64;
+    let mut factor = if exp < 0 { 1.0 / base } else { base };
+    let mut n = exp.unsigned_abs();
+    while n > 0 {
+        if n & 1 == 1 {
+            acc *= factor;
+        }
+        factor *= factor;
+        n >>= 1;
+    }
+    acc
+}
+
+/// Calculate the nth Fibonacci number (1-indexed): 1, 1, 2, 3, 5, 8, 13, ...
+pub fn fibonacci(n: u8) -> u64 {
+    match n {
+        0 => 0,
+        1 | 2 => 1,
+        _ => {
+            let mut a = 1u64;
+            let mut b = 1u64;
+            for _ in 2..n {
+                let next = a.saturating_add(b);
+                a = b;
+                b = next;
+            }
+            b
+        }
+    }
+}
+
+/// Blend a base delay with jitter using the full-jitter algorithm.
+///
+/// `jitter_factor` is clamped to `[0.0, 1.0]`: `0.0` returns `base` unchanged,
+/// `1.0` yields a uniform value in `[0, base]`.
+fn apply_jitter<R: Rng>(base: f64, jitter_factor: f64, rng: &mut R) -> u64 {
+    let jitter_factor = jitter_factor.clamp(0.0, 1.0);
+    let random_scalar: f64 = rng.random_range(0.0..=1.0);
+    let jitter_blend = 1.0 - jitter_factor + random_scalar * jitter_factor;
+    (base * jitter_blend) as u64
+}
+
+/// Trait for backoff strategies that calculate delays between retry attempts
+pub trait BackoffStrategy {
+    /// Calculate the delay in milliseconds for the given attempt number
+    ///
+    /// # Arguments
+    ///
+    /// * `attempt` - Current attempt number (1-indexed)
+    /// * `rng` - Random number generator for jitter
+    ///
+    /// # Returns
+    ///
+    /// Delay in milliseconds, or `None` if retries should stop
+    fn delay<R: Rng>(&self, attempt: u8, rng: &mut R) -> Option<u64>;
+
+    /// Check if another retry should be attempted
+    ///
+    /// # Arguments
+    ///
+    /// * `attempt` - Current attempt number (1-indexed)
+    ///
+    /// # Returns
+    ///
+    /// `true` if another retry is allowed, `false` otherwise
+    fn should_retry(&self, attempt: u8) -> bool;
+
+    /// Maximum number of retry attempts permitted by this strategy.
+    fn max_attempts(&self) -> u8;
+}
+
+/// Exponential backoff strategy with configurable jitter
+///
+/// Delays grow exponentially: base_delay * multiplier^(attempt-1)
+///
+/// # Example
+///
+/// ```rust
+/// use chrono_machines::ExponentialBackoff;
+///
+/// let backoff = ExponentialBackoff::new()
+///     .base_delay_ms(100)
+///     .multiplier(2.0)
+///     .max_delay_ms(10_000)
+///     .max_attempts(5)
+///     .jitter_factor(1.0); // Full jitter
+/// ```
+#[derive(Debug, Clone, Copy)]
+pub struct ExponentialBackoff {
+    /// Maximum number of retry attempts
+    pub max_attempts: u8,
+    /// Base delay in milliseconds
+    pub base_delay_ms: u64,
+    /// Exponential backoff multiplier
+    pub multiplier: f64,
+    /// Maximum delay cap in milliseconds
+    pub max_delay_ms: u64,
+    /// Jitter factor (0.0 = no jitter, 1.0 = full jitter)
+    pub jitter_factor: f64,
+}
+
+impl ExponentialBackoff {
+    /// Create a new exponential backoff builder with default values
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set the base delay in milliseconds
+    pub fn base_delay_ms(mut self, ms: u64) -> Self {
+        self.base_delay_ms = ms;
+        self
+    }
+
+    /// Set the exponential multiplier
+    pub fn multiplier(mut self, multiplier: f64) -> Self {
+        self.multiplier = multiplier;
+        self
+    }
+
+    /// Set the maximum delay cap in milliseconds
+    pub fn max_delay_ms(mut self, ms: u64) -> Self {
+        self.max_delay_ms = ms;
+        self
+    }
+
+    /// Set the maximum number of attempts
+    pub fn max_attempts(mut self, attempts: u8) -> Self {
+        self.max_attempts = attempts;
+        self
+    }
+
+    /// Set the jitter factor (0.0 = no jitter, 1.0 = full jitter)
+    pub fn jitter_factor(mut self, factor: f64) -> Self {
+        self.jitter_factor = factor.clamp(0.0, 1.0);
+        self
+    }
+}
+
+impl Default for ExponentialBackoff {
+    fn default() -> Self {
+        Self {
+            max_attempts: 3,
+            base_delay_ms: 100,
+            multiplier: 2.0,
+            max_delay_ms: 10_000,
+            jitter_factor: 1.0, // Full jitter by default
+        }
+    }
+}
+
+impl BackoffStrategy for ExponentialBackoff {
+    fn delay<R: Rng>(&self, attempt: u8, rng: &mut R) -> Option<u64> {
+        if attempt >= self.max_attempts {
+            return None;
+        }
+
+        let exponent = attempt.saturating_sub(1) as i32;
+        let base_exponential = (self.base_delay_ms as f64) * powi_f64(self.multiplier, exponent);
+        let capped = base_exponential.min(self.max_delay_ms as f64);
+
+        Some(apply_jitter(capped, self.jitter_factor, rng))
+    }
+
+    fn should_retry(&self, attempt: u8) -> bool {
+        attempt < self.max_attempts
+    }
+
+    fn max_attempts(&self) -> u8 {
+        self.max_attempts
+    }
+}
+
+/// Constant backoff strategy with fixed delay
+///
+/// All retry delays are the same constant value.
+///
+/// # Example
+///
+/// ```rust
+/// use chrono_machines::ConstantBackoff;
+///
+/// let backoff = ConstantBackoff::new()
+///     .delay_ms(500)
+///     .max_attempts(5)
+///     .jitter_factor(0.1); // 10% jitter
+/// ```
+#[derive(Debug, Clone, Copy)]
+pub struct ConstantBackoff {
+    /// Fixed delay in milliseconds
+    pub delay_ms: u64,
+    /// Maximum number of retry attempts
+    pub max_attempts: u8,
+    /// Jitter factor (0.0 = no jitter, 1.0 = full jitter)
+    pub jitter_factor: f64,
+}
+
+impl ConstantBackoff {
+    /// Create a new constant backoff builder with default values
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set the constant delay in milliseconds
+    pub fn delay_ms(mut self, ms: u64) -> Self {
+        self.delay_ms = ms;
+        self
+    }
+
+    /// Set the maximum number of attempts
+    pub fn max_attempts(mut self, attempts: u8) -> Self {
+        self.max_attempts = attempts;
+        self
+    }
+
+    /// Set the jitter factor (0.0 = no jitter, 1.0 = full jitter)
+    pub fn jitter_factor(mut self, factor: f64) -> Self {
+        self.jitter_factor = factor.clamp(0.0, 1.0);
+        self
+    }
+}
+
+impl Default for ConstantBackoff {
+    fn default() -> Self {
+        Self {
+            delay_ms: 100,
+            max_attempts: 3,
+            jitter_factor: 0.0, // No jitter for constant by default
+        }
+    }
+}
+
+impl BackoffStrategy for ConstantBackoff {
+    fn delay<R: Rng>(&self, attempt: u8, rng: &mut R) -> Option<u64> {
+        if attempt >= self.max_attempts {
+            return None;
+        }
+
+        Some(apply_jitter(self.delay_ms as f64, self.jitter_factor, rng))
+    }
+
+    fn should_retry(&self, attempt: u8) -> bool {
+        attempt < self.max_attempts
+    }
+
+    fn max_attempts(&self) -> u8 {
+        self.max_attempts
+    }
+}
+
+/// Fibonacci backoff strategy
+///
+/// Delays follow the Fibonacci sequence: 1, 1, 2, 3, 5, 8, 13, ...
+/// Each delay is base_delay_ms * fibonacci(attempt).
+///
+/// # Example
+///
+/// ```rust
+/// use chrono_machines::FibonacciBackoff;
+///
+/// let backoff = FibonacciBackoff::new()
+///     .base_delay_ms(100)  // 100ms, 100ms, 200ms, 300ms, 500ms...
+///     .max_delay_ms(5_000)
+///     .max_attempts(8)
+///     .jitter_factor(0.5); // 50% jitter
+/// ```
+#[derive(Debug, Clone, Copy)]
+pub struct FibonacciBackoff {
+    /// Base delay in milliseconds (multiplied by Fibonacci number)
+    pub base_delay_ms: u64,
+    /// Maximum delay cap in milliseconds
+    pub max_delay_ms: u64,
+    /// Maximum number of retry attempts
+    pub max_attempts: u8,
+    /// Jitter factor (0.0 = no jitter, 1.0 = full jitter)
+    pub jitter_factor: f64,
+}
+
+impl FibonacciBackoff {
+    /// Create a new Fibonacci backoff builder with default values
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set the base delay in milliseconds
+    pub fn base_delay_ms(mut self, ms: u64) -> Self {
+        self.base_delay_ms = ms;
+        self
+    }
+
+    /// Set the maximum delay cap in milliseconds
+    pub fn max_delay_ms(mut self, ms: u64) -> Self {
+        self.max_delay_ms = ms;
+        self
+    }
+
+    /// Set the maximum number of attempts
+    pub fn max_attempts(mut self, attempts: u8) -> Self {
+        self.max_attempts = attempts;
+        self
+    }
+
+    /// Set the jitter factor (0.0 = no jitter, 1.0 = full jitter)
+    pub fn jitter_factor(mut self, factor: f64) -> Self {
+        self.jitter_factor = factor.clamp(0.0, 1.0);
+        self
+    }
+}
+
+impl Default for FibonacciBackoff {
+    fn default() -> Self {
+        Self {
+            base_delay_ms: 100,
+            max_delay_ms: 10_000,
+            max_attempts: 8,
+            jitter_factor: 1.0, // Full jitter by default
+        }
+    }
+}
+
+impl BackoffStrategy for FibonacciBackoff {
+    fn delay<R: Rng>(&self, attempt: u8, rng: &mut R) -> Option<u64> {
+        if attempt >= self.max_attempts {
+            return None;
+        }
+
+        let fib = fibonacci(attempt);
+        let base = ((self.base_delay_ms as f64) * (fib as f64)).min(self.max_delay_ms as f64);
+
+        Some(apply_jitter(base, self.jitter_factor, rng))
+    }
+
+    fn should_retry(&self, attempt: u8) -> bool {
+        attempt < self.max_attempts
+    }
+
+    fn max_attempts(&self) -> u8 {
+        self.max_attempts
+    }
+}
+
+/// Backoff policy that can represent any supported strategy.
+///
+/// The enum form makes it possible to store heterogeneous strategies in a
+/// registry or configuration without heap allocation or dynamic dispatch.
+#[derive(Debug, Clone, Copy)]
+pub enum BackoffPolicy {
+    /// Exponential backoff policy
+    Exponential(ExponentialBackoff),
+    /// Constant backoff policy
+    Constant(ConstantBackoff),
+    /// Fibonacci backoff policy
+    Fibonacci(FibonacciBackoff),
+}
+
+impl BackoffPolicy {
+    /// Return the maximum retry attempts for the wrapped strategy.
+    pub fn max_attempts(&self) -> u8 {
+        match self {
+            BackoffPolicy::Exponential(policy) => policy.max_attempts,
+            BackoffPolicy::Constant(policy) => policy.max_attempts,
+            BackoffPolicy::Fibonacci(policy) => policy.max_attempts,
+        }
+    }
+}
+
+impl BackoffStrategy for BackoffPolicy {
+    fn delay<R: Rng>(&self, attempt: u8, rng: &mut R) -> Option<u64> {
+        match self {
+            BackoffPolicy::Exponential(policy) => policy.delay(attempt, rng),
+            BackoffPolicy::Constant(policy) => policy.delay(attempt, rng),
+            BackoffPolicy::Fibonacci(policy) => policy.delay(attempt, rng),
+        }
+    }
+
+    fn should_retry(&self, attempt: u8) -> bool {
+        match self {
+            BackoffPolicy::Exponential(policy) => policy.should_retry(attempt),
+            BackoffPolicy::Constant(policy) => policy.should_retry(attempt),
+            BackoffPolicy::Fibonacci(policy) => policy.should_retry(attempt),
+        }
+    }
+
+    fn max_attempts(&self) -> u8 {
+        match self {
+            BackoffPolicy::Exponential(policy) => policy.max_attempts(),
+            BackoffPolicy::Constant(policy) => policy.max_attempts(),
+            BackoffPolicy::Fibonacci(policy) => policy.max_attempts(),
+        }
+    }
+}
+
+impl From<ExponentialBackoff> for BackoffPolicy {
+    fn from(value: ExponentialBackoff) -> Self {
+        BackoffPolicy::Exponential(value)
+    }
+}
+
+impl From<ConstantBackoff> for BackoffPolicy {
+    fn from(value: ConstantBackoff) -> Self {
+        BackoffPolicy::Constant(value)
+    }
+}
+
+impl From<FibonacciBackoff> for BackoffPolicy {
+    fn from(value: FibonacciBackoff) -> Self {
+        BackoffPolicy::Fibonacci(value)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rand::rngs::StdRng;
+    use rand::SeedableRng;
+
+    #[test]
+    fn test_exponential_backoff_builder() {
+        let backoff = ExponentialBackoff::new()
+            .base_delay_ms(200)
+            .multiplier(3.0)
+            .max_delay_ms(5000)
+            .max_attempts(5)
+            .jitter_factor(0.5);
+
+        assert_eq!(backoff.base_delay_ms, 200);
+        assert_eq!(backoff.multiplier, 3.0);
+        assert_eq!(backoff.max_delay_ms, 5000);
+        assert_eq!(backoff.max_attempts, 5);
+        assert_eq!(backoff.jitter_factor, 0.5);
+    }
+
+    #[test]
+    fn test_exponential_delays() {
+        let backoff = ExponentialBackoff::new()
+            .base_delay_ms(100)
+            .multiplier(2.0)
+            .jitter_factor(0.0); // No jitter for predictable testing
+
+        let mut rng = StdRng::seed_from_u64(42);
+
+        assert_eq!(backoff.delay(1, &mut rng), Some(100));
+        assert_eq!(backoff.delay(2, &mut rng), Some(200));
+        assert_eq!(backoff.delay(3, &mut rng), None); // Exceeds max_attempts (default 3)
+    }
+
+    #[test]
+    fn test_constant_backoff() {
+        let backoff = ConstantBackoff::new()
+            .delay_ms(500)
+            .max_attempts(4)
+            .jitter_factor(0.0);
+
+        let mut rng = StdRng::seed_from_u64(42);
+
+        assert_eq!(backoff.delay(1, &mut rng), Some(500));
+        assert_eq!(backoff.delay(2, &mut rng), Some(500));
+        assert_eq!(backoff.delay(3, &mut rng), Some(500));
+        assert_eq!(backoff.delay(4, &mut rng), None);
+    }
+
+    #[test]
+    fn test_fibonacci_sequence() {
+        assert_eq!(fibonacci(1), 1);
+        assert_eq!(fibonacci(2), 1);
+        assert_eq!(fibonacci(3), 2);
+        assert_eq!(fibonacci(4), 3);
+        assert_eq!(fibonacci(5), 5);
+        assert_eq!(fibonacci(6), 8);
+        assert_eq!(fibonacci(7), 13);
+    }
+
+    #[test]
+    fn test_fibonacci_backoff() {
+        let backoff = FibonacciBackoff::new()
+            .base_delay_ms(100)
+            .max_attempts(5)
+            .jitter_factor(0.0);
+
+        let mut rng = StdRng::seed_from_u64(42);
+
+        assert_eq!(backoff.delay(1, &mut rng), Some(100)); // 100 * 1
+        assert_eq!(backoff.delay(2, &mut rng), Some(100)); // 100 * 1
+        assert_eq!(backoff.delay(3, &mut rng), Some(200)); // 100 * 2
+        assert_eq!(backoff.delay(4, &mut rng), Some(300)); // 100 * 3
+        assert_eq!(backoff.delay(5, &mut rng), None); // Exceeds max_attempts
+    }
+
+    #[test]
+    fn test_jitter_application() {
+        let backoff = ConstantBackoff::new().delay_ms(1000).jitter_factor(1.0); // Full jitter
+
+        let mut rng = StdRng::seed_from_u64(42);
+        let delays: Vec<u64> = (1..10).filter_map(|i| backoff.delay(i, &mut rng)).collect();
+
+        // With full jitter, delays should vary
+        let all_different = delays.windows(2).any(|w| w[0] != w[1]);
+        assert!(all_different, "Full jitter should produce varying delays");
+
+        // All delays should be <= base delay
+        assert!(delays.iter().all(|&d| d <= 1000));
+    }
+}