///|
test "resolve closed range" {
  let r = unwrap_resolve("bytes=0-499", 1_000L).ranges()[0]
  assert_true(r == concrete_range(0L, 499L))
}

///|
test "resolve clips closed range at representation end" {
  assert_true(
    unwrap_resolve("bytes=0-999", 500L).ranges()[0] == concrete_range(0L, 499L),
  )
}

///|
test "closed range starting at end is unsatisfiable" {
  assert_int_eq(unwrap_resolve("bytes=500-999", 500L).unsatisfiable_count(), 1)
}

///|
test "resolve open ended range" {
  assert_true(
    unwrap_resolve("bytes=500-", 1_000L).ranges()[0] ==
    concrete_range(500L, 999L),
  )
}

///|
test "open ended beyond end is unsatisfiable" {
  assert_int_eq(unwrap_resolve("bytes=1500-", 1_000L).satisfiable_count(), 0)
}

///|
test "suffix selects last bytes" {
  assert_true(
    unwrap_resolve("bytes=-500", 1_000L).ranges()[0] ==
    concrete_range(500L, 999L),
  )
}

///|
test "large suffix selects whole representation" {
  assert_true(
    unwrap_resolve("bytes=-500", 200L).ranges()[0] == concrete_range(0L, 199L),
  )
}

///|
test "suffix one selects final byte" {
  assert_true(
    unwrap_resolve("bytes=-1", 10L).ranges()[0] == concrete_range(9L, 9L),
  )
}

///|
test "zero suffix is unsatisfiable" {
  assert_int_eq(unwrap_resolve("bytes=-0", 10L).unsatisfiable_count(), 1)
}

///|
test "zero length representation makes all ranges unsatisfiable" {
  assert_int_eq(unwrap_resolve("bytes=0-0,-1", 0L).unsatisfiable_count(), 2)
}

///|
test "one byte representation supports final byte" {
  assert_true(
    unwrap_resolve("bytes=0-0", 1L).ranges()[0] == concrete_range(0L, 0L),
  )
}

///|
test "partially satisfiable set retains good member" {
  let r = unwrap_resolve("bytes=0-99,9999-10000", 1_000L)
  assert_int_eq(r.satisfiable_count(), 1)
  assert_int_eq(r.unsatisfiable_count(), 1)
  assert_int_eq(r.original_count(), 2)
}

///|
test "completely unsatisfiable set has no ranges" {
  assert_true(unwrap_resolve("bytes=1000-,2000-", 1_000L).ranges().is_empty())
}

///|
test "resolver rejects negative representation length" {
  assert_true(
    resolve_byte_ranges(unwrap_request("bytes=0-1"), -1L)
    is Err(RangeError(_, InvalidRepresentationLength, _, _)),
  )
}

///|
test "resolver rejects unknown units" {
  assert_true(
    resolve_byte_ranges(unwrap_request("items=0-1"), 10L)
    is Err(RangeError(_, UnsupportedRangeUnit, _, _)),
  )
}

///|
test "concrete range length is inclusive" {
  assert_i64_eq(concrete_range(5L, 5L).length(), 1L)
}

///|
test "suffix one selects the final byte" {
  let ranges = unwrap_resolve("bytes=-1", 10L).ranges()
  assert_i64_eq(ranges[0].first(), 9L)
  assert_i64_eq(ranges[0].last(), 9L)
}