(* Test runner for json_pointer *)

let read_file path =
  let ic = open_in path in
  let n = in_channel_length ic in
  let s = really_input_string ic n in
  close_in ic;
  s

let parse_json s =
  match Jsont_bytesrw.decode_string Jsont.json s with
  | Ok json -> json
  | Error e -> failwith e

let json_to_string json =
  match Jsont_bytesrw.encode_string Jsont.json json with
  | Ok s -> s
  | Error e -> failwith e

(* Helper to get indices from any pointer *)
let indices_of_any (Json_pointer.Any p) = Json_pointer.indices p

(* Helper to convert to string from any pointer *)
let to_string_of_any (Json_pointer.Any p) = Json_pointer.to_string p

(* Helper to check if pointer is append *)
let is_append_any p = not (Json_pointer.is_nav p)

(* Test: parse pointer and print indices *)
let test_parse pointer_str =
  try
    let result = Json_pointer.of_string pointer_str in
    let indices = indices_of_any result in
    let index_strs = List.map (fun idx ->
      match idx with
      | Jsont.Path.Mem (s, _) -> Printf.sprintf "Mem:%s" s
      | Jsont.Path.Nth (n, _) -> Printf.sprintf "Nth:%d" n
    ) indices in
    let suffix = if is_append_any result then ", /-" else "" in
    Printf.printf "OK: [%s%s]\n" (String.concat ", " index_strs) suffix
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: roundtrip pointer string *)
let test_roundtrip pointer_str =
  try
    let result = Json_pointer.of_string pointer_str in
    let s = to_string_of_any result in
    if s = pointer_str then
      Printf.printf "OK: %s\n" s
    else
      Printf.printf "MISMATCH: input=%s output=%s\n" pointer_str s
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: evaluate pointer against JSON *)
let test_eval json_path pointer_str =
  try
    let json = parse_json (read_file json_path) in
    let p = Json_pointer.of_string_nav pointer_str in
    let result = Json_pointer.get p json in
    Printf.printf "OK: %s\n" (json_to_string result)
  with
  | Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
  | Failure e ->
    Printf.printf "FAIL: %s\n" e

(* Test: escape token *)
let test_escape token =
  let escaped = Json_pointer.Token.escape token in
  Printf.printf "%s\n" escaped

(* Test: unescape token *)
let test_unescape token =
  try
    let unescaped = Json_pointer.Token.unescape token in
    Printf.printf "OK: %s\n" unescaped
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: URI fragment roundtrip *)
let test_uri_fragment pointer_str =
  try
    let result = Json_pointer.of_string pointer_str in
    let (Json_pointer.Any p) = result in
    let frag = Json_pointer.to_uri_fragment p in
    let result2 = Json_pointer.of_uri_fragment frag in
    let s2 = to_string_of_any result2 in
    if s2 = pointer_str then
      Printf.printf "OK: %s -> %s\n" pointer_str frag
    else
      Printf.printf "MISMATCH: %s -> %s -> %s\n" pointer_str frag s2
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: add operation *)
let test_add json_str pointer_str value_str =
  try
    let json = parse_json json_str in
    let value = parse_json value_str in
    let p = Json_pointer.of_string pointer_str in
    let result = Json_pointer.add p json ~value in
    Printf.printf "%s\n" (json_to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: remove operation *)
let test_remove json_str pointer_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.of_string_nav pointer_str in
    let result = Json_pointer.remove p json in
    Printf.printf "%s\n" (json_to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: replace operation *)
let test_replace json_str pointer_str value_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.of_string_nav pointer_str in
    let value = parse_json value_str in
    let result = Json_pointer.replace p json ~value in
    Printf.printf "%s\n" (json_to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: move operation *)
let test_move json_str from_str path_str =
  try
    let json = parse_json json_str in
    let from = Json_pointer.of_string_nav from_str in
    let path = Json_pointer.of_string path_str in
    let result = Json_pointer.move ~from ~path json in
    Printf.printf "%s\n" (json_to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: copy operation *)
let test_copy json_str from_str path_str =
  try
    let json = parse_json json_str in
    let from = Json_pointer.of_string_nav from_str in
    let path = Json_pointer.of_string path_str in
    let result = Json_pointer.copy ~from ~path json in
    Printf.printf "%s\n" (json_to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: test operation *)
let test_test json_str pointer_str expected_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.of_string_nav pointer_str in
    let expected = parse_json expected_str in
    let result = Json_pointer.test p json ~expected in
    Printf.printf "%b\n" result
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: has operation (checks if pointer exists) *)
let test_has json_str pointer_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.of_string_nav pointer_str in
    let result = Json_pointer.find p json in
    Printf.printf "%b\n" (Option.is_some result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: JMAP extended pointer parse *)
let test_jmap_parse pointer_str =
  try
    let p = Json_pointer.Jmap.of_string pointer_str in
    let s = Json_pointer.Jmap.to_string p in
    if s = "" then Printf.printf "OK: (root)\n"
    else Printf.printf "OK: %s\n" s
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: JMAP extended pointer evaluation *)
let test_jmap_eval json_str pointer_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.Jmap.of_string pointer_str in
    let result = Json_pointer.Jmap.eval p json in
    Printf.printf "OK: %s\n" (json_to_string result)
  with
  | Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
  | Failure e ->
    Printf.printf "FAIL: %s\n" e

(* Test: JMAP extended pointer evaluation from file *)
let test_jmap_eval_file json_path pointer_str =
  try
    let json = parse_json (read_file json_path) in
    let p = Json_pointer.Jmap.of_string pointer_str in
    let result = Json_pointer.Jmap.eval p json in
    Printf.printf "OK: %s\n" (json_to_string result)
  with
  | Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
  | Failure e ->
    Printf.printf "FAIL: %s\n" e

(* Test: JMAP path combinator - extract strings *)
let test_jmap_path_strings json_str pointer_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.Jmap.of_string pointer_str in
    let codec = Json_pointer.Jmap.path_list p Jsont.string in
    let result = match Jsont.Json.decode' codec json with
      | Ok v -> v
      | Error e -> raise (Jsont.Error e)
    in
    Printf.printf "OK: [%s]\n" (String.concat ", " result)
  with
  | Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
  | Failure e ->
    Printf.printf "FAIL: %s\n" e

(* Test: JMAP path combinator - extract ints *)
let test_jmap_path_ints json_str pointer_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.Jmap.of_string pointer_str in
    let codec = Json_pointer.Jmap.path_list p Jsont.int in
    let result = match Jsont.Json.decode' codec json with
      | Ok v -> v
      | Error e -> raise (Jsont.Error e)
    in
    Printf.printf "OK: [%s]\n" (String.concat ", " (List.map string_of_int result))
  with
  | Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
  | Failure e ->
    Printf.printf "FAIL: %s\n" e

(* Test: JMAP path combinator - extract single value *)
let test_jmap_path_single json_str pointer_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.Jmap.of_string pointer_str in
    let codec = Json_pointer.Jmap.path p Jsont.string in
    let result = match Jsont.Json.decode' codec json with
      | Ok v -> v
      | Error e -> raise (Jsont.Error e)
    in
    Printf.printf "OK: %s\n" result
  with
  | Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
  | Failure e ->
    Printf.printf "FAIL: %s\n" e

(* Test: JMAP path combinator with absent *)
let test_jmap_path_absent json_str pointer_str default =
  try
    let json = parse_json json_str in
    let p = Json_pointer.Jmap.of_string pointer_str in
    let codec = Json_pointer.Jmap.path ~absent:default p Jsont.string in
    let result = match Jsont.Json.decode' codec json with
      | Ok v -> v
      | Error e -> raise (Jsont.Error e)
    in
    Printf.printf "OK: %s\n" result
  with
  | Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)
  | Failure e ->
    Printf.printf "FAIL: %s\n" e

(* Test: index functions - mem, nth, pp_index, equal_index, compare_index *)
let test_mem name =
  let idx = Json_pointer.mem name in
  Format.printf "mem(%s) = %a\n" name Json_pointer.pp_index idx

let test_nth n =
  let idx = Json_pointer.nth n in
  Format.printf "nth(%d) = %a\n" n Json_pointer.pp_index idx

let test_equal_index idx1_str idx2_str =
  let parse_idx s =
    if String.length s > 0 && s.[0] >= '0' && s.[0] <= '9' then
      Json_pointer.nth (int_of_string s)
    else
      Json_pointer.mem s
  in
  let idx1 = parse_idx idx1_str in
  let idx2 = parse_idx idx2_str in
  Printf.printf "%b\n" (Json_pointer.equal_index idx1 idx2)

let test_compare_index idx1_str idx2_str =
  let parse_idx s =
    if String.length s > 0 && s.[0] >= '0' && s.[0] <= '9' then
      Json_pointer.nth (int_of_string s)
    else
      Json_pointer.mem s
  in
  let idx1 = parse_idx idx1_str in
  let idx2 = parse_idx idx2_str in
  let cmp = Json_pointer.compare_index idx1 idx2 in
  if cmp < 0 then Printf.printf "LT\n"
  else if cmp > 0 then Printf.printf "GT\n"
  else Printf.printf "EQ\n"

(* Test: pointer constructors - root, is_root, make *)
let test_root () =
  let r = Json_pointer.root in
  Printf.printf "root = %s\n" (Json_pointer.to_string r);
  Printf.printf "is_root(root) = %b\n" (Json_pointer.is_root r)

let test_is_root pointer_str =
  try
    let p = Json_pointer.of_string pointer_str in
    let (Json_pointer.Any ptr) = p in
    Printf.printf "%b\n" (Json_pointer.is_root ptr)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

let test_make indices_str =
  (* Parse comma-separated indices like "foo,0,bar" *)
  let parts = String.split_on_char ',' indices_str in
  let indices = List.map (fun s ->
    let s = String.trim s in
    if s = "" then Json_pointer.mem ""
    else if String.length s > 0 && s.[0] >= '0' && s.[0] <= '9' then
      Json_pointer.nth (int_of_string s)
    else
      Json_pointer.mem s
  ) parts in
  let p = Json_pointer.make indices in
  Printf.printf "%s\n" (Json_pointer.to_string p)

(* Test: append_index and / operator *)
let test_append_index base_str index_str =
  try
    let base = Json_pointer.of_string_nav base_str in
    let idx =
      if String.length index_str > 0 && index_str.[0] >= '0' && index_str.[0] <= '9' then
        Json_pointer.nth (int_of_string index_str)
      else
        Json_pointer.mem index_str
    in
    let result = Json_pointer.(base / idx) in
    Printf.printf "%s\n" (Json_pointer.to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: at_end *)
let test_at_end pointer_str =
  try
    let p = Json_pointer.of_string_nav pointer_str in
    let append_p = Json_pointer.at_end p in
    Printf.printf "%s\n" (Json_pointer.to_string append_p)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: concat *)
let test_concat p1_str p2_str =
  try
    let p1 = Json_pointer.of_string_nav p1_str in
    let p2 = Json_pointer.of_string_nav p2_str in
    let result = Json_pointer.concat p1 p2 in
    Printf.printf "%s\n" (Json_pointer.to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: parent *)
let test_parent pointer_str =
  try
    let p = Json_pointer.of_string_nav pointer_str in
    match Json_pointer.parent p with
    | Some parent -> Printf.printf "Some(%s)\n" (Json_pointer.to_string parent)
    | None -> Printf.printf "None\n"
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: last *)
let test_last pointer_str =
  try
    let p = Json_pointer.of_string_nav pointer_str in
    match Json_pointer.last p with
    | Some idx -> Format.printf "Some(%a)\n" Json_pointer.pp_index idx
    | None -> Printf.printf "None\n"
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: indices *)
let test_indices pointer_str =
  try
    let p = Json_pointer.of_string pointer_str in
    let indices = indices_of_any p in
    let strs = List.map (fun idx ->
      match idx with
      | Jsont.Path.Mem (s, _) -> Printf.sprintf "Mem:%s" s
      | Jsont.Path.Nth (n, _) -> Printf.sprintf "Nth:%d" n
    ) indices in
    Printf.printf "[%s]\n" (String.concat ", " strs)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: coercion - to_nav, to_nav_exn *)
let test_to_nav pointer_str =
  try
    let p = Json_pointer.of_string pointer_str in
    match Json_pointer.to_nav p with
    | Some nav -> Printf.printf "Some(%s)\n" (Json_pointer.to_string nav)
    | None -> Printf.printf "None\n"
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

let test_to_nav_exn pointer_str =
  try
    let p = Json_pointer.of_string pointer_str in
    let nav = Json_pointer.to_nav_exn p in
    Printf.printf "OK: %s\n" (Json_pointer.to_string nav)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: of_string_kind *)
let test_of_string_kind pointer_str =
  try
    match Json_pointer.of_string_kind pointer_str with
    | `Nav p -> Printf.printf "Nav(%s)\n" (Json_pointer.to_string p)
    | `Append p -> Printf.printf "Append(%s)\n" (Json_pointer.to_string p)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: of_string_result *)
let test_of_string_result pointer_str =
  match Json_pointer.of_string_result pointer_str with
  | Ok p -> Printf.printf "Ok(%s)\n" (to_string_of_any p)
  | Error e -> Printf.printf "Error(%s)\n" e

(* Test: of_uri_fragment_nav *)
let test_of_uri_fragment_nav frag =
  try
    let p = Json_pointer.of_uri_fragment_nav frag in
    Printf.printf "OK: %s\n" (Json_pointer.to_string p)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: of_uri_fragment_result *)
let test_of_uri_fragment_result frag =
  match Json_pointer.of_uri_fragment_result frag with
  | Ok p -> Printf.printf "Ok(%s)\n" (to_string_of_any p)
  | Error e -> Printf.printf "Error(%s)\n" e

(* Test: pp and pp_verbose *)
let test_pp pointer_str =
  try
    let p = Json_pointer.of_string pointer_str in
    let (Json_pointer.Any ptr) = p in
    Format.printf "%a\n" Json_pointer.pp ptr
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

let test_pp_verbose pointer_str =
  try
    let p = Json_pointer.of_string pointer_str in
    let (Json_pointer.Any ptr) = p in
    Format.printf "%a\n" Json_pointer.pp_verbose ptr
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: equal *)
let test_equal p1_str p2_str =
  try
    let p1 = Json_pointer.of_string p1_str in
    let p2 = Json_pointer.of_string p2_str in
    let (Json_pointer.Any ptr1) = p1 in
    let (Json_pointer.Any ptr2) = p2 in
    Printf.printf "%b\n" (Json_pointer.equal ptr1 ptr2)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: compare *)
let test_compare p1_str p2_str =
  try
    let p1 = Json_pointer.of_string p1_str in
    let p2 = Json_pointer.of_string p2_str in
    let (Json_pointer.Any ptr1) = p1 in
    let (Json_pointer.Any ptr2) = p2 in
    let cmp = Json_pointer.compare ptr1 ptr2 in
    if cmp < 0 then Printf.printf "LT\n"
    else if cmp > 0 then Printf.printf "GT\n"
    else Printf.printf "EQ\n"
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: of_path and to_path *)
let test_of_path () =
  (* Create a Jsont.Path and convert to pointer *)
  let path = Jsont.Path.(
    root
    |> Jsont.Path.nth 0
    |> Jsont.Path.mem "foo"
    |> Jsont.Path.nth 1
  ) in
  let p = Json_pointer.of_path path in
  Printf.printf "%s\n" (Json_pointer.to_string p)

let test_to_path pointer_str =
  try
    let p = Json_pointer.of_string_nav pointer_str in
    let path = Json_pointer.to_path p in
    (* Use rev_indices to get the indices in reverse order *)
    let indices = Jsont.Path.rev_indices path in
    let parts = List.rev_map (fun idx ->
      match idx with
      | Jsont.Path.Mem (s, _) -> Printf.sprintf "Mem:%s" s
      | Jsont.Path.Nth (n, _) -> Printf.sprintf "Nth:%d" n
    ) indices in
    Printf.printf "[%s]\n" (String.concat ", " parts)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: get_result *)
let test_get_result json_str pointer_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.of_string_nav pointer_str in
    match Json_pointer.get_result p json with
    | Ok result -> Printf.printf "Ok(%s)\n" (json_to_string result)
    | Error e -> Printf.printf "Error(%s)\n" (Jsont.Error.to_string e)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: set operation *)
let test_set json_str pointer_str value_str =
  try
    let json = parse_json json_str in
    let value = parse_json value_str in
    let p = Json_pointer.of_string pointer_str in
    let result = Json_pointer.set p json ~value in
    Printf.printf "%s\n" (json_to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: jsont codec *)
let test_jsont_codec pointer_str =
  try
    let json = Jsont.Json.string pointer_str in
    let decoded = match Jsont.Json.decode' Json_pointer.jsont json with
      | Ok p -> p
      | Error e -> raise (Jsont.Error e)
    in
    let encoded = match Jsont.Json.encode' Json_pointer.jsont decoded with
      | Ok j -> j
      | Error e -> raise (Jsont.Error e)
    in
    let encoded_str = json_to_string encoded in
    Printf.printf "%s\n" encoded_str
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: jsont_kind codec *)
let test_jsont_kind pointer_str =
  try
    let json = Jsont.Json.string pointer_str in
    let decoded = match Jsont.Json.decode' Json_pointer.jsont_kind json with
      | Ok p -> p
      | Error e -> raise (Jsont.Error e)
    in
    match decoded with
    | `Nav p -> Printf.printf "Nav(%s)\n" (Json_pointer.to_string p)
    | `Append p -> Printf.printf "Append(%s)\n" (Json_pointer.to_string p)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: jsont_nav codec *)
let test_jsont_nav pointer_str =
  try
    let json = Jsont.Json.string pointer_str in
    let decoded = match Jsont.Json.decode' Json_pointer.jsont_nav json with
      | Ok p -> p
      | Error e -> raise (Jsont.Error e)
    in
    Printf.printf "OK: %s\n" (Json_pointer.to_string decoded)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: jsont_uri_fragment codec *)
let test_jsont_uri_fragment pointer_str =
  try
    (* First parse it normally, then encode as URI fragment *)
    let p = Json_pointer.of_string pointer_str in
    let encoded = match Jsont.Json.encode' Json_pointer.jsont_uri_fragment p with
      | Ok j -> j
      | Error e -> raise (Jsont.Error e)
    in
    let encoded_str = json_to_string encoded in
    Printf.printf "%s\n" encoded_str
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: query combinator - path *)
let test_query_path json_str pointer_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.of_string_nav pointer_str in
    let codec = Json_pointer.path p Jsont.string in
    let result = match Jsont.Json.decode' codec json with
      | Ok v -> v
      | Error e -> raise (Jsont.Error e)
    in
    Printf.printf "OK: %s\n" result
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: query combinator - path with absent *)
let test_query_path_absent json_str pointer_str default =
  try
    let json = parse_json json_str in
    let p = Json_pointer.of_string_nav pointer_str in
    let codec = Json_pointer.path ~absent:default p Jsont.string in
    let result = match Jsont.Json.decode' codec json with
      | Ok v -> v
      | Error e -> raise (Jsont.Error e)
    in
    Printf.printf "OK: %s\n" result
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: query combinator - set_path *)
let test_set_path json_str pointer_str value_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.of_string pointer_str in
    let codec = Json_pointer.set_path Jsont.string p value_str in
    let result = match Jsont.Json.recode' codec json with
      | Ok v -> v
      | Error e -> raise (Jsont.Error e)
    in
    Printf.printf "%s\n" (json_to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: query combinator - update_path *)
let test_update_path json_str pointer_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.of_string_nav pointer_str in
    let codec = Json_pointer.update_path p Jsont.string in
    let result = match Jsont.Json.recode' codec json with
      | Ok v -> v
      | Error e -> raise (Jsont.Error e)
    in
    Printf.printf "%s\n" (json_to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: query combinator - delete_path *)
let test_delete_path json_str pointer_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.of_string_nav pointer_str in
    let codec = Json_pointer.delete_path p in
    let result = match Jsont.Json.recode' codec json with
      | Ok v -> v
      | Error e -> raise (Jsont.Error e)
    in
    Printf.printf "%s\n" (json_to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: query combinator - delete_path with allow_absent *)
let test_delete_path_absent json_str pointer_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.of_string_nav pointer_str in
    let codec = Json_pointer.delete_path ~allow_absent:true p in
    let result = match Jsont.Json.recode' codec json with
      | Ok v -> v
      | Error e -> raise (Jsont.Error e)
    in
    Printf.printf "%s\n" (json_to_string result)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: JMAP of_string_result *)
let test_jmap_of_string_result pointer_str =
  match Json_pointer.Jmap.of_string_result pointer_str with
  | Ok p -> Printf.printf "Ok(%s)\n" (Json_pointer.Jmap.to_string p)
  | Error e -> Printf.printf "Error(%s)\n" e

(* Test: JMAP pp *)
let test_jmap_pp pointer_str =
  try
    let p = Json_pointer.Jmap.of_string pointer_str in
    Format.printf "%a\n" Json_pointer.Jmap.pp p
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: JMAP eval_result *)
let test_jmap_eval_result json_str pointer_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.Jmap.of_string pointer_str in
    match Json_pointer.Jmap.eval_result p json with
    | Ok result -> Printf.printf "Ok(%s)\n" (json_to_string result)
    | Error e -> Printf.printf "Error(%s)\n" (Jsont.Error.to_string e)
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: JMAP find *)
let test_jmap_find json_str pointer_str =
  try
    let json = parse_json json_str in
    let p = Json_pointer.Jmap.of_string pointer_str in
    match Json_pointer.Jmap.find p json with
    | Some result -> Printf.printf "Some(%s)\n" (json_to_string result)
    | None -> Printf.printf "None\n"
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

(* Test: JMAP jsont codec *)
let test_jmap_jsont pointer_str =
  try
    let json = Jsont.Json.string pointer_str in
    let decoded = match Jsont.Json.decode' Json_pointer.Jmap.jsont json with
      | Ok p -> p
      | Error e -> raise (Jsont.Error e)
    in
    let encoded = match Jsont.Json.encode' Json_pointer.Jmap.jsont decoded with
      | Ok j -> j
      | Error e -> raise (Jsont.Error e)
    in
    let encoded_str = json_to_string encoded in
    Printf.printf "%s\n" encoded_str
  with Jsont.Error e ->
    Printf.printf "ERROR: %s\n" (Jsont.Error.to_string e)

let () =
  match Array.to_list Sys.argv with
  | _ :: "parse" :: pointer :: _ ->
    test_parse pointer
  | _ :: "roundtrip" :: pointer :: _ ->
    test_roundtrip pointer
  | _ :: "eval" :: json_path :: pointer :: _ ->
    test_eval json_path pointer
  | _ :: "escape" :: token :: _ ->
    test_escape token
  | _ :: "unescape" :: token :: _ ->
    test_unescape token
  | _ :: "uri-fragment" :: pointer :: _ ->
    test_uri_fragment pointer
  | _ :: "add" :: json :: pointer :: value :: _ ->
    test_add json pointer value
  | _ :: "remove" :: json :: pointer :: _ ->
    test_remove json pointer
  | _ :: "replace" :: json :: pointer :: value :: _ ->
    test_replace json pointer value
  | _ :: "move" :: json :: from :: path :: _ ->
    test_move json from path
  | _ :: "copy" :: json :: from :: path :: _ ->
    test_copy json from path
  | _ :: "test" :: json :: pointer :: expected :: _ ->
    test_test json pointer expected
  | _ :: "has" :: json :: pointer :: _ ->
    test_has json pointer
  | _ :: "jmap-parse" :: pointer :: _ ->
    test_jmap_parse pointer
  | _ :: "jmap-eval" :: json :: pointer :: _ ->
    test_jmap_eval json pointer
  | _ :: "jmap-eval-file" :: json_path :: pointer :: _ ->
    test_jmap_eval_file json_path pointer
  | _ :: "jmap-path-strings" :: json :: pointer :: _ ->
    test_jmap_path_strings json pointer
  | _ :: "jmap-path-ints" :: json :: pointer :: _ ->
    test_jmap_path_ints json pointer
  | _ :: "jmap-path-single" :: json :: pointer :: _ ->
    test_jmap_path_single json pointer
  | _ :: "jmap-path-absent" :: json :: pointer :: default :: _ ->
    test_jmap_path_absent json pointer default
  (* Index functions *)
  | _ :: "mem" :: name :: _ ->
    test_mem name
  | _ :: "nth" :: n :: _ ->
    test_nth (int_of_string n)
  | _ :: "equal-index" :: idx1 :: idx2 :: _ ->
    test_equal_index idx1 idx2
  | _ :: "compare-index" :: idx1 :: idx2 :: _ ->
    test_compare_index idx1 idx2
  (* Pointer constructors *)
  | _ :: "root" :: _ ->
    test_root ()
  | _ :: "is-root" :: pointer :: _ ->
    test_is_root pointer
  | _ :: "make" :: indices :: _ ->
    test_make indices
  | _ :: "append-index" :: base :: index :: _ ->
    test_append_index base index
  | _ :: "at-end" :: pointer :: _ ->
    test_at_end pointer
  | _ :: "concat" :: p1 :: p2 :: _ ->
    test_concat p1 p2
  | _ :: "parent" :: pointer :: _ ->
    test_parent pointer
  | _ :: "last" :: pointer :: _ ->
    test_last pointer
  | _ :: "indices" :: pointer :: _ ->
    test_indices pointer
  (* Coercion *)
  | _ :: "to-nav" :: pointer :: _ ->
    test_to_nav pointer
  | _ :: "to-nav-exn" :: pointer :: _ ->
    test_to_nav_exn pointer
  (* Parsing variants *)
  | _ :: "of-string-kind" :: pointer :: _ ->
    test_of_string_kind pointer
  | _ :: "of-string-result" :: pointer :: _ ->
    test_of_string_result pointer
  | _ :: "of-uri-fragment-nav" :: frag :: _ ->
    test_of_uri_fragment_nav frag
  | _ :: "of-uri-fragment-result" :: frag :: _ ->
    test_of_uri_fragment_result frag
  (* Pretty printing *)
  | _ :: "pp" :: pointer :: _ ->
    test_pp pointer
  | _ :: "pp-verbose" :: pointer :: _ ->
    test_pp_verbose pointer
  (* Comparison *)
  | _ :: "equal" :: p1 :: p2 :: _ ->
    test_equal p1 p2
  | _ :: "compare" :: p1 :: p2 :: _ ->
    test_compare p1 p2
  (* Path conversion *)
  | _ :: "of-path" :: _ ->
    test_of_path ()
  | _ :: "to-path" :: pointer :: _ ->
    test_to_path pointer
  (* Evaluation *)
  | _ :: "get-result" :: json :: pointer :: _ ->
    test_get_result json pointer
  | _ :: "set" :: json :: pointer :: value :: _ ->
    test_set json pointer value
  (* Jsont codecs *)
  | _ :: "jsont-codec" :: pointer :: _ ->
    test_jsont_codec pointer
  | _ :: "jsont-kind" :: pointer :: _ ->
    test_jsont_kind pointer
  | _ :: "jsont-nav" :: pointer :: _ ->
    test_jsont_nav pointer
  | _ :: "jsont-uri-fragment" :: pointer :: _ ->
    test_jsont_uri_fragment pointer
  (* Query combinators *)
  | _ :: "query-path" :: json :: pointer :: _ ->
    test_query_path json pointer
  | _ :: "query-path-absent" :: json :: pointer :: default :: _ ->
    test_query_path_absent json pointer default
  | _ :: "set-path" :: json :: pointer :: value :: _ ->
    test_set_path json pointer value
  | _ :: "update-path" :: json :: pointer :: _ ->
    test_update_path json pointer
  | _ :: "delete-path" :: json :: pointer :: _ ->
    test_delete_path json pointer
  | _ :: "delete-path-absent" :: json :: pointer :: _ ->
    test_delete_path_absent json pointer
  (* JMAP extras *)
  | _ :: "jmap-of-string-result" :: pointer :: _ ->
    test_jmap_of_string_result pointer
  | _ :: "jmap-pp" :: pointer :: _ ->
    test_jmap_pp pointer
  | _ :: "jmap-eval-result" :: json :: pointer :: _ ->
    test_jmap_eval_result json pointer
  | _ :: "jmap-find" :: json :: pointer :: _ ->
    test_jmap_find json pointer
  | _ :: "jmap-jsont" :: pointer :: _ ->
    test_jmap_jsont pointer
  | _ ->
    Printf.printf "Usage:\n";
    Printf.printf "  test_pointer parse <pointer>\n";
    Printf.printf "  test_pointer roundtrip <pointer>\n";
    Printf.printf "  test_pointer eval <json-file> <pointer>\n";
    Printf.printf "  test_pointer escape <token>\n";
    Printf.printf "  test_pointer unescape <token>\n";
    Printf.printf "  test_pointer uri-fragment <pointer>\n";
    Printf.printf "  test_pointer add <json> <pointer> <value>\n";
    Printf.printf "  test_pointer remove <json> <pointer>\n";
    Printf.printf "  test_pointer replace <json> <pointer> <value>\n";
    Printf.printf "  test_pointer move <json> <from> <path>\n";
    Printf.printf "  test_pointer copy <json> <from> <path>\n";
    Printf.printf "  test_pointer test <json> <pointer> <expected>\n";
    Printf.printf "  test_pointer has <json> <pointer>\n";
    Printf.printf "  test_pointer jmap-parse <pointer>\n";
    Printf.printf "  test_pointer jmap-eval <json> <pointer>\n";
    Printf.printf "  test_pointer jmap-eval-file <json-file> <pointer>\n";
    Printf.printf "  -- Index functions --\n";
    Printf.printf "  test_pointer mem <name>\n";
    Printf.printf "  test_pointer nth <n>\n";
    Printf.printf "  test_pointer equal-index <idx1> <idx2>\n";
    Printf.printf "  test_pointer compare-index <idx1> <idx2>\n";
    Printf.printf "  -- Pointer constructors --\n";
    Printf.printf "  test_pointer root\n";
    Printf.printf "  test_pointer is-root <pointer>\n";
    Printf.printf "  test_pointer make <indices>\n";
    Printf.printf "  test_pointer append-index <base> <index>\n";
    Printf.printf "  test_pointer at-end <pointer>\n";
    Printf.printf "  test_pointer concat <p1> <p2>\n";
    Printf.printf "  test_pointer parent <pointer>\n";
    Printf.printf "  test_pointer last <pointer>\n";
    Printf.printf "  test_pointer indices <pointer>\n";
    Printf.printf "  -- Coercion --\n";
    Printf.printf "  test_pointer to-nav <pointer>\n";
    Printf.printf "  test_pointer to-nav-exn <pointer>\n";
    Printf.printf "  -- Parsing variants --\n";
    Printf.printf "  test_pointer of-string-kind <pointer>\n";
    Printf.printf "  test_pointer of-string-result <pointer>\n";
    Printf.printf "  test_pointer of-uri-fragment-nav <frag>\n";
    Printf.printf "  test_pointer of-uri-fragment-result <frag>\n";
    Printf.printf "  -- Pretty printing --\n";
    Printf.printf "  test_pointer pp <pointer>\n";
    Printf.printf "  test_pointer pp-verbose <pointer>\n";
    Printf.printf "  -- Comparison --\n";
    Printf.printf "  test_pointer equal <p1> <p2>\n";
    Printf.printf "  test_pointer compare <p1> <p2>\n";
    Printf.printf "  -- Path conversion --\n";
    Printf.printf "  test_pointer of-path\n";
    Printf.printf "  test_pointer to-path <pointer>\n";
    Printf.printf "  -- Evaluation --\n";
    Printf.printf "  test_pointer get-result <json> <pointer>\n";
    Printf.printf "  test_pointer set <json> <pointer> <value>\n";
    Printf.printf "  -- Jsont codecs --\n";
    Printf.printf "  test_pointer jsont-codec <pointer>\n";
    Printf.printf "  test_pointer jsont-kind <pointer>\n";
    Printf.printf "  test_pointer jsont-nav <pointer>\n";
    Printf.printf "  test_pointer jsont-uri-fragment <pointer>\n";
    Printf.printf "  -- Query combinators --\n";
    Printf.printf "  test_pointer query-path <json> <pointer>\n";
    Printf.printf "  test_pointer query-path-absent <json> <pointer> <default>\n";
    Printf.printf "  test_pointer set-path <json> <pointer> <value>\n";
    Printf.printf "  test_pointer update-path <json> <pointer>\n";
    Printf.printf "  test_pointer delete-path <json> <pointer>\n";
    Printf.printf "  test_pointer delete-path-absent <json> <pointer>\n";
    Printf.printf "  -- JMAP extras --\n";
    Printf.printf "  test_pointer jmap-of-string-result <pointer>\n";
    Printf.printf "  test_pointer jmap-pp <pointer>\n";
    Printf.printf "  test_pointer jmap-eval-result <json> <pointer>\n";
    Printf.printf "  test_pointer jmap-find <json> <pointer>\n";
    Printf.printf "  test_pointer jmap-jsont <pointer>\n";
    exit 1