interpreter/interpreter_test.ml at master · danfloyd111/interpreter · GitHub

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
(* PAOLINI DANIELE - MAT. 444260 *)

open Interpreter;;
open Assert;;
open Printf;;

let environment = empty_env               (* funzione che identifica l'ambiente vuoto *)
let execute (e:exp) = eval  e environment;; (* helper per la valutazione delle espressioni su ambiente vuoto *)

(* TEST SU INTERI *)

printf "*** Integer test ***\n";;

(* test assegnamento e somma -> risultato atteso : Int(42) *)
let t1() = let e1 = Let("x",EInt(40),Op("+",Ide("x"),EInt(2))) in execute e1 = Int(42);;
run_test "Test1 - assignment and summation \t\t" t1;;

(* test assegnamento e sottrazione -> risultato atteso : Int(42) *)
let t2() = let e1 = Let("x",EInt(44),Op("-",Ide("x"),EInt(2))) in execute e1 = Int(42);;
run_test "Test2 - assignment and subtraction \t\t" t2;;

(* test assegnamento e moltiplicazione -> risultato atteso : Int(42) *)
let t3() = let e1 = Let("x",EInt(21),Op("*",Ide("x"),EInt(2))) in execute e1 = Int(42);;
run_test "Test3 - assignment and multiplication \t\t" t3;;

(* test assegnamento e divisione -> risultato atteso : Int(42) *)
let t4() = let e1 = Let("x",EInt(84),Op("/",Ide("x"),EInt(2))) in execute e1 = Int(42);;
run_test "Test4 - assignment and division \t\t" t4;;

(* TEST SU FUNZIONI ED ASSEGNAMENTI *)

printf "*** Functions test ***\n";;

(* test assegnamento funzione ed applicazione -> risultato atteso : Int(42) *)
let t5() = let e1 = Let("f",FunDec("x",Op("*",Ide("x"),EInt(2))),FunApp(Ide("f"),EInt(21))) in execute e1 = Int(42);;
run_test "Test5 - function definition and application \t" t5;;

(* test assegnamento funzione esprimibile -> risultato atteso : fun x -> x + 2 *)
let t6() = let e1 = Let("f",FunDec("x",FunDec("y",Op("+",Ide("x"),Ide("y")))),FunApp(Ide("f"),EInt(2)))
  in execute (FunApp(e1,EInt(40))) = Int(42);;
run_test "Test6 - expressible function \t\t\t" t6;;

(* test assegnamento doppio con somma -> risultato atteso : Int(42) *)
let t7() = let e1 = Let("x",EInt(40),Let("y",EInt(2),Op("+",Ide("x"),Ide("y")))) in execute e1 = Int(42);;
run_test "Test7 - double assignment and sum\t\t" t7;;

(* TEST DI VISIBILITA' STATICA *)

printf "*** Scoping test ***\n";;

(* test scoping statico -> risultato atteso : Int(42) *)
let t8() = let e1 = Let("y",EInt(40),Let("f",FunDec("x",Op("+",Ide("x"),Ide("y"))),Let("y",EInt(200),
  FunApp(Ide("f"),EInt(2))))) in execute e1 = Int(42);;
run_test "Test8 - static scoping test\t\t\t" t8;;

(* TEST SU BOOLEANI *)

printf "*** Boolean test ***\n";;

(* test assegnamento e and logico -> risultato atteso : Bool(false) *)
let t9() = let e1 = Let("x",EBool(true),And(Ide("x"),EBool(true))) in execute e1 = Bool(true);;
run_test "Test9 - assignment and logical and\t\t" t9;;

(* test assegnamento e or logico -> risultato atteso : Bool(false) *)
let t10() = let e1 = Let("x",EBool(false),And(Ide("x"),EBool(false))) in execute e1 = Bool(false);;
run_test "Test10 - assignment and logical or\t\t" t10;;

(* test assegnamento e not -> risultato atteso : Bool(false) *)
let t11() = let e1 = Let("x",EBool(true),Not(Ide("x"))) in execute e1 = Bool(false);;
run_test "Test11 - assignment and logical negation\t" t11;;

(* TEST IF THEN ELSE & EQUIVALENZE *)

printf "*** if-then-else and equivalences test ***\n";;

(* test assegnamento, uguaglianza e costrutto if -> risultato atteso : Int(42) *)
let t12() = let e1 = Let("x",EInt(2),If(Op("=",Ide("x"),EInt(0)),EInt(24),EInt(42))) in execute e1 = Int(42);;
run_test "Test12 - if-then-else and equality test\t" t12;;

(* test assegnamento, maggiore o uguale e costrutto if -> risultato atteso : Int(42)  *)
let t13() = let e1 = Let("x",EInt(2),If(Op(">=",Ide("x"),EInt(0)),EInt(42),EInt(24))) in execute e1 = Int(42);;
run_test "Test13 - if-then-else and greater or equal test" t13;;

(* test assegnamento, minore o uguale e costrutto if -> risultato atteso : Int(42)  *)
let t14() = let e1 = Let("x",EInt(0),If(Op(">=",Ide("x"),EInt(0)),EInt(42),EInt(24))) in execute e1 = Int(42);;
run_test "Test14 - if-then-else and lesser or equal test\t" t14;;

(* test assegnamento, maggiore e costrutto if -> risultato atteso : Int(42) *)
let t15() = let e1 = Let("x",EInt(-2),If(Op(">",Ide("x"),EInt(0)),EInt(24),EInt(42))) in execute e1 = Int(42);;
run_test "Test15 - if-then-else and greater test\t\t" t15;;

(* test assegnamento, minore e costrutto if -> risultato atteso : Int(42) *)
let t16() = let e1 = Let("x",EInt(-2),If(Op("<",Ide("x"),EInt(0)),EInt(42),EInt(24))) in execute e1 = Int(42);;
run_test "Test16 - if-then-else and lesser test\t\t" t16;;

(* TEST SU PATTERN MATCHING *)

printf "*** Pattern matching test ***\n";;

(* test assegnamento e patten matching composto -> risultato atteso : Int(42) *)
(*
  pseudo codice:
  let z = 40 in
    let w = 2 in
      try x with (+,z,w) in
        (x = 0  -> 99)::
        (x = 42 -> 42)::
        ( _     -> 88)
*)
let t17() = let e1 = Let("z",EInt(40),Let("w",EInt(2),Try("x",Op("+",Ide("z"),Ide("w")),
  Comp(Op("=",Ide("x"),EInt(0)),EInt(99),Comp(Op("=",Ide("x"),EInt(42)),EInt(42),Default(EInt(88))))))) in execute e1 = Int(42);;
run_test "Test17 - assignment and pattern matching\t" t17;;

(* test contenuto nelle specifiche -> risultato atteso : Int(42) *)
(*
  pseudo codice:
  let z = 40 in
    let w = 1 in
      try x with (+,z,w) in
        (x > 0 -> let succ x = x + 1 in succ x )::
        (x < 0 -> let abs x = if x >= 0 then x * 1 else x * -1 in abs x)::
        ( _    -> x)

  le variabili z, w sono state assegnate per semplicità, come si nota dallo pseudo codice e dal codice effettivo,
  questo test mira anche a controllare l'efficacia e la correttezza dello scoping dichiarando la variabile 'x' come
  parametro formale sia di 'try' che di 'succ' e 'abs'
*)
let t18() = let e1 =
  Let("z",EInt(40),
    Let("w",EInt(1),
      Try("x",Op("+",Ide("z"),Ide("w")),
        Comp(Op(">",Ide("x"),EInt(0)),
          Let("succ",FunDec("x",Op("+",Ide("x"),EInt(1))),FunApp(Ide("succ"),Ide("x"))),
            Comp(Op("<",Ide("x"),EInt(0)),
              Let("abs",FunDec("x",If(Op(">=",Ide("x"),EInt(0)),Op("*",Ide("x"),EInt(1)),Op("*",Ide("x"),EInt(-1)))),
              FunApp(Ide("abs"),Ide("x"))),
                Default(Op("*",Ide("x"),EInt(1)))))))) in execute e1 = Int(42);;
run_test "Test18 - test contained in the specs\t\t" t18;;

(* TEST DELLE ECCEZIONI *)

printf "*** Failures test ***\n";;
printf "*** N.B. THE FOLLOWING TESTS MUST THROWS EXCEPTIONS !!! ***\n";;

(* test operazione non riconosciuta *)
let t19() = let e1 = Op("foo_sum",EInt(2),EInt(40)) in execute e1 = Int(42);;
run_test "Test19 - unrecognized operation test" t19;;

(* test assenza di binding *)
let t20() = let e1 = Ide("x") in
  if execute e1 = Novalue then failwith "unbound identificator" else failwith "SEVERE ERROR";;
run_test "Test20 - unbound identificator test" t20;;

(* test divisione per zero *)
let t21() = let e1 = Op("/",EInt(1),EInt(0)) in execute e1 = Int(42);;
run_test "Test21 - division by zero" t21;;

(* test parametri non booleani *)
let t22() = let e1 = And(EInt(42),EInt(42)) in execute e1 = Int(42);;
run_test "Test22 - non boolean parameters" t22;;

(* test parametri non interi *)
let t23() = let e1 = Op("+",EBool(false),EBool(false)) in execute e1 = Int(42);;
run_test "Test23 - non integer parameters" t23;;

(* test applicazione di funzione su identificatore non funzione *)
let t24() = let e1 = Let("f",FunDec("x",Op("+",Ide("x"),EInt(1))),FunApp(EInt(42),EInt(42))) in execute e1 = Int(43);;
run_test "Test24 - function application on non-function ide" t24;;

(* test valore non esprimibile *)
let t25() = let e1 = Op("=",EInt(42),EBool(false)) in execute e1 = Int(42);;
run_test "Test25 - unexpressible value" t25;;

(* test pattern non coincidente *)
let t26() = let e1 = Try("x",Op("+",EInt(-1),EInt(-1)),Elem(Op("=",Ide("x"),EInt(0)),EInt(42)))
  in execute e1 = Int(42);;
run_test "Test26 - unmatched pattern" t26;;

printf "*** TEST END ***\n";;