///|
test "builder creates all standard members" {
  let p = unwrap_build(
    ProblemBuilder::new()
    .type_uri("urn:x")
    .title("T")
    .status(400)
    .detail("D")
    .instance("/i")
    .build(),
  )
  assert_int_eq(p.standard_member_count(), 5)
}

///|
test "builder keeps arbitrary json extensions" {
  let p = unwrap_build(
    ProblemBuilder::new()
    .extension("meta", Json::array([Json::number(1.0)]))
    .build(),
  )
  assert_true(p.extension("meta") is Some(Array(_)))
}

///|
test "builder rejects type extension collision" {
  let r = ProblemBuilder::new().extension("type", Json::string("x")).build()
  assert_true(r is Err(ProblemError(_, DuplicateReservedExtension, _, _)))
}

///|
test "builder rejects status extension collision" {
  assert_true(
    ProblemBuilder::new().extension("status", Json::number(400.0)).build()
    is Err(_),
  )
}

///|
test "builder rejects invalid status" {
  assert_true(ProblemBuilder::new().status(99).build() is Err(_))
}

///|
test "builder rejects invalid type uri" {
  assert_true(ProblemBuilder::new().type_uri("bad uri").build() is Err(_))
}

///|
test "builder replaces duplicate extension names" {
  let p = unwrap_build(
    ProblemBuilder::new()
    .extension("x", Json::number(1.0))
    .extension("x", Json::number(2.0))
    .build(),
  )
  assert_int_eq(p.extensions().length(), 1)
  assert_true(p.extension("x") == Some(Json::number(2.0)))
}

///|
test "problem convenience creates status and title" {
  let p = unwrap_build(problem(404, "Missing"))
  assert_int_eq(p.status().unwrap(), 404)
  assert_str_eq(p.title().unwrap(), "Missing")
}

///|
test "about blank convenience derives common title" {
  let p = unwrap_build(about_blank(404))
  assert_str_eq(p.title().unwrap(), "Not Found")
  assert_true(p.is_about_blank())
}

///|
test "about blank convenience accepts unknown valid status" {
  let p = unwrap_build(about_blank(299))
  assert_int_eq(p.status().unwrap(), 299)
  assert_true(p.title() is None)
}