File: test_base_containers_poly.ml

package info (click to toggle)
janest-base 0.17.3-1
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid
  • size: 3,632 kB
  • sloc: ml: 48,653; ansic: 281; javascript: 126; makefile: 14
file content (227 lines) | stat: -rw-r--r-- 6,872 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
open! Import
open Test_container

(* Tests of containers that are polymorphic over their element type. *)

include (Test_S1 (Array) : sig end)
include (Test_S1 (List) : sig end)
include (Test_S1 (Queue) : sig end)

(* Quickcheck-based expect tests *)

let%expect_test "Array" =
  Base_container_tests.test_indexed_container_s1_with_creators
    (module struct
      include Array

      type 'a t = 'a array [@@deriving quickcheck]

      (* [Array.concat] has a slightly different type than S1 expects *)
      let concat array = concat (Array.to_list array)
    end);
  [%expect
    {|
    Container: testing [length]
    Container: testing [is_empty]
    Container: testing [mem]
    Container: testing [iter]
    Container: testing [fold]
    Container: testing [fold_result]
    Container: testing [fold_until]
    Container: testing [exists]
    Container: testing [for_all]
    Container: testing [count]
    Container: testing [sum]
    Container: testing [find]
    Container: testing [find_map]
    Container: testing [to_list]
    Container: testing [to_array]
    Container: testing [min_elt]
    Container: testing [max_elt]
    Container: testing [of_list]
    Container: testing [of_array]
    Container: testing [append]
    Container: testing [concat]
    Container: testing [map]
    Container: testing [filter]
    Container: testing [filter_map]
    Container: testing [concat_map]
    Container: testing [partition_tf]
    Container: testing [partition_map]
    Container: testing [foldi]
    Container: testing [iteri]
    Container: testing [existsi]
    Container: testing [for_alli]
    Container: testing [counti]
    Container: testing [findi]
    Container: testing [find_mapi]
    Container: testing [init]
    Container: testing [mapi]
    Container: testing [filteri]
    Container: testing [filter_mapi]
    Container: testing [concat_mapi]
    |}]
;;

let%expect_test "List" =
  Base_container_tests.test_indexed_container_s1_with_creators
    (module struct
      include List

      type 'a t = 'a list [@@deriving quickcheck]
    end);
  [%expect
    {|
    Container: testing [length]
    Container: testing [is_empty]
    Container: testing [mem]
    Container: testing [iter]
    Container: testing [fold]
    Container: testing [fold_result]
    Container: testing [fold_until]
    Container: testing [exists]
    Container: testing [for_all]
    Container: testing [count]
    Container: testing [sum]
    Container: testing [find]
    Container: testing [find_map]
    Container: testing [to_list]
    Container: testing [to_array]
    Container: testing [min_elt]
    Container: testing [max_elt]
    Container: testing [of_list]
    Container: testing [of_array]
    Container: testing [append]
    Container: testing [concat]
    Container: testing [map]
    Container: testing [filter]
    Container: testing [filter_map]
    Container: testing [concat_map]
    Container: testing [partition_tf]
    Container: testing [partition_map]
    Container: testing [foldi]
    Container: testing [iteri]
    Container: testing [existsi]
    Container: testing [for_alli]
    Container: testing [counti]
    Container: testing [findi]
    Container: testing [find_mapi]
    Container: testing [init]
    Container: testing [mapi]
    Container: testing [filteri]
    Container: testing [filter_mapi]
    Container: testing [concat_mapi]
    |}]
;;

let%expect_test "Set" =
  Base_container_tests.test_container_s0
    (module struct
      open Base_quickcheck

      module Elt = struct
        include Int

        type t = (int[@generator Generator.small_strictly_positive_int])
        [@@deriving compare, equal, quickcheck, sexp_of]
      end

      include Set

      type t = Set.M(Int).t [@@deriving sexp_of]

      let quickcheck_generator = Generator.set_t_m (module Elt) Elt.quickcheck_generator
      let quickcheck_observer = Observer.set_t Elt.quickcheck_observer
      let quickcheck_shrinker = Shrinker.set_t Elt.quickcheck_shrinker
      let min_elt t ~compare:_ = min_elt t
      let max_elt t ~compare:_ = max_elt t

      (* [find] and [find_map] use pre-order traversals (root -> left -> right), while all
         the other traversals are in-order (left -> root -> right). We patch them up here
         to behave like pre-order, while still using [Set.find] and [Set.find_map] for the
         searching so we're actually testing those functions. *)

      let rec find t ~f =
        match Set.find t ~f with
        | None -> None
        | Some elt as some ->
          let lt, _ = Set.split_lt_ge t elt in
          Option.first_some (find lt ~f) some
      ;;

      let rec find_map t ~f =
        match Set.find_map t ~f:(fun elt -> Option.map (f elt) ~f:(fun x -> elt, x)) with
        | None -> None
        | Some (elt, x) ->
          let lt, _ = Set.split_lt_ge t elt in
          Option.first_some (find_map lt ~f) (Some x)
      ;;
    end);
  [%expect
    {|
    Container: testing [length]
    Container: testing [is_empty]
    Container: testing [mem]
    Container: testing [iter]
    Container: testing [fold]
    Container: testing [fold_result]
    Container: testing [fold_until]
    Container: testing [exists]
    Container: testing [for_all]
    Container: testing [count]
    Container: testing [sum]
    Container: testing [find]
    Container: testing [find_map]
    Container: testing [to_list]
    Container: testing [to_array]
    Container: testing [min_elt]
    Container: testing [max_elt]
    |}]
;;

let%expect_test "Queue" =
  Base_container_tests.test_indexed_container_s1
    (module struct
      include Queue
      open Base_quickcheck

      let quickcheck_generator quickcheck_generator_elt =
        [%generator: elt list] |> Generator.map ~f:Queue.of_list
      ;;

      let quickcheck_observer quickcheck_observer_elt =
        [%observer: elt list] |> Observer.unmap ~f:Queue.to_list
      ;;

      let quickcheck_shrinker quickcheck_shrinker_elt =
        [%shrinker: elt list] |> Shrinker.map ~f:Queue.of_list ~f_inverse:Queue.to_list
      ;;
    end);
  [%expect
    {|
    Container: testing [length]
    Container: testing [is_empty]
    Container: testing [mem]
    Container: testing [iter]
    Container: testing [fold]
    Container: testing [fold_result]
    Container: testing [fold_until]
    Container: testing [exists]
    Container: testing [for_all]
    Container: testing [count]
    Container: testing [sum]
    Container: testing [find]
    Container: testing [find_map]
    Container: testing [to_list]
    Container: testing [to_array]
    Container: testing [min_elt]
    Container: testing [max_elt]
    Container: testing [foldi]
    Container: testing [iteri]
    Container: testing [existsi]
    Container: testing [for_alli]
    Container: testing [counti]
    Container: testing [findi]
    Container: testing [find_mapi]
    |}]
;;