Source file test_iterator.ml

open! Base
open Base_quickcheck.Export
open Expect_test_helpers_base
module Iterator = Trie.Iterator

let test iter_m ~f:seq_of_string =
  require_does_not_raise [%here] (fun () ->
    Base_quickcheck.Test.run_exn
      ~config:{ Base_quickcheck.Test.default_config with test_count = 100 }
      (module struct
        type t = string [@@deriving quickcheck, sexp_of]
      end)
      ~f:(fun string ->
        let seq = seq_of_string string in
        let round_trip_string =
          let rec loop iter acc =
            if Iterator.is_finished iter_m iter seq
            then String.of_char_list (List.rev acc)
            else
              loop
                (Iterator.next_exn iter_m iter seq)
                (Iterator.get_exn iter_m iter seq :: acc)
          in
          loop (Iterator.start iter_m seq) []
        in
        require_equal [%here] (module String) string round_trip_string))
;;

let%test_module _ =
  (module (
             struct
               module type Impl0 = Iterator.Impl0
               module type Impl1 = Iterator.Impl1
               module type Listable0 = Iterator.Listable0
               module type Listable1 = Iterator.Listable1
               module type S0 = Iterator.S0
               module type S1 = Iterator.S1

               type ('iter, 'seq, 'elt, 'idx) t = ('iter, 'seq, 'elt, 'idx) Iterator.t

               (** accessors are uninteresting *)

               let start = Iterator.start
               let is_finished = Iterator.is_finished
               let get_exn = Iterator.get_exn
               let next_exn = Iterator.next_exn

               (** type conversion is uninteresting **)
               module Monomorphic = Iterator.Monomorphic

               module Make1 = Iterator.Make1

               let%expect_test "Make1" =
                 let module M =
                   Make1 (struct
                     type 'a seq = 'a array
                     type 'a elt = 'a
                     type _ t = int

                     let start _ = 0
                     let is_finished pos array = pos >= Array.length array
                     let get_exn pos array = array.(pos)
                     let next_exn pos _ = pos + 1
                   end)
                 in
                 test M.iterator ~f:String.to_array;
                 [%expect {| |}]
               ;;

               module Make0 = Iterator.Make0

               let%expect_test "Make0" =
                 let module M =
                   Make0 (struct
                     type seq = bytes
                     type elt = char
                     type t = int

                     let start _ = 0
                     let is_finished pos array = pos >= Bytes.length array
                     let get_exn pos array = Bytes.get array pos
                     let next_exn pos _ = pos + 1
                   end)
                 in
                 test M.iterator ~f:Bytes.of_string;
                 [%expect {| |}]
               ;;

               module Of_listable1 = Iterator.Of_listable1

               let%expect_test "Of_listable1" =
                 let module M =
                   Of_listable1 (struct
                     include Array

                     type 'a elt = 'a
                   end)
                 in
                 test M.iterator ~f:String.to_array;
                 [%expect {| |}]
               ;;

               module Of_listable0 = Iterator.Of_listable0

               let%expect_test "Of_listable0" =
                 let module M =
                   Of_listable0 (struct
                     include Bytes

                     type elt = char
                   end)
                 in
                 test M.iterator ~f:Bytes.of_string;
                 [%expect {| |}]
               ;;

               module Of_list = Iterator.Of_list

               let%expect_test "Of_list" =
                 test Of_list.iterator ~f:String.to_list;
                 [%expect {| |}]
               ;;

               module Of_string = Iterator.Of_string

               let%expect_test "Of_string" =
                 test Of_string.iterator ~f:Fn.id;
                 [%expect {| |}]
               ;;
             end :
               module type of Iterator))
;;