Fold_lib: move to alcotest

dune-project

@@ -31,6 +31,7 @@
  (synopsis "A library for fold functions")
  (description "A library for fold functions")
  (depends
+  (alcotest :with-test)
   (bisect_ppx :with-test)
   (core_kernel (and (>= v0.14) (< v0.15)))
   (dune :build)

fold_lib.opam

@@ -9,6 +9,7 @@ license: "MIT"
 homepage: "https://github.com/o1labs/snarky"
 bug-reports: "https://github.com/o1labs/snarky/issues"
 depends: [
+  "alcotest" {with-test}
   "bisect_ppx" {with-test}
   "core_kernel" {>= "v0.14" & < "v0.15"}
   "dune" {>= "3.0" & build}

fold_lib/dune

@@ -2,8 +2,6 @@
  (name fold_lib)
  (public_name fold_lib)
  (library_flags -linkall)
- (inline_tests
-  (flags -verbose -show-counts))
  (libraries core_kernel)
  (preprocess
   (pps ppx_jane ppx_deriving.eq bisect_ppx -- --conditional))

fold_lib/fold.ml

@@ -49,10 +49,6 @@ let of_list (xs : 'a list) : 'a t =
 let of_array (xs : 'a array) : 'a t =
   { fold = (fun ~init ~f -> Array.fold xs ~init ~f) }
 
-let%test_unit "fold-to-list" =
-  Quickcheck.test (Quickcheck.Generator.list Int.quickcheck_generator)
-    ~f:(fun xs -> assert ([%equal: Int.t list] xs (to_list (of_list xs))))
-
 let sexp_of_t f t = List.sexp_of_t f (to_list t)
 
 let compose (t1 : 'a t) (t2 : 'a t) : 'a t =
@@ -85,23 +81,6 @@ let group3 ~default (t : 'a t) : ('a * 'a * 'a) t =
             assert false )
   }
 
-let%test_unit "group3" =
-  Quickcheck.test (Quickcheck.Generator.list Int.quickcheck_generator)
-    ~f:(fun xs ->
-      let default = 0 in
-      let n = List.length xs in
-      let tuples = to_list (group3 ~default (of_list xs)) in
-      let k = List.length tuples in
-      let r = n mod 3 in
-      (let padded =
-         xs @ if r = 0 then [] else List.init (3 - r) ~f:(fun _ -> default)
-       in
-       let concated =
-         List.concat_map ~f:(fun (b1, b2, b3) -> [ b1; b2; b3 ]) tuples
-       in
-       [%test_eq: int list] padded concated ) ;
-      assert ((n + 2) / 3 = k) )
-
 let string_bits s =
   let ith_bit_int n i = (n lsr i) land 1 = 1 in
   { fold =

fold_lib/test/dune

@@ -0,0 +1,6 @@
+(test
+ (name test_fold_lib)
+ (package fold_lib)
+ (libraries alcotest core_kernel fold_lib)
+ (preprocess
+  (pps ppx_jane)))

fold_lib/test/test_fold_lib.ml

@@ -0,0 +1,35 @@
+open Core_kernel
+open Alcotest
+open Fold_lib
+
+let int_list = list int
+
+let test_fold_to_list () =
+  Quickcheck.test (Quickcheck.Generator.list Int.quickcheck_generator)
+    ~f:(fun xs ->
+      let result = Fold.to_list (Fold.of_list xs) in
+      Alcotest.(check int_list) "fold-to-list" xs result )
+
+let test_group3 () =
+  Quickcheck.test (Quickcheck.Generator.list Int.quickcheck_generator)
+    ~f:(fun xs ->
+      let default = 0 in
+      let n = List.length xs in
+      let tuples = Fold.to_list (Fold.group3 ~default (Fold.of_list xs)) in
+      let k = List.length tuples in
+      let r = n mod 3 in
+      let padded =
+        xs @ if r = 0 then [] else List.init (3 - r) ~f:(fun _ -> default)
+      in
+      let concated =
+        List.concat_map ~f:(fun (b1, b2, b3) -> [ b1; b2; b3 ]) tuples
+      in
+      Alcotest.(check int_list) "group3 padded equals concated" padded concated ;
+      Alcotest.(check int) "group3 length" ((n + 2) / 3) k )
+
+let fold_tests =
+  [ ("fold-to-list", `Quick, test_fold_to_list)
+  ; ("group3", `Quick, test_group3)
+  ]
+
+let () = Alcotest.run "Fold_lib" [ ("fold", fold_tests) ]