unikernel/duniverse/ocaml-re/lib_test/expect/import.ml

@@ -0,0 +1,85 @@
+module Re = Re_private.Re
+include Re_private.Import
+module Fmt = Re_private.Fmt
+module Dyn = Re_private.Dyn
+
+let printf = Printf.printf
+
+let t re s =
+  let group = Re.exec_opt (Re.compile re) s in
+  Format.printf "%a@." (Fmt.opt Re.Group.pp) group
+;;
+
+let re_whitespace = Re.Pcre.regexp "[\t ]+"
+let re_eol = Re.compile Re.eol
+let re_bow = Re.compile Re.bow
+let re_eow = Re.compile Re.eow
+let strings = Format.printf "[%a]@." Fmt.(list ~pp_sep:(Fmt.lit "; ") Fmt.quoted_string)
+let re_empty = Re.Posix.compile_pat ""
+
+let invalid_argument f =
+  match f () with
+  | s -> ignore s
+  | exception Invalid_argument s -> Format.printf "Invalid_argument %S@." s
+;;
+
+let exec_partial_detailed ?pos re s =
+  let re = Re.compile re in
+  let res = Re.exec_partial_detailed ?pos re s in
+  match res with
+  | `Mismatch -> Format.printf "`Mismatch@."
+  | `Partial position -> Format.printf "`Partial %d@." position
+  | `Full groups ->
+    Re.Group.all_offset groups
+    |> Array.to_list
+    |> List.map ~f:(fun (a, b) ->
+      Printf.sprintf
+        "%d,%d,%s"
+        a
+        b
+        (match String.sub s a (b - a) with
+         | exception Invalid_argument _ -> "<No match>"
+         | s -> Printf.sprintf "%S" s))
+    |> String.concat ";"
+    |> Format.printf "`Full [|%s|]@."
+;;
+
+let or_not_found f fmt v =
+  match v () with
+  | exception Not_found -> Format.fprintf fmt "Not_found"
+  | s -> f fmt s
+;;
+
+let array f fmt v =
+  Format.fprintf fmt "[| %a |]" (Fmt.list ~pp_sep:(Fmt.lit "; ") f) (Array.to_list v)
+;;
+
+let offset fmt (x, y) = Format.fprintf fmt "(%d, %d)" x y
+
+let test_re ?pos ?len r s =
+  let offsets () = Re.Group.all_offset (Re.exec ?pos ?len (Re.compile r) s) in
+  Format.printf "%a@." (or_not_found (array offset)) offsets
+;;
+
+let rec sexp_of_dyn (t : Re_private.Dyn.t) : Base.Sexp.t =
+  match t with
+  | Int i -> Atom (Int.to_string i)
+  | String s -> Atom s
+  | Tuple xs -> List (List.map xs ~f:sexp_of_dyn)
+  | Enum s -> Atom s
+  | List xs -> List (List.map ~f:sexp_of_dyn xs)
+  | Variant (name, []) -> Atom name
+  | Variant (name, xs) ->
+    let xs = List.map xs ~f:sexp_of_dyn in
+    (match xs with
+     | [] -> List []
+     | xs -> List (Atom name :: xs))
+  | Record fields ->
+    List
+      (List.filter_map fields ~f:(fun (name, v) ->
+         match sexp_of_dyn v with
+         | List [] -> None
+         | sexp -> Some (Base.Sexp.List [ Atom name; sexp ])))
+;;
+
+let print_dyn dyn = sexp_of_dyn dyn |> Base.Sexp.to_string_hum |> print_endline