2817

Committed 23 Oct 2024 05:55PM UTC coverage: 33.411% (-27.7%) from 61.089%

Build # 2817

Build Type

push

buildkite

Committed by

web-flow

Commit Message

Merge pull request #16270 from MinaProtocol/dkijania/fix_promotion_job

Fix verify promoted docker check

Run Details

22271 of 66658 relevant lines covered (33.41%)

131054.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

13.33

/src/lib/key_value_database/key_value_database.ml

open Core_kernel

module Monad = struct
  module type S = sig
    type 'a t

    include Monad.S with type 'a t := 'a t

    module Result : sig
      val lift : 'value t -> ('value, 'err) Result.t t

      type nonrec ('value, 'err) t = ('value, 'err) Result.t t

      include Monad.S2 with type ('value, 'err) t := ('value, 'err) t
    end

    module Option : sig
      type nonrec 'a t = 'a option t

      include Monad.S with type 'a t := 'a t
    end
  end

  module Ident = struct
    include Monad.Ident

    module Result = struct
      let lift = Result.return

      include Result
    end

    module Option = Option
  end
end

module Intf = struct
  module type S = sig
    type t

    type key

    type value

    type config

    module M : Monad.S

    val create : config -> t

    val close : t -> unit

    val get : t -> key:key -> value option M.t

    val get_batch : t -> keys:key list -> value option list M.t

    val set : t -> key:key -> data:value -> unit M.t

    val remove : t -> key:key -> unit M.t

    val set_batch :
      t -> ?remove_keys:key list -> update_pairs:(key * value) list -> unit M.t

    val to_alist : t -> (key * value) list M.t
  end

  module type Ident = S with module M := Monad.Ident

  module type Mock = sig
    include Ident

    val random_key : t -> key option

    val to_sexp :
      t -> key_sexp:(key -> Sexp.t) -> value_sexp:(value -> Sexp.t) -> Sexp.t
  end
end

module Make_mock
    (Key : Hashable.S) (Value : sig
      type t
    end) :
  Intf.Mock
    with type t = Value.t Key.Table.t
     and type key := Key.t
     and type value := Value.t
     and type config := unit = struct
  type t = Value.t Key.Table.t

  let to_sexp t ~key_sexp ~value_sexp =
    Key.Table.to_alist t
    |> List.map ~f:(fun (key, value) ->
           [%sexp_of: Sexp.t * Sexp.t] (key_sexp key, value_sexp value) )
    |> [%sexp_of: Sexp.t list]

  let create _ = Key.Table.create ()

  let get t ~key = Key.Table.find t key

  let get_batch t ~keys = List.map keys ~f:(Key.Table.find t)

  let set = Key.Table.set

  let remove t ~key = Key.Table.remove t key

  let close _ = ()

  let random_key t =
    let keys = Key.Table.keys t in
    List.random_element keys

  let set_batch t ?(remove_keys = []) ~update_pairs =
    List.iter update_pairs ~f:(fun (key, data) -> set t ~key ~data) ;
    List.iter remove_keys ~f:(fun key -> remove t ~key)

  let to_alist = Key.Table.to_alist
end

1	open Core_kernel	8✔
2
3	module Monad = struct
4	module type S = sig
5	type 'a t
6
7	include Monad.S with type 'a t := 'a t
8
9	module Result : sig
10	val lift : 'value t -> ('value, 'err) Result.t t
11
12	type nonrec ('value, 'err) t = ('value, 'err) Result.t t
13
14	include Monad.S2 with type ('value, 'err) t := ('value, 'err) t
15	end
16
17	module Option : sig
18	type nonrec 'a t = 'a option t
19
20	include Monad.S with type 'a t := 'a t
21	end
22	end
23
24	module Ident = struct
25	include Monad.Ident
26
27	module Result = struct
28	let lift = Result.return
29
30	include Result
31	end
32
33	module Option = Option
34	end
35	end
36
37	module Intf = struct
38	module type S = sig
39	type t
40
41	type key
42
43	type value
44
45	type config
46
47	module M : Monad.S
48
49	val create : config -> t
50
51	val close : t -> unit
52
53	val get : t -> key:key -> value option M.t
54
55	val get_batch : t -> keys:key list -> value option list M.t
56
57	val set : t -> key:key -> data:value -> unit M.t
58
59	val remove : t -> key:key -> unit M.t
60
61	val set_batch :
62	t -> ?remove_keys:key list -> update_pairs:(key * value) list -> unit M.t
63
64	val to_alist : t -> (key * value) list M.t
65	end
66
67	module type Ident = S with module M := Monad.Ident
68
69	module type Mock = sig
70	include Ident
71
72	val random_key : t -> key option
73
74	val to_sexp :
75	t -> key_sexp:(key -> Sexp.t) -> value_sexp:(value -> Sexp.t) -> Sexp.t
76	end
77	end
78
79	module Make_mock
80	(Key : Hashable.S) (Value : sig
81	type t
82	end) :
83	Intf.Mock
84	with type t = Value.t Key.Table.t
85	and type key := Key.t
86	and type value := Value.t
87	and type config := unit = struct
88	type t = Value.t Key.Table.t
89
90	let to_sexp t ~key_sexp ~value_sexp =
91	Key.Table.to_alist t	×
92	\|> List.map ~f:(fun (key, value) ->	×
93	[%sexp_of: Sexp.t * Sexp.t] (key_sexp key, value_sexp value) )	×
94	\|> [%sexp_of: Sexp.t list]
95
96	let create _ = Key.Table.create ()	×
97
98	let get t ~key = Key.Table.find t key	×
99
100	let get_batch t ~keys = List.map keys ~f:(Key.Table.find t)	×
101
102	let set = Key.Table.set
103
104	let remove t ~key = Key.Table.remove t key	×
105
106	let close _ = ()	×
107
108	let random_key t =
109	let keys = Key.Table.keys t in	×
110	List.random_element keys	×
111
112	let set_batch t ?(remove_keys = []) ~update_pairs =	×
113	List.iter update_pairs ~f:(fun (key, data) -> set t ~key ~data) ;	×
114	List.iter remove_keys ~f:(fun key -> remove t ~key)	×
115
116	let to_alist = Key.Table.to_alist
117	end	16✔

MinaProtocol / mina / 2817

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous