///|
fn repeat_string(value : String, count : Int) -> String {
  let builder = StringBuilder()
  for i = 0; i < count; i = i + 1 {
    builder.write_string(value)
  }
  builder.to_string()
}

///|
test "stress: 256 ranges resolve under permissive limits" {
  let parts : Array[String] = []
  for i = 0; i < 256; i = i + 1 {
    parts.push("\{i * 10}-\{i * 10 + 9}")
  }
  let input = "bytes=" + join_strings(parts, ",")
  let request = parse_range_with_limits(input, Limits::permissive()).unwrap()
  assert_int_eq(request.specs().length(), 256)
  let resolved = resolve_byte_ranges(request, 10_000L).unwrap()
  assert_int_eq(resolved.satisfiable_count(), 256)
  assert_int_eq(resolved.unsatisfiable_count(), 0)
  for range in resolved.ranges() {
    assert_true(range.first() >= 0L)
    assert_true(range.last() < 10_000L)
  }
}

///|
test "stress: default limits reject a 33rd range" {
  let parts : Array[String] = []
  for i = 0; i < 33; i = i + 1 {
    parts.push("0-0")
  }
  let error = match
    parse_range_with_limits(
      "bytes=" + join_strings(parts, ","),
      Limits::default(),
    ) {
    Ok(_) => fail("expected LimitExceeded")
    Err(error) => error
  }
  assert_eq(error.kind(), LimitExceeded)
}

///|
test "stress: strict input limit accepts exactly 1024 bytes" {
  // OWS padding counts toward the input limit but never reaches the
  // decimal parser, so this isolates the max_input_bytes check.
  // "bytes=0-" is 8 characters; 1016 spaces reach exactly 1024 bytes.
  let input = "bytes=0-" + repeat_string(" ", 1016)
  let request = parse_range_with_limits(input, Limits::strict()).unwrap()
  assert_true(request.specs()[0] is OpenEnded(_))
  let error = match parse_range_with_limits(input + " ", Limits::strict()) {
    Ok(_) => fail("expected LimitExceeded")
    Err(error) => error
  }
  assert_eq(error.kind(), LimitExceeded)
}

///|
test "stress: 19-digit boundary around the Int64 maximum" {
  assert_true(
    parse_range_with_limits(
      "bytes=9223372036854775807-9223372036854775807",
      Limits::default(),
    )
    is Ok(_),
  )
  let error = match
    parse_range_with_limits("bytes=9223372036854775808-0", Limits::default()) {
    Ok(_) => fail("expected IntegerOverflow")
    Err(error) => error
  }
  assert_eq(error.kind(), IntegerOverflow)
}

///|
test "stress: multipart boundary sweep at the length edges" {
  assert_true(plan_multipart_ranges([], 10L, "x") is Ok(_))
  assert_true(plan_multipart_ranges([], 10L, repeat_string("a", 70)) is Ok(_))
  assert_true(plan_multipart_ranges([], 10L, repeat_string("a", 71)) is Err(_))
  assert_true(plan_multipart_ranges([], 10L, "has space") is Err(_))
  assert_true(plan_multipart_ranges([], 10L, "has\"quote") is Err(_))
}

///|
test "stress: audit stays bounded on a 32-range request" {
  let parts : Array[String] = []
  for i = 0; i < 32; i = i + 1 {
    parts.push("\{i}-\{i}")
  }
  let input = "bytes=" + join_strings(parts, ",")
  let request = parse_range(input).unwrap()
  let report = audit_range_request(
    request,
    raw_input=input,
    representation_length=100L,
  )
  assert_true(has_finding(report, ManySmallRanges))
  assert_true(has_finding(report, TooManyRanges))
  assert_true(has_finding(report, AdjacentRanges))
  assert_true(report.findings().length() >= 3)
}

///|
test "stress: unknown unit raw sets respect their own limit" {
  let request = parse_range_with_limits(
    "items=" + repeat_string("x", 500),
    Limits::permissive(),
  ).unwrap()
  assert_true(request.unit() is Other(_))
  let error = match
    parse_range_with_limits(
      "items=" + repeat_string("x", 513),
      Limits::strict(),
    ) {
    Ok(_) => fail("expected LimitExceeded")
    Err(error) => error
  }
  assert_eq(error.kind(), LimitExceeded)
}