Permalink
Fetching contributors…
Cannot retrieve contributors at this time
206 lines (182 sloc) 6.4 KB
(*testdyn1.sml*)
(* ------------------------------------------------------------------- *)
(* testdyn1, 08/02/1995 19:17, Martin *)
(* Dynamic test of primitives... except for input/output *)
(* ------------------------------------------------------------------- *)
(*
MEMO : 'sin', 'cos', 'arctan', 'ln' and 'exp' are not checked yet.
*)
infix ==
val epsilon = 0.000666
fun r1 == r2 = abs (r1 - r2) < epsilon (*no perfect world*)
fun digit n = chr(ord #"0" + n)
fun digits(n,acc) =
if n >=0 andalso n<=9 then digit n:: acc
else digits (n div 10, digit(n mod 10) :: acc)
fun int_to_string(n) = if n >= 0 then implode(digits(n,[]))
else "~" ^ int_to_string(~n)
fun error b s = print ((if b then "Ok - " else "Error - ") ^ s ^ "...<br>")
(* testing stuff *)
val _ =
let
val _ = print "Testing list operations:<br>\
\ [rev, @, map]...<br>"
in
error (rev [3,34,2,23] = [23,2,34,3]) "rev";
error (map (fn a:int => 2 * a) [3,34,2] = [6,68,4]) "map";
error ([34,56] @ [12,67] = [34,56,12,67]) "@"
end
val _ =
let
val _ = print "Testing string operations:<br>\
\ [implode, explode, chr, ord, size]...<br>"
fun hds [] = #"-"
| hds (x::_) = x
in
error (int_to_string 232 = "232") "int_to_string";
error (implode [#"h", #"e", #"l", #"l", #" "] = "hell ") "implode";
error (hds (explode "hello") = #"h") "explode";
error (chr 66 = #"B") "chr";
error (ord #"B" = 66) "ord";
error (((chr 1000) handle Chr => #"h") = #"h") "Chr";
error (((chr 1000) handle Div => #"h"
| Chr => #"k") = #"k") "Chr2";
error (size "hello I'm 19 long.." = 19) "size"
end
val _ =
let
val _ = print "Testing ref [ref, :=, !]...<br>"
val a = ref "hello"
val g = ref 45
in
error (!a = "hello") "!1";
error ((a := "hej") = ()) ":=1";
error (!a = "hej") "!2";
error ((g := !g + 1) = ()) ":=2";
error (!g = 46) "!3"
end
val _ =
let
val _ = print "Testing polymorphic equality...<br>"
val a = [(34,"hejsa"), (4, "bw")]
val b = [[3,23], [~34,23]]
val c = (56, ref "hello")
val d = ref "hej"
datatype k = A of int * string | B | C of k * k
val k1 = C (A(5,"hello"), B)
val k2 = C (A(5,"hello2"), B)
val k3 = C (A(5,"hello2"), B)
in
error (a = [(34,"hejsa"), (4, "bw")]) "equal";
error ((a = [(34,"hejsa"), (4, "cw")]) = false) "equal2";
error (b = [[3,23], [~34,23]]) "equal3";
error ((b = [[3,23], [~34,21]]) = false) "equal4";
error ((c = (56, ref "hello")) = false) "equal5 (ref1)";
error ((34,d) = (34,d)) "equal5 (ref2)";
error (k1 <> k2) "equal6 (dat k)";
error (k2 = k3) "equal7 (dat k)"
end
val _ =
let
val _ = print "Testing arithmetic integer operations:<br>\
\ [~, abs, floor, +, -, *, div, mod, &lt;, &gt;, &lt;=, &gt;=] ...<br>"
fun checkdivmod (i, d) =
let
val (r, q) = (i mod d, i div d)
val gt_zero = fn a => a > 0
in
error (gt_zero r = gt_zero d andalso d * q + r = i)
("intdivmod - " ^ int_to_string i ^ " mod " ^ int_to_string d ^
" = " ^ int_to_string r ^ ", " ^ int_to_string i ^ " div "
^ int_to_string d ^ " = " ^ int_to_string q)
end
in
error (~ 5 = ~5) "~1";
error (~ (~2) = 2) "~2";
error (abs 5 = 5) "abs1";
error (abs (~23) = 23) "abs2";
error (floor (23.23) = 23) "floor1";
error (floor (~23.23) = ~24) "floor2";
error (((floor (23.0E23)) handle Overflow => 4) = 4) "floor3";
error (23 + 12 = 35 andalso ~4 + 5 = 1) "+";
error (34 - 12 = 22 andalso ~23 - 15 = ~38) "-";
error (12 * 3 = 36 andalso ~23 * 2 = ~46) "*";
map checkdivmod [(2,3), (34, ~3), (5, ~2), (~7, 3)];
error (((3 div 0) handle Div => 60) = 60) "Div1";
error (((3 mod 0) handle Div => 45) = 45) "Div2";
error ((23 < 40) = true) "<1";
error ((54 < 40) = false) "<2";
error ((40 < 40) = false) "<3";
error ((23 > 40) = false) ">1";
error ((54 > 40) = true) ">2";
error ((40 > 40) = false) ">3";
error ((23 <= 40) = true) "<=1";
error ((54 <= 40) = false) "<=2";
error ((40 <= 40) = true) "<=3";
error ((23 >= 40) = false) ">=1";
error ((54 >= 40) = true) ">=2";
error ((40 >= 40) = true) ">=3"
end
val _ =
let
val _ = print "Testing arithmetic real operations:<br>\
\ [+, -, *, /, ~, abs, real, sqrt, <, >, <=, >=] ...<br>"
in
error (4.0 + 3.0 == 7.0) "+";
error (4.0 - 1.0 == 3.0) "-";
error (4.0 * 3.0 == 12.0) "*";
error (9.0 / 2.0 == 4.5) "/";
error (~ 5.3 == ~5.3) "~1";
error (~ (~2.23) == 2.23) "~2";
error (abs 5.23 == 5.23) "abs1";
error (abs (~23.12) == 23.12) "abs2";
error (real 5 == 5.0) "real1";
error (real ~5 == ~5.0) "real2";
error (Math.sqrt 0.0 == 0.0) "sqrt1";
error (Math.sqrt 2.0 > 1.4) "sqrt2";
error (Math.sqrt 2.0 < 1.5) "sqrt3";
error ((23.34 < 40.23) = true) "<1";
error ((54.12 < 40.45) = false) "<2";
error ((40.12 < 40.12) = false) "<3";
error ((23.34 > 40.12) = false) ">1";
error ((54.45 > 40.23) = true) ">2";
error ((40.23 > 40.23) = false) ">3";
error ((23.12 <= 40.34) = true) "<=1";
error ((54.23 <= 40.23) = false) "<=2";
error ((40.23 <= 40.23) = true) "<=3";
error ((23.75 >= 40.75) = false) ">=1";
error ((54.57 >= 40.57) = true) ">=2";
error ((40.23 >= 40.23) = true) ">=3"
end
val _ =
let
val _ = print "Testing composition o:<br>"
fun f x = 3 + x
fun g y = (y, 2*y)
in
error ((g o f) 7 = (10,20)) "o"
end
val _ =
let
val _ = print "Testing generative exceptions:<br>"
fun g a =
let
fun f x =
let
exception E
in
if x < 1 then raise E
else ((f (x-1)) handle E => 7) (* should not handle this.. *)
end
in
(f a) handle _ => a
end (* a *)
in
error (g 10 = 10) "exn - generative"
end
fun etst b s = if b then () else print ("Error - " ^ s ^ "...<br>");
val _ = etst ("\u0041\u000a\\u0041\n" = "A\n\092" ^ "u0041\010")
"backslash u does not work or somepin";
val _ = etst (map ord [#"a", #"A", #" ", chr 42, #"\117"] =
[97, 65, 32, 42, 117]) "char problem, maybe #"
val _ = print "End of test.<br>"