regression/bytechar.sml

   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/bytechar.sml -- test cases for Byte and Char, suitable for ASCII
  23    PS 1994-12-10, 1995-05-11, 1995-11-10, 1996-09-30 *)
  24
  25 (*KILL 05/11/1997 10:55. tho.:
  26 use "auxil.sml";
  27 *)
  28
  29 val _ = print "\nFile bytechar.sml: Testing structures Byte and Char...\n"
  30
  31 local
  32
  33 in
  34
  35 val test1 = tstrange "test1" (0,255) (fn i =>
  36     (Word8.toInt o Byte.charToByte o Byte.byteToChar o Word8.fromInt) i = i);
  37
  38 val test2 = tstrange "test2" (0,Char.maxOrd) (fn i =>
  39     (Word8.toInt o Byte.charToByte o Char.chr) i = i);
  40
  41 val test3 = tstrange "test3" (0,255)
  42     (fn i => (Char.ord o Byte.byteToChar o Word8.fromInt) i = i);
  43
  44 val test4 = tstrange "test4" (0, Char.maxOrd)
  45     (fn i => (Char.ord o Char.chr) i = i);
  46
  47 val test5 = tst0 "test5" ((Char.chr ~1 seq "WRONG") handle Chr => "OK" | _ => "WRONG")
  48
  49 val test6 = tst0 "test6" ((Char.chr (Char.maxOrd+1) seq "WRONG")
  50                           handle Chr => "OK" | _ => "WRONG")
  51
  52 val test7 = tst "test7" ("" = Byte.bytesToString (Word8Vector.fromList []));
  53
  54 val test8 =
  55     tst "test8" ("ABDC" =
  56           (Byte.bytesToString o Word8Vector.fromList o map Word8.fromInt)
  57            [65, 66, 68, 67]);
  58
  59 val unpackString = Byte.unpackString o Word8ArraySlice.slice
  60
  61 val test9 = tst "test9" ("" = unpackString (Word8Array.fromList [], 0, SOME 0))
  62
  63 local
  64     val arr = Word8Array.tabulate(10, fn i => Word8.fromInt(i+65))
  65 in
  66 val test10a = tst "test10a" ("" = unpackString(arr, 0, SOME 0));
  67 val test10b = tst "test10b" ("" = unpackString(arr, 10, SOME 0)
  68                              andalso "" = unpackString(arr, 10, NONE));
  69 val test10c = tst "test10c" ("BCDE" = unpackString(arr, 1, SOME 4));
  70 val test10d = tst0 "test10d" ((unpackString(arr, ~1, SOME 0) seq "WRONG")
  71                               handle Subscript => "OK" | _ => "WRONG")
  72 val test10e = tst0 "test10e" ((unpackString(arr, 11, SOME 0) seq "WRONG")
  73                               handle Subscript => "OK" | _ => "WRONG")
  74 val test10f = tst0 "test10f" ((unpackString(arr, 0, SOME ~1) seq "WRONG")
  75                               handle Subscript => "OK" | _ => "WRONG")
  76 val test10g = tst0 "test10g" ((unpackString(arr, 0, SOME 11) seq "WRONG")
  77                               handle Subscript => "OK" | _ => "WRONG")
  78 val test10h = tst0 "test10h" ((unpackString(arr, 10, SOME 1) seq "WRONG")
  79                               handle Subscript => "OK" | _ => "WRONG")
  80 val test10i = tst0 "test10i" ((unpackString(arr, ~1, NONE) seq "WRONG")
  81                               handle Subscript => "OK" | _ => "WRONG")
  82 val test10j = tst0 "test10j" ((unpackString(arr, 11, NONE) seq "WRONG")
  83                               handle Subscript => "OK" | _ => "WRONG")
  84 end
  85
  86 val unpackStringVec = Byte.unpackStringVec o Word8VectorSlice.slice
  87 local
  88     val vec = Word8Vector.tabulate(10, fn i => Word8.fromInt(i+65))
  89 in
  90 val test11a = tst "test11a" ("" = unpackStringVec(vec, 0, SOME 0));
  91 val test11b = tst "test11b" ("" = unpackStringVec(vec, 10, SOME 0)
  92                              andalso "" = unpackStringVec(vec, 10, NONE));
  93 val test11c = tst "test11c" ("BCDE" = unpackStringVec(vec, 1, SOME 4));
  94 val test11d = tst0 "test11d" ((unpackStringVec(vec, ~1, SOME 0) seq "WRONG")
  95                               handle Subscript => "OK" | _ => "WRONG")
  96 val test11e = tst0 "test11e" ((unpackStringVec(vec, 11, SOME 0) seq "WRONG")
  97                               handle Subscript => "OK" | _ => "WRONG")
  98 val test11f = tst0 "test11f" ((unpackStringVec(vec, 0, SOME ~1) seq "WRONG")
  99                               handle Subscript => "OK" | _ => "WRONG")
 100 val test11g = tst0 "test11g" ((unpackStringVec(vec, 0, SOME 11) seq "WRONG")
 101                               handle Subscript => "OK" | _ => "WRONG")
 102 val test11h = tst0 "test11h" ((unpackStringVec(vec, 10, SOME 1) seq "WRONG")
 103                               handle Subscript => "OK" | _ => "WRONG")
 104 val test11i = tst0 "test11i" ((unpackStringVec(vec, ~1, NONE) seq "WRONG")
 105                             handle Subscript => "OK" | _ => "WRONG")
 106 val test11j = tst0 "test11j" ((unpackStringVec(vec, 11, NONE) seq "WRONG")
 107                               handle Subscript => "OK" | _ => "WRONG")
 108 end
 109
 110 val test18 = tst "test18" (not (Char.contains "" (Char.chr 65))
 111                    andalso not (Char.contains "aBCDE" (Char.chr 65))
 112                    andalso (Char.contains "ABCD" (Char.chr 67))
 113                    andalso not (Char.contains "" #"\000")
 114                    andalso not (Char.contains "" #"\255")
 115                    andalso not (Char.contains "azAZ09" #"\000")
 116                    andalso not (Char.contains "azAZ09" #"\255"));
 117
 118 val test19 = tst "test19" (Char.notContains "" (Char.chr 65)
 119                    andalso Char.notContains "aBCDE" (Char.chr 65)
 120                    andalso not (Char.notContains "ABCD" (Char.chr 67))
 121                    andalso Char.notContains "" #"\000"
 122                    andalso Char.notContains "" #"\255"
 123                    andalso Char.notContains "azAZ09" #"\000"
 124                    andalso Char.notContains "azAZ09" #"\255");
 125
 126 val test20 = tst "test20" (Char.ord Char.maxChar = Char.maxOrd);
 127
 128 local
 129 fun mycontains s c =
 130     let val stop = String.size s
 131         fun h i = i < stop andalso (c = String.sub(s, i) orelse h(i+1))
 132     in h 0 end;
 133
 134 (* Check that p(c) = (mycontains s c) for all characters: *)
 135 fun equivalent p s =
 136     let fun h n =
 137         n > 255 orelse
 138         (p (chr n) = mycontains s (chr n)) andalso h(n+1)
 139     in h 0 end
 140
 141 fun checkset p s = tst' "checkset" (fn _ => equivalent p s);
 142
 143 val graphchars = "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\
 144  \[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
 145
 146 val ascii = "\^@\^A\^B\^C\^D\^E\^F\^G\^H\t\n\^K\^L\^M\^N\^O\^P\
 147  \\^Q\^R\^S\^T\^U\^V\^W\^X\^Y\^Z\^[\^\\^]\^^\^_\
 148  \ !\"#$%&'()*+,-./0123456789:;<=>?@\
 149  \ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\127"
 150
 151 val lowerascii = "\^@\^A\^B\^C\^D\^E\^F\^G\^H\t\n\^K\^L\^M\^N\^O\^P\
 152  \\^Q\^R\^S\^T\^U\^V\^W\^X\^Y\^Z\^[\^\\^]\^^\^_\
 153  \ !\"#$%&'()*+,-./0123456789:;<=>?@\
 154  \abcdefghijklmnopqrstuvwxyz[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\127"
 155
 156 val upperascii = "\^@\^A\^B\^C\^D\^E\^F\^G\^H\t\n\^K\^L\^M\^N\^O\^P\
 157  \\^Q\^R\^S\^T\^U\^V\^W\^X\^Y\^Z\^[\^\\^]\^^\^_\
 158  \ !\"#$%&'()*+,-./0123456789:;<=>?@\
 159  \ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~\127"
 160
 161 val allchars =
 162     let fun h 0 res = chr 0 :: res
 163           | h n res = h (n-1) (chr n :: res)
 164     in h 255 [] end
 165
 166 open Char
 167 in
 168
 169 val test21 =
 170     checkset isLower "abcdefghijklmnopqrstuvwxyz";
 171 val test22 =
 172     checkset isUpper "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 173 val test23 =
 174     checkset isDigit "0123456789";
 175 val test24 =
 176     checkset isAlpha "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 177 val test25 =
 178     checkset isHexDigit "0123456789abcdefABCDEF";
 179 val test26 =
 180     checkset isAlphaNum
 181        "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 182 val test27 =
 183     checkset isPrint (" " ^ graphchars)
 184 val test28 =
 185     checkset isSpace " \009\010\011\012\013";
 186 val test29 =
 187     checkset isGraph graphchars
 188 val test30 =
 189     checkset isAscii ascii
 190
 191 val test31 =
 192     tst' "test31" (fn _ => map toLower (explode ascii) = explode lowerascii)
 193 val test32 =
 194     tst' "test32" (fn _ => map toUpper (explode ascii) = explode upperascii)
 195 val test33 =
 196     tst' "test33" (fn _ =>
 197            map toUpper (explode graphchars)
 198            seq map toLower (explode graphchars)
 199            seq true)
 200
 201 val test34a =
 202     tst' "test34a" (fn _ =>
 203            map pred (List.drop(allchars, 1)) = List.take(allchars, 255));
 204 val test34b = tst0 "test34b" ((pred minChar seq "WRONG")
 205                               handle Chr => "OK" | _ => "WRONG")
 206 val test35a =
 207     tst' "test35a" (fn _ =>
 208            map succ (List.take(allchars, 255)) = List.drop(allchars, 1));
 209 val test35b = tst0 "test35b" ((succ maxChar seq "WRONG")
 210                               handle Chr => "OK" | _ => "WRONG")
 211 end
 212
 213
 214 (* Test cases for SML character escape functions. *)
 215
 216 val test36 =
 217     let fun chk (arg, res) = Char.toString arg = res
 218     in tst' "test36" (fn _ => List.all chk
 219               [(#"\000", "\\^@"),
 220                (#"\001", "\\^A"),
 221                (#"\006", "\\^F"),
 222                (#"\007", "\\a"),
 223                (#"\008", "\\b"),
 224                (#"\009", "\\t"),
 225                (#"\010", "\\n"),
 226                (#"\011", "\\v"),
 227                (#"\012", "\\f"),
 228                (#"\013", "\\r"),
 229                (#"\014", "\\^N"),
 230                (#"\031", "\\^_"),
 231                (#"\032", " "),
 232                (#"\126", "~"),
 233                (#"\\", "\\\\"),
 234                (#"\"", "\\\""),
 235                (#"A", "A"),
 236                (#"\127", "\\127"),
 237                (#"\128", "\\128"),
 238                (#"\255", "\\255")])
 239     end;
 240
 241 val test37 =
 242     let val chars = List.tabulate(256, chr)
 243         fun chk c = Char.fromString(Char.toString c) = SOME c
 244     in tst' "test37" (fn _ => List.all chk chars) end
 245
 246 val test38 =
 247     let fun chkFromString (arg, res) = Char.fromString arg = SOME res
 248         val argResList =
 249             [("A", #"A"),
 250              ("z", #"z"),
 251              ("@", #"@"),
 252              ("~", #"~"),
 253              ("\\a", #"\007"),
 254              ("\\b", #"\008"),
 255              ("\\t", #"\009"),
 256              ("\\n", #"\010"),
 257              ("\\v", #"\011"),
 258              ("\\f", #"\012"),
 259              ("\\r", #"\013"),
 260              ("\\\\", #"\\"),
 261              ("\\\"", #"\""),
 262              ("\\^@", #"\000"),
 263              ("\\^A", #"\001"),
 264              ("\\^Z", #"\026"),
 265              ("\\^_", #"\031"),
 266              ("\\000", #"\000"),
 267              ("\\097", #"a"),
 268              ("\\255", #"\255"),
 269              ("\\   \t\n\n \\A", #"A"),
 270              ("\\   \t\n\n \\z", #"z"),
 271              ("\\   \t\n\n \\@", #"@"),
 272              ("\\   \t\n\n \\~", #"~"),
 273              ("\\   \t\n\n \\\\n", #"\n"),
 274              ("\\   \t\n\n \\\\t", #"\t"),
 275              ("\\   \t\n\n \\\\\\", #"\\"),
 276              ("\\   \t\n\n \\\\\"", #"\""),
 277              ("\\   \t\n\n \\\\^@", #"\000"),
 278              ("\\   \t\n\n \\\\^A", #"\001"),
 279              ("\\   \t\n\n \\\\^Z", #"\026"),
 280              ("\\   \t\n\n \\\\^_", #"\031"),
 281              ("\\   \t\n\n \\\\000", #"\000"),
 282              ("\\   \t\n\n \\\\097", #"a"),
 283              ("\\   \t\n\n \\\\255", #"\255")]
 284     in
 285         tst' "test38" (fn _ => List.all chkFromString argResList)
 286     end;
 287
 288 val test39 =
 289     tst' "test39" (fn _ => List.all (fn arg => Char.fromString arg = NONE)
 290            ["\\",
 291             "\\c",
 292             "\\F",
 293             "\\e",
 294             "\\g",
 295             "\\N",
 296             "\\T",
 297             "\\1",
 298             "\\11",
 299             "\\256",
 300             "\\-65",
 301             "\\~65",
 302             "\\?",
 303             "\\^`",
 304             "\\^a",
 305             "\\^z",
 306             "\\   a",
 307             "\\   a\\B",
 308             "\\   \\"]);
 309
 310 (* Test cases for C string escape functions *)
 311
 312 val test40 =
 313     let val chars = List.tabulate(256, chr)
 314     in tst' "test40" (fn _ =>
 315               List.map SOME chars
 316               = List.map Char.fromCString (List.map Char.toCString chars))
 317     end;
 318
 319 val test41 =
 320     let val argResList =
 321             [(#"\010", "\\n"),
 322              (#"\009", "\\t"),
 323              (#"\011", "\\v"),
 324              (#"\008", "\\b"),
 325              (#"\013", "\\r"),
 326              (#"\012", "\\f"),
 327              (#"\007", "\\a"),
 328              (#"\\", "\\\\"),
 329              (#"?", "\\?"),
 330              (#"'", "\\'"),
 331              (#"\"", "\\\"")]
 332     in
 333         tst' "test41" (fn _ =>
 334                List.all (fn (arg, res) => Char.toCString arg = res) argResList)
 335     end;
 336
 337 val test42 =
 338     let fun checkFromCStringSucc (arg, res) =
 339             str (valOf (Char.fromCString arg)) = res
 340         val argResList =
 341             [("\\n", "\010"),
 342              ("\\t", "\009"),
 343              ("\\v", "\011"),
 344              ("\\b", "\008"),
 345              ("\\r", "\013"),
 346              ("\\f", "\012"),
 347              ("\\a", "\007"),
 348              ("\\\\",  "\\"),
 349              ("\\?", "?"),
 350              ("\\'", "'"),
 351              ("\\\"", "\""),
 352              ("\\1", "\001"),
 353              ("\\11", "\009"),
 354              ("\\111", "\073"),
 355              ("\\1007", "\064"),
 356              ("\\100A", "\064"),
 357              ("\\0",   "\000"),
 358              ("\\377", "\255"),
 359              ("\\18", "\001"),
 360              ("\\178", "\015"),
 361              ("\\1C", "\001"),
 362              ("\\17C", "\015"),
 363              ("\\x0", "\000"),
 364              ("\\xff", "\255"),
 365              ("\\xFF", "\255"),
 366              ("\\x1", "\001"),
 367              ("\\x11", "\017"),
 368              ("\\xag", "\010"),
 369              ("\\xAAg", "\170"),
 370              ("\\x0000000a", "\010"),
 371              ("\\x0000000a2", "\162"),
 372              ("\\x0000000ag", "\010"),
 373              ("\\x0000000A", "\010"),
 374              ("\\x0000000A2", "\162"),
 375              ("\\x0000000Ag", "\010"),
 376              ("\\x00000000000000000000000000000000000000000000000000000000000000011+",
 377               "\017")
 378              ]
 379     in
 380         tst' "test42" (fn _ => List.all checkFromCStringSucc argResList)
 381     end;
 382
 383 val test43 =
 384     let fun checkFromCStringFail arg = Char.fromCString arg = NONE
 385     in
 386         tst' "test43" (fn _ => List.all checkFromCStringFail
 387                ["\\",
 388                 "\\X",
 389                 "\\=",
 390                 "\\400",
 391                 "\\777",
 392                 "\\8",
 393                 "\\9",
 394                 "\\c",
 395                 "\\d",
 396                 "\\x",
 397                 "\\x100",
 398                 "\\xG"])
 399     end;
 400 end