Source file unit_tests.ml

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
open! Core

let parse_and_print sexp_of grammar tokens =
  Sequence.take (Common.parse grammar tokens) 5
  |> Sequence.iter ~f:(fun r -> print_s (sexp_of r))
;;

let%expect_test "Return" =
  parse_and_print [%sexp_of: int] (Return 42) [];
  [%expect {| 42 |}]
;;

let%expect_test "Terminal - matching" =
  parse_and_print [%sexp_of: unit] (Terminal A) [ A ];
  [%expect {| () |}]
;;

let%expect_test "Terminal - non-matching" =
  parse_and_print [%sexp_of: unit] (Terminal A) [ B ];
  [%expect {| |}]
;;

let%expect_test "Map" =
  parse_and_print [%sexp_of: int] (Map (Return 10, ( * ) 2)) [];
  [%expect {| 20 |}]
;;

let%expect_test "Capture" =
  parse_and_print
    [%sexp_of: string]
    (Capture (Concat_unit [ Terminal A; Terminal B ], String.sub))
    [ A; B ];
  [%expect {| ab |}]
;;

let%expect_test "Capture_also" =
  parse_and_print
    [%sexp_of: string * int]
    (Capture_also
       ( Map (Concat_unit [ Terminal A; Terminal B ], fun () -> 99)
       , fun input ~pos ~len a -> String.sub input ~pos ~len, a ))
    [ A; B ];
  [%expect {| (ab 99) |}]
;;

let%expect_test "Union - first branch" =
  parse_and_print [%sexp_of: unit] (Union [ Terminal A; Terminal B ]) [ A ];
  [%expect {| () |}]
;;

let%expect_test "Union - second branch" =
  parse_and_print [%sexp_of: unit] (Union [ Terminal A; Terminal B ]) [ B ];
  [%expect {| () |}]
;;

let%expect_test "Union - ambiguous" =
  parse_and_print [%sexp_of: unit] (Union [ Terminal A; Terminal A ]) [ A ];
  [%expect
    {|
    ()
    ()
    |}]
;;

let%expect_test "Append" =
  parse_and_print [%sexp_of: int] (Append (Return 1, Return 2, ( + ))) [];
  [%expect {| 3 |}]
;;

let%expect_test "Append with terminals" =
  parse_and_print
    [%sexp_of: string]
    (Append (Terminal A, Terminal B, fun () () -> "matched"))
    [ A; B ];
  [%expect {| matched |}]
;;

let%expect_test "Concat_unit" =
  parse_and_print [%sexp_of: unit] (Concat_unit [ Terminal A; Terminal B ]) [ A; B ];
  [%expect {| () |}]
;;

let%expect_test "Star - empty" =
  parse_and_print
    [%sexp_of: unit list]
    (Star (Terminal A, { init = []; f = (fun acc () -> () :: acc) }))
    [];
  [%expect {| () |}]
;;

let%expect_test "Star - one iteration" =
  parse_and_print
    [%sexp_of: unit list]
    (Star (Terminal A, { init = []; f = (fun acc () -> () :: acc) }))
    [ A ];
  [%expect {| (()) |}]
;;

let%expect_test "Star - multiple iterations" =
  parse_and_print
    [%sexp_of: int]
    (Star (Terminal A, { init = 0; f = (fun acc () -> acc + 1) }))
    [ A; A; A ];
  [%expect {| 3 |}]
;;

let%expect_test "Star_unit - empty" =
  parse_and_print [%sexp_of: unit] (Star_unit (Terminal A)) [];
  [%expect {| () |}]
;;

let%expect_test "Star_unit - multiple" =
  parse_and_print [%sexp_of: unit] (Star_unit (Terminal A)) [ A; A ];
  [%expect {| () |}]
;;