///|
test "900 deterministic Range parse serialize resolve and coalesce cases" {
  let mut state = 0x2468ACE
  for case = 0; case < 900; case = case + 1 {
    state = state * 1_103_515_245 + 12_345
    let length = 1L + ((state >> 8) & 4095).to_int64()
    let first = ((state >> 3) & 2047).to_int64() % length
    let span = 1L + ((state >> 13) & 255).to_int64()
    let requested_last = first + span
    let text = if case % 3 == 0 {
      "bytes=\{first}-\{requested_last},-\{1L + first % 17L}"
    } else if case % 3 == 1 {
      "BYTES=\{first}-"
    } else {
      "bytes=\{first}-\{requested_last}"
    }
    let request = unwrap_request(text)
    let canonical = serialize_range(request)
    assert_str_eq(serialize_range(unwrap_request(canonical)), canonical)
    let resolved = resolve_byte_ranges(request, length).unwrap()
    for range in resolved.ranges() {
      assert_true(range.first() >= 0L)
      assert_true(range.last() >= range.first())
      assert_true(range.last() < length)
    }
    let merged = coalesce_ranges(resolved.ranges())
    for i = 1; i < merged.length(); i = i + 1 {
      assert_true(merged[i - 1].last() < merged[i].first())
    }
  }
}

///|
test "600 deterministic Content-Range parse serialize round trips" {
  let mut state = 0x1A2B3C4D
  for case = 0; case < 600; case = case + 1 {
    state = state * 1_664_525 + 1_013_904_223
    let length = 1L + ((state >> 7) & 65_535).to_int64()
    let first = ((state >> 5) & 32_767).to_int64() % length
    let last = first + ((state >> 11) & 4_095).to_int64() % (length - first)
    let value = if case % 3 == 0 {
      Satisfied(Bytes, first, last, Some(length))
    } else if case % 3 == 1 {
      Satisfied(Bytes, first, last, None)
    } else {
      Unsatisfied(Bytes, length)
    }
    let text = serialize_content_range(value)
    assert_eq(parse_content_range(text).unwrap(), value)
  }
}

///|
test "400 deterministic Accept-Ranges parse serialize round trips" {
  let mut state = 0x9E3779B9
  let units = ["bytes", "BYTES", "exampleunit", "things", "widgets"]
  for case = 0; case < 400; case = case + 1 {
    state = state * 1_664_525 + 1_013_904_223
    let text = if (state >> 9) % 4 == 0 {
      "none"
    } else {
      // Mask before indexing: 32-bit Int wrapping makes >> 3 negative.
      units[(state >> 3) & 3]
    }
    let parsed = parse_accept_ranges(text).unwrap()
    let canonical = serialize_accept_ranges(parsed)
    assert_eq(parse_accept_ranges(canonical).unwrap(), parsed)
  }
}

///|
test "300 deterministic strong etag comparison cases" {
  let mut state = 0x1234567
  for case = 0; case < 300; case = case + 1 {
    state = state * 1_664_525 + 1_013_904_223
    let left_weak = (state & 1) == 1
    let right_weak = ((state >> 2) & 1) == 1
    let same = ((state >> 4) & 1) == 1
    let left = "\{(if left_weak { "W/" } else { "" })}\{(if same { "t" } else { "a" })}"
    let right = "\{(if right_weak { "W/" } else { "" })}t"
    assert_eq(
      strong_etag_equal("\{left}", "\{right}"),
      same && !left_weak && !right_weak,
    )
  }
}

///|
test "500 deterministic multipart estimate structural cases" {
  let mut state = 0xDEADBEEF
  for case = 0; case < 500; case = case + 1 {
    state = state * 1_664_525 + 1_013_904_223
    let count = 1 + (state & 7)
    let length = 10_000L + ((state >> 4) & 9_999).to_int64()
    let ranges : Array[ConcreteRange] = []
    let mut cursor = 0L
    let mut data_sum = 0L
    for i = 0; i < count; i = i + 1 {
      state = state * 1_664_525 + 1_013_904_223
      let span = 1L + ((state >> 6) & 255).to_int64()
      let first = cursor + ((state >> 9) & 127).to_int64()
      let last = first + span
      if last >= length {
        break
      }
      ranges.push(concrete_range(first, last))
      data_sum = data_sum + (last - first + 1L)
      cursor = last + 1L + ((state >> 13) & 63).to_int64()
    }
    let plan = plan_multipart_ranges(ranges, length, "TESTBOUNDARY").unwrap()
    let estimate = plan.estimated_body_length("text/plain")
    assert_true(estimate >= data_sum)
    // A multi-part estimate must equal the sum of per-part single plans
    // minus the duplicated closing delimiters.
    let mut singles = 0L
    for range in ranges {
      let single = plan_multipart_ranges([range], length, "TESTBOUNDARY")
        .unwrap()
        .estimated_body_length("text/plain")
      singles = singles + single
    }
    let closing = plan_multipart_ranges([], length, "TESTBOUNDARY")
      .unwrap()
      .estimated_body_length("text/plain")
    assert_i64_eq(
      estimate,
      singles - closing * (ranges.length() - 1).to_int64(),
    )
  }
}