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