| 1 | (* Auxiliary functions for test cases *) |
| 2 | |
| 3 | infix 1 seq |
| 4 | fun e1 seq e2 = e2; |
| 5 | fun check b = if b then "OK" else "WRONG"; |
| 6 | fun check' f = (if f () then "OK" else "WRONG") handle _ => "EXN"; |
| 7 | |
| 8 | fun range (from, to) p = |
| 9 | let open Int |
| 10 | in |
| 11 | (from > to) orelse (p from) andalso (range (from+1, to) p) |
| 12 | end; |
| 13 | |
| 14 | fun checkrange bounds = check o range bounds; |
| 15 | |
| 16 | fun tst0 s s' = print (s ^ " \t" ^ s' ^ "\n"); |
| 17 | fun tst s b = tst0 s (check b); |
| 18 | fun tst' s f = tst0 s (check' f); |
| 19 | |
| 20 | fun tstrange s bounds = (tst s) o range bounds |
| 21 | |
| 22 | (* test/word.sml -- some test cases for Word, appropriate for a two's |
| 23 | complement machine whose Int.precision = SOME 31 |
| 24 | PS 1995-03-19, 1995-07-12, 1995-11-06, 1996-04-01, 1996-10-01 |
| 25 | |
| 26 | modified to work for Int.precision = SOME 32 -- ME 1998-10-07 |
| 27 | *) |
| 28 | |
| 29 | (*KILL 05/11/1997 11:04. tho.: |
| 30 | use "auxil.sml"; |
| 31 | *) |
| 32 | |
| 33 | local |
| 34 | (* Isn't this disgusting: *) |
| 35 | val [gt, lt, ge, le] = |
| 36 | [op>, op<, op>=, op<=] : (int * int -> bool) list |
| 37 | val [add, sub, mul, idiv, imod] = |
| 38 | [op+, op-, op*, op div, op mod] : (int * int -> int) list |
| 39 | open Word; |
| 40 | val op > = gt and op < = lt and op >= = ge and op <= = le; |
| 41 | val op + = add and op - = sub and op * = mul |
| 42 | and op div = idiv and op mod = imod; |
| 43 | val i2w = fromInt |
| 44 | and w2i = toIntX; |
| 45 | fun pr_ln s s' = print (s ^ ": " ^ s' ^ "\n") |
| 46 | in |
| 47 | |
| 48 | val test1 = checkrange (0, 1025) |
| 49 | (fn i => i = w2i (i2w i)); |
| 50 | val _ = pr_ln "test1" test1 |
| 51 | |
| 52 | val test3 = checkrange (~1000, 1000) |
| 53 | (fn i => i = toIntX (i2w i)); |
| 54 | val _ = pr_ln "test3" test3 |
| 55 | |
| 56 | val test5a = checkrange (0,15) |
| 57 | (fn i => (i+960) div 2 * 2 + 1 |
| 58 | = w2i (orb (i2w i, i2w 961))); |
| 59 | val _ = pr_ln "test5a" test5a |
| 60 | val test5b = checkrange (0,513) |
| 61 | (fn i => i = w2i (orb (i2w i, i2w i))); |
| 62 | val _ = pr_ln "test5b" test5b |
| 63 | val test6a = checkrange (0,15) |
| 64 | (fn i => i div 2 * 2 = w2i (andb (i2w i, i2w ~2))); |
| 65 | val _ = pr_ln "test6a" test6a |
| 66 | val test6b = checkrange (0,513) |
| 67 | (fn i => i = w2i (andb (i2w i, i2w i))); |
| 68 | val _ = pr_ln "test6b" test6b |
| 69 | val test7a = checkrange (0,15) |
| 70 | (fn i => i+960 = w2i (xorb (i2w i, i2w 960))); |
| 71 | val _ = pr_ln "test7a" test7a |
| 72 | val test7b = checkrange (0, 513) |
| 73 | (fn i => 0 = w2i (xorb (i2w i, i2w i))); |
| 74 | val _ = pr_ln "test7b" test7b |
| 75 | val test8a = check(~1 = w2i (notb (i2w 0))); |
| 76 | val _ = pr_ln "test8a" test8a |
| 77 | val test8b = check (0 = w2i (notb (i2w ~1))); |
| 78 | val _ = pr_ln "test8b" test8b |
| 79 | val maxposint = valOf Int.maxInt; |
| 80 | val maxnegint = (Int.~ maxposint)-1; |
| 81 | fun pwr2 0 = 1 |
| 82 | | pwr2 n = 2 * pwr2 (n-1); |
| 83 | fun rwp i 0 = i |
| 84 | | rwp i n = rwp i (n-1) div 2; |
| 85 | |
| 86 | val test9a = checkrange (0,29) |
| 87 | (fn k => pwr2 k = w2i (<< (i2w 1, i2w k))); |
| 88 | val _ = pr_ln "test9a" test9a |
| 89 | val test9b = checkrange (32,65) |
| 90 | (fn k => 0 = w2i (<< (i2w 1, i2w k))); |
| 91 | val _ = pr_ln "test9b" test9b |
| 92 | val test9c = check (maxnegint = w2i (<< (i2w 1, i2w 31))); |
| 93 | val _ = pr_ln "test9c" test9c |
| 94 | val test9d = checkrange (0, 1025) |
| 95 | (fn i => 2 * i = w2i (<< (i2w i, i2w 1))); |
| 96 | val _ = pr_ln "test9d" test9d |
| 97 | val test9e = checkrange (0, 1025) |
| 98 | (fn i => i div 2 = w2i (>> (i2w i, i2w 1))); |
| 99 | val _ = pr_ln "test9e" test9e |
| 100 | val test9f = checkrange (0,65) |
| 101 | (fn k => rwp maxposint k = w2i (>> (i2w maxposint, i2w k))); |
| 102 | val _ = pr_ln "test9f" test9f |
| 103 | val test9g = checkrange (32,65) |
| 104 | (fn k => 0 = w2i (<< (i2w ~1, i2w k))); |
| 105 | val _ = pr_ln "test9g" test9g |
| 106 | val test9h = checkrange (1,65) |
| 107 | (fn k => 0 = w2i (>> (i2w 1, i2w k))); |
| 108 | val _ = pr_ln "test9h" test9h |
| 109 | |
| 110 | val test10a = checkrange (1,65) |
| 111 | (fn k => 0 = w2i (~>> (i2w 1, i2w k))); |
| 112 | val _ = pr_ln "test10a" test10a |
| 113 | val test10b = checkrange (1,65) |
| 114 | (fn k => ~1 = w2i (~>> (i2w ~1, i2w k))); |
| 115 | val _ = pr_ln "test10b" test10b |
| 116 | val test10c = checkrange (~513, 513) |
| 117 | (fn i => i div 2 = toIntX (~>> (i2w i, i2w 1))); |
| 118 | val _ = pr_ln "test10c" test10c |
| 119 | val test10d = checkrange (0,65) |
| 120 | (fn k => rwp maxnegint k = toIntX (~>> (i2w maxnegint, i2w k))); |
| 121 | val _ = pr_ln "test10d" test10d |
| 122 | local |
| 123 | open Word |
| 124 | in |
| 125 | val test11a = check (i2w 256 > i2w 255); |
| 126 | val _ = pr_ln "test11a" test11a |
| 127 | val test11b = check (i2w 0 < i2w ~1); |
| 128 | val _ = pr_ln "test11b" test11b |
| 129 | val test11c = check (i2w maxposint >= i2w maxposint); |
| 130 | val _ = pr_ln "test11c" test11c |
| 131 | val test11d = check (i2w maxnegint >= i2w 127); |
| 132 | val _ = pr_ln "test11d" test11d |
| 133 | val test11e = check (i2w 1 <= i2w 1); |
| 134 | val _ = pr_ln "test11e" test11e |
| 135 | val test11f = check (i2w 0 <= i2w 1); |
| 136 | val _ = pr_ln "test11f" test11f |
| 137 | val test11g = check (i2w 0 < i2w maxposint); |
| 138 | val _ = pr_ln "test11g" test11g |
| 139 | val test11h = check (i2w maxposint < i2w maxnegint); |
| 140 | val _ = pr_ln "test11h" test11h |
| 141 | val test11i = check (i2w maxnegint < i2w ~1); |
| 142 | val _ = pr_ln "test11i" test11i |
| 143 | end; |
| 144 | |
| 145 | local |
| 146 | open Word |
| 147 | in |
| 148 | val test12a = checkrange(0, 300) (fn k => w2i (i2w k + i2w 17) = add(k, 17)); |
| 149 | val _ = pr_ln "test12a" test12a |
| 150 | val test12b = checkrange(0, 300) (fn k => w2i (i2w k - i2w 17) = sub(k, 17)); |
| 151 | val _ = pr_ln "test12b" test12b |
| 152 | val test12c = checkrange(0, 300) (fn k => w2i (i2w k * i2w 17) = mul(k, 17)); |
| 153 | val _ = pr_ln "test12c" test12c |
| 154 | val test12d = checkrange(0, 300) |
| 155 | (fn k => w2i (i2w k div i2w 17) = idiv(k, 17)); |
| 156 | val _ = pr_ln "test12d" test12d |
| 157 | val test12e = checkrange(0, 300) |
| 158 | (fn k => w2i (i2w k mod i2w 17) = imod(k, 17)); |
| 159 | val _ = pr_ln "test12e" test12e |
| 160 | val test12f = checkrange(0, 300) |
| 161 | (fn k => w2i (i2w k + i2w maxnegint) = add(k, maxnegint)); |
| 162 | val _ = pr_ln "test12f" test12f |
| 163 | val test12g = checkrange(0, 300) |
| 164 | (fn k => w2i (i2w maxnegint - i2w k - i2w 1) = sub(maxposint,k)); |
| 165 | val _ = pr_ln "test12g" test12g |
| 166 | val test12h = checkrange(0, 300) |
| 167 | (fn k => w2i (i2w k * i2w maxnegint) = mul(imod(k, 2), maxnegint)); |
| 168 | val _ = pr_ln "test12h" test12h |
| 169 | val test12i = checkrange(0, 300) |
| 170 | (fn k => w2i (i2w k * i2w maxposint + i2w k) = mul(imod(k, 2), maxnegint)); |
| 171 | val _ = pr_ln "test12i" test12i |
| 172 | val test12j = checkrange(0, 300) |
| 173 | (fn k => w2i (i2w k div i2w ~1) = 0); |
| 174 | val _ = pr_ln "test12j" test12j |
| 175 | val test12k = checkrange(0, 300) |
| 176 | (fn k => w2i (i2w k mod i2w ~1) = k); |
| 177 | val _ = pr_ln "test12k" test12k |
| 178 | val test12l = check(w2i (i2w maxposint + i2w 1) = maxnegint); |
| 179 | val _ = pr_ln "test12l" test12l |
| 180 | val test12m = check(w2i (i2w maxnegint - i2w 1) = maxposint); |
| 181 | val _ = pr_ln "test12m" test12m |
| 182 | val test12n = check(w2i (i2w ~1 div i2w 2) = maxposint); |
| 183 | val _ = pr_ln "test12n" test12n |
| 184 | val test12o = check(w2i (i2w ~1 mod i2w 2) = 1); |
| 185 | val _ = pr_ln "test12o" test12o |
| 186 | val test12p = check(w2i (i2w ~1 div i2w 100) = idiv(maxposint, 50)); |
| 187 | val _ = pr_ln "test12p" test12p |
| 188 | (*31bit |
| 189 | val test12q = check(w2i (i2w ~1 mod i2w 10) = 7); |
| 190 | val _ = pr_ln "test12q" test12q |
| 191 | *) |
| 192 | val test12r = (i2w 17 div i2w 0 seq "WRONG") |
| 193 | handle Div => "OK" | _ => "WRONG"; |
| 194 | val _ = pr_ln "test12r" test12r |
| 195 | val test12s = (i2w 17 mod i2w 0 seq "WRONG") |
| 196 | handle Div => "OK" | _ => "WRONG"; |
| 197 | val _ = pr_ln "test12s" test12s |
| 198 | fun chk f (s, r) = |
| 199 | check'(fn _ => |
| 200 | case f s of |
| 201 | SOME res => res = i2w r |
| 202 | | NONE => false) |
| 203 | |
| 204 | fun chkScan fmt = chk (StringCvt.scanString (scan fmt)) |
| 205 | |
| 206 | val test13a = |
| 207 | List.map (chk fromString) |
| 208 | [("20Af", 8367), |
| 209 | (" \n\t20AfGrap", 8367), |
| 210 | ("0w20Af", 0 (*8367*)), |
| 211 | (" \n\t0w20AfGrap", 0 (*8367*)), |
| 212 | ("0", 0), |
| 213 | ("0w", 0), |
| 214 | ("0W1", 0), |
| 215 | ("0w ", 0), |
| 216 | ("0wx", 0), |
| 217 | ("0wX", 0), |
| 218 | ("0wx1", 1), |
| 219 | ("0wX1", 1), |
| 220 | ("0wx ", 0), |
| 221 | ("0wX ", 0)]; |
| 222 | val _ = pr_ln "test13a" (concat test13a) |
| 223 | val test13b = |
| 224 | List.map (fn s => case fromString s of NONE => "OK" | _ => "WRONG") |
| 225 | ["", "-", "~", "+", " \n\t", " \n\t-", " \n\t~", " \n\t+", |
| 226 | "+1", "~1", "-1", "GG"]; |
| 227 | val _ = pr_ln "test13b" (concat test13b) |
| 228 | |
| 229 | val test14a = |
| 230 | List.map (chkScan StringCvt.DEC) |
| 231 | [("10789", 10789), |
| 232 | (" \n\t10789crap", 10789), |
| 233 | ("0w10789", 10789), |
| 234 | (" \n\t0w10789crap", 10789), |
| 235 | ("0", 0), |
| 236 | ("0w", 0), |
| 237 | ("0W1", 0), |
| 238 | ("0w ", 0), |
| 239 | ("0wx", 0), |
| 240 | ("0wX", 0), |
| 241 | ("0wx1", 0), |
| 242 | ("0wX1", 0), |
| 243 | ("0wx ", 0), |
| 244 | ("0wX ", 0)]; |
| 245 | val _ = pr_ln "test14a" (concat test14a) |
| 246 | val test14b = |
| 247 | List.map (fn s => case StringCvt.scanString (scan StringCvt.DEC) s |
| 248 | of NONE => "OK" | _ => "WRONG") |
| 249 | ["", "-", "~", "+", " \n\t", " \n\t-", " \n\t~", " \n\t+", |
| 250 | "+1", "~1", "-1", "ff"]; |
| 251 | val _ = pr_ln "test14b" (concat test14b) |
| 252 | val test15a = |
| 253 | List.map (chkScan StringCvt.BIN) |
| 254 | [("10010", 18), |
| 255 | (" \n\t10010crap", 18), |
| 256 | ("0w10010", 18), |
| 257 | (" \n\t0w10010crap", 18), |
| 258 | ("0", 0), |
| 259 | ("0w", 0), |
| 260 | ("0W1", 0), |
| 261 | ("0w ", 0), |
| 262 | ("0wx", 0), |
| 263 | ("0wX", 0), |
| 264 | ("0wx1", 0), |
| 265 | ("0wX1", 0), |
| 266 | ("0wx ", 0), |
| 267 | ("0wX ", 0)]; |
| 268 | val _ = pr_ln "test15a" (concat test15a) |
| 269 | val test15b = |
| 270 | List.map (fn s => case StringCvt.scanString (scan StringCvt.BIN) s |
| 271 | of NONE => "OK" | _ => "WRONG") |
| 272 | ["", "-", "~", "+", " \n\t", " \n\t-", " \n\t~", " \n\t+", |
| 273 | "+1", "~1", "-1", "2", "8", "ff"]; |
| 274 | val _ = pr_ln "test15b" (concat test15b) |
| 275 | val test16a = |
| 276 | List.map (chkScan StringCvt.OCT) |
| 277 | [("2071", 1081), |
| 278 | (" \n\t2071crap", 1081), |
| 279 | ("0w2071", 1081), |
| 280 | (" \n\t0w2071crap", 1081), |
| 281 | ("0", 0), |
| 282 | ("0w", 0), |
| 283 | ("0W1", 0), |
| 284 | ("0w ", 0), |
| 285 | ("0wx", 0), |
| 286 | ("0wX", 0), |
| 287 | ("0wx1", 0), |
| 288 | ("0wX1", 0), |
| 289 | ("0wx ", 0), |
| 290 | ("0wX ", 0)]; |
| 291 | val _ = pr_ln "test16a" (concat test16a) |
| 292 | val test16b = |
| 293 | List.map (fn s => case StringCvt.scanString (scan StringCvt.OCT) s |
| 294 | of NONE => "OK" | _ => "WRONG") |
| 295 | ["", "-", "~", "+", " \n\t", " \n\t-", " \n\t~", " \n\t+", |
| 296 | "+1", "~1", "-1", "8", "ff"]; |
| 297 | val _ = pr_ln "test16b" (concat test16b) |
| 298 | val test17a = |
| 299 | List.map (chkScan StringCvt.HEX) |
| 300 | [("20Af", 8367), (" \n\t20AfGrap", 8367), |
| 301 | ("0wx20Af", 8367), (" \n\t0wx20AfGrap", 8367), |
| 302 | ("0wX20Af", 8367), (" \n\t0wX20AfGrap", 8367), |
| 303 | ("0x20Af", 8367), (" \n\t0x20AfGrap", 8367), |
| 304 | ("0X20Af", 8367), (" \n\t0X20AfGrap", 8367), |
| 305 | ("0", 0), |
| 306 | ("0w", 0), |
| 307 | ("0w ", 0), |
| 308 | ("0w1", 0 (*1*)), |
| 309 | ("0W1", 0), |
| 310 | ("0wx", 0), |
| 311 | ("0wX", 0), |
| 312 | ("0wx1", 1), |
| 313 | ("0wX1", 1)]; |
| 314 | val _ = pr_ln "test17a" (concat test17a) |
| 315 | val test17b = |
| 316 | List.map (fn s => case StringCvt.scanString (scan StringCvt.HEX) s |
| 317 | of NONE => "OK" | _ => "WRONG") |
| 318 | ["", "-", "~", "+", " \n\t", " \n\t-", " \n\t~", " \n\t+", |
| 319 | "+1", "~1", "-1"]; |
| 320 | val _ = pr_ln "test17b" (concat test17b) |
| 321 | end; |
| 322 | |
| 323 | local |
| 324 | fun fromToString i = |
| 325 | fromString (toString (fromInt i)) = SOME (fromInt i); |
| 326 | |
| 327 | fun scanFmt radix i = |
| 328 | let val w = fromInt i |
| 329 | val s = fmt radix w |
| 330 | in StringCvt.scanString (scan radix) s = SOME w end; |
| 331 | |
| 332 | in |
| 333 | val test18 = |
| 334 | check'(fn _ => range (0, 1200) fromToString); |
| 335 | val _ = pr_ln "test18" test18 |
| 336 | val test19 = |
| 337 | check'(fn _ => range (0, 1200) (scanFmt StringCvt.BIN)); |
| 338 | val _ = pr_ln "test19" test19 |
| 339 | val test20 = |
| 340 | check'(fn _ => range (0, 1200) (scanFmt StringCvt.OCT)); |
| 341 | val _ = pr_ln "test20" test20 |
| 342 | val test21 = |
| 343 | check'(fn _ => range (0, 1200) (scanFmt StringCvt.DEC)); |
| 344 | val _ = pr_ln "test21" test21 |
| 345 | val test22 = |
| 346 | check'(fn _ => range (0, 1200) (scanFmt StringCvt.HEX)); |
| 347 | val _ = pr_ln "test22" test22 |
| 348 | end |
| 349 | end; |