test {
  let backoff : @retry.Backoff = {
    base_ms: 500,
    max_ms: 30000,
    jitter: Proportional(lo=800, hi=1200),
  }
  assert_eq(backoff.delay_ms(2, 0.5), 2000)
  assert_eq(backoff.delay_ms(0, 0.0), 400)
}

1. attempt >= max_retries stops with Exhausted.
2. A body that cannot be sent again stops with NotReplayable; replayable overrides request.body.is_replayable().
3. A response carrying override_header with the value true (ignoring case and surrounding whitespace) skips step 4; false stops with ServerSaidNo; any other value is ignored.
4. The outcome must be retryable for the request's method: a response through the first StatusRule containing its status; Protocol never; Proxy when unsent_failures is set and its status matches a StatusRule; another unsent failure when unsent_failures is set; any other failure through sent_failures. Idempotent asks @http.is_idempotent unless idempotent is given.
5. The wait is server_delay_ms when given, otherwise the response's header per retry_after.source (an HTTP date needs now_unix_ms), bounded by retry_after.cap; without one it is backoff.delay_ms(attempt, random).
6. With remaining_ms, a wait that is not shorter than it stops with Budget(wait).

test {
  let rule : @retry.RetryRule = {
    ..@retry.RetryRule::never(),
    max_retries: 2,
    statuses: [{ statuses: [Code(429)], methods: Any, }],
    retry_after: {
      source: Header,
      cap: StopAbove(60000),
      zero_means_backoff: false,
    },
  }
  let post = @http.Request::post("/messages")
  let headers = @http.Headers::from_array([("Retry-After", "3")])
  let limited = @retry.Response(status=429, headers~)
  assert_eq(rule.decide(limited, post, attempt=0, random=0.5), Wait(3000))
  assert_eq(
    rule.decide(limited, post, attempt=0, random=0.5, remaining_ms=2000),
    Stop(Budget(3000)),
  )
}