162 lines
5.5 KiB
OCaml
162 lines
5.5 KiB
OCaml
open Duration
|
|
|
|
let test_f f s factor upper upperv () =
|
|
List.iter (fun v ->
|
|
Alcotest.(check int64 (s ^ " works" ^ string_of_int v)
|
|
Int64.(mul (of_int v) factor)
|
|
(f v)))
|
|
[ 0 ; 1 ; 100 ] ;
|
|
Alcotest.(check_raises (s ^ " raises") (Invalid_argument "negative")
|
|
(fun () -> ignore (f (-1)))) ;
|
|
Alcotest.(check int64 ("upper bound " ^ s ^ " good")
|
|
upperv (f upper)) ;
|
|
Alcotest.(check_raises ("upper bound + 1 " ^ s ^ " raises")
|
|
(Invalid_argument "out of range")
|
|
(fun () -> ignore (f (succ upper))))
|
|
|
|
let test_g g s factor upper upperv () =
|
|
List.iter (fun (e, v) ->
|
|
Alcotest.(check int (s ^ " works " ^ Int64.to_string v)
|
|
e (g v)))
|
|
[ 0, 0L ; 1, factor ] ;
|
|
Alcotest.(check int ("upper bound " ^ s ^ " good")
|
|
upper (g upperv))
|
|
|
|
let test_inv f g s upper () =
|
|
Alcotest.(check int ("inverse 0 " ^ s) 0 (g (f 0))) ;
|
|
Alcotest.(check int ("inverse 1 " ^ s) 1 (g (f 1))) ;
|
|
Alcotest.(check int ("inverse 10 " ^ s) 10 (g (f 10))) ;
|
|
Alcotest.(check int "inverse upper" upper (g (f upper)))
|
|
|
|
let test_one f g s fa m mv = [
|
|
"of" ^ s ^ " is good", `Quick, test_f f ("of" ^ s) fa m mv ;
|
|
"to" ^ s ^ " is good", `Quick, test_g g ("to" ^ s) fa m mv ;
|
|
"inverse of/to" ^ s, `Quick, test_inv f g s m
|
|
]
|
|
|
|
let test_f_64 f s factor upper upperv () =
|
|
List.iter (fun v ->
|
|
Alcotest.(check int64 (s ^ " works" ^ Int64.to_string v)
|
|
Int64.(mul v factor)
|
|
(f v)))
|
|
[ 0L ; 1L ; 100L ] ;
|
|
Alcotest.(check_raises (s ^ " raises") (Invalid_argument "negative")
|
|
(fun () -> ignore (f (-1L)))) ;
|
|
Alcotest.(check int64 ("upper bound " ^ s ^ " good")
|
|
upperv (f upper)) ;
|
|
Alcotest.(check_raises ("upper bound + 1 " ^ s ^ " raises")
|
|
(Invalid_argument "out of range")
|
|
(fun () -> ignore (f (Int64.succ upper))))
|
|
|
|
let test_g_64 g s factor upper upperv () =
|
|
List.iter (fun (e, v) ->
|
|
Alcotest.(check int64 (s ^ " works " ^ Int64.to_string v)
|
|
e (g v)))
|
|
[ 0L, 0L ; 1L, factor ] ;
|
|
Alcotest.(check int64 ("upper bound " ^ s ^ " good")
|
|
upper (g upperv))
|
|
|
|
let test_inv_64 f g s upper () =
|
|
Alcotest.(check int64 ("inverse 0 " ^ s) 0L (g (f 0L))) ;
|
|
Alcotest.(check int64 ("inverse 1 " ^ s) 1L (g (f 1L))) ;
|
|
Alcotest.(check int64 ("inverse 10 " ^ s) 10L (g (f 10L))) ;
|
|
Alcotest.(check int64 "inverse upper" upper (g (f upper)))
|
|
|
|
let test_one_64 f g s fa m mv = [
|
|
"of" ^ s ^ " is good", `Quick, test_f_64 f ("of" ^ s) fa m mv ;
|
|
"to" ^ s ^ " is good", `Quick, test_g_64 g ("to" ^ s) fa m mv ;
|
|
"inverse of/to" ^ s, `Quick, test_inv_64 f g s m
|
|
]
|
|
|
|
let test_of_us =
|
|
let a, b = 18446744073709549L, 0xFFFFFFFFFFFFF5C8L in
|
|
test_one_64 of_us_64 to_us_64 "_us" 1_000L a b @
|
|
if Sys.word_size = 64 then
|
|
test_one of_us to_us "_us" 1_000L (Int64.to_int a) b
|
|
else
|
|
[]
|
|
|
|
let test_of_ms =
|
|
let a, b = 18446744073709L, 0xFFFFFFFFFFF79540L in
|
|
test_one_64 of_ms_64 to_ms_64 "_ms" 1_000_000L a b @
|
|
if Sys.word_size = 64 then
|
|
test_one of_ms to_ms "_ms" 1_000_000L (Int64.to_int a) b
|
|
else
|
|
[]
|
|
|
|
let test_of_sec =
|
|
let a, b = 18446744073L, 0xFFFFFFFFD5B51A00L in
|
|
test_one_64 of_sec_64 to_sec_64 "_sec" 1_000_000_000L a b @
|
|
if Sys.word_size = 64 then
|
|
test_one of_sec to_sec "_sec" 1_000_000_000L (Int64.to_int a) b
|
|
else
|
|
[]
|
|
|
|
let test_of_min =
|
|
test_one of_min to_min "_min" 60_000_000_000L 307445734 0xFFFFFFF826C11000L
|
|
|
|
let test_of_hour =
|
|
test_one of_hour to_hour "_hour" 3600_000_000_000L 5124095 0xFFFFFE1D2D476000L
|
|
|
|
let test_of_day =
|
|
let d_in_ns = Int64.mul 24L 3600_000_000_000L in
|
|
test_one of_day to_day "_day" d_in_ns 213503 0xFFFFB2CECCB10000L
|
|
|
|
let test_of_year =
|
|
let y_in_ns = Int64.mul 8766L 3600_000_000_000L in
|
|
test_one of_year to_year "_year" y_in_ns 584 0xFFC33A7AFAE60000L
|
|
|
|
|
|
let test_of_f () =
|
|
List.iter (fun v ->
|
|
Alcotest.(check int64 ("of_f works " ^ string_of_float v)
|
|
(Int64.of_float (v *. 1_000_000_000.))
|
|
(of_f v)))
|
|
[ 0. ; 1. ; 2. ; 0.000000001 ] ;
|
|
Alcotest.(check_raises ("of_f raises") (Invalid_argument "negative")
|
|
(fun () -> ignore (of_f (-1.)))) ;
|
|
Alcotest.(check int64 ("upper bound of_f good")
|
|
0xFFFFFFFFFFFFF596L (of_f 18446744073.709549)) ;
|
|
Alcotest.(check_raises ("upper bound + 1 of_f raises")
|
|
(Invalid_argument "out of range")
|
|
(fun () -> ignore (of_f 18446744073.709551)))
|
|
|
|
let test_to_f () =
|
|
List.iter (fun (e, v) ->
|
|
Alcotest.(check (float 0.) ("to_f works " ^ Int64.to_string v)
|
|
e (to_f v)))
|
|
[ 0., 0L ; 1., 1000000000L ; 2., 2000000000L ; 0.000000001, 1L ] ;
|
|
Alcotest.(check (float 0.) ("upper bound to_f good")
|
|
18446744073.709549 (to_f 0xFFFFFFFFFFFFF596L))
|
|
|
|
let test_inv_f () =
|
|
Alcotest.(check (float 0.) "inverse 0 to/of_f" 0. (to_f (of_f 0.))) ;
|
|
Alcotest.(check (float 0.) "inverse 1 to/of_f" 1. (to_f (of_f 1.))) ;
|
|
Alcotest.(check (float 0.) "inverse 10 to/of_f" 10. (to_f (of_f 10.))) ;
|
|
Alcotest.(check (float 0.) "inverse 3.5 to/of_f" 3.5 (to_f (of_f 3.5))) ;
|
|
Alcotest.(check (float 0.) "inverse upper" 18446744073.709549 (to_f (of_f 18446744073.709549)))
|
|
|
|
let test_float = [
|
|
"of_f is good", `Quick, test_of_f ;
|
|
"to_f is good", `Quick, test_to_f ;
|
|
"inverse of/to_f", `Quick, test_inv_f
|
|
]
|
|
|
|
let dur_tests =
|
|
List.flatten [
|
|
test_of_us ;
|
|
test_of_ms ;
|
|
test_of_sec ;
|
|
test_of_min ;
|
|
test_of_hour ;
|
|
test_of_day ;
|
|
test_of_year ;
|
|
test_float
|
|
]
|
|
|
|
|
|
let tests = [
|
|
"Duration", dur_tests
|
|
]
|
|
|
|
let () = Alcotest.run "Duration tests" tests
|