Commit | Line | Data |
---|---|---|
7f918cf1 CE |
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 | ||
23 | (* test/string.sml | |
24 | PS 1994-12-10, 1995-06-14, 1996-05-16 *) | |
25 | ||
26 | (*KILL 05/11/1997 11:02. tho.: | |
27 | use "auxil.sml"; | |
28 | *) | |
29 | ||
30 | val _ = print "Testing String...\n"; | |
31 | ||
32 | local | |
33 | val map' = map | |
34 | open Char String | |
35 | val map = map' | |
36 | ||
37 | val s1 = "" (* size s1 = 0 *) | |
38 | and s2 = "ABCDE\tFGHI"; (* size s2 = 10 *) | |
39 | val ABCDE = List.map chr [65,66,67,68,69]; | |
40 | in | |
41 | ||
42 | val test1 = tst' "test1" (fn _ => (size s1 = 0 andalso size s2 = 10)); | |
43 | val test2 = tst' "test2" (fn _ => (sub(s2,6) = chr 70 andalso sub(s2,9) = chr 73)); | |
44 | val test3 = tst0 "test3" ((sub(s1, 0) seq "WRONG") handle Subscript => "OK" | _ => "WRONG"); | |
45 | val test4 = tst0 "test4" ((sub(s2, ~1) seq "WRONG") handle Subscript => "OK" | _ => "WRONG"); | |
46 | val test5 = tst0 "test5" ((sub(s2, 10) seq "WRONG") handle Subscript => "OK" | _ => "WRONG"); | |
47 | ||
48 | val test6 = | |
49 | tst' "test6" (fn _ => | |
50 | "" = concat [] andalso "" = concat [s1] | |
51 | andalso s2 = concat [s2] andalso s2^s2 = concat [s2,s2] | |
52 | andalso "ABCD" = concat ["A","B","C","D"]); | |
53 | ||
54 | val test7 = tst' "test7" (fn _ => "A" = str(chr 65)); | |
55 | ||
56 | val test8 = | |
57 | tst' "test8" (fn _ => "" = implode [] andalso "ABCDE" = implode ABCDE); | |
58 | ||
59 | val test9 = | |
60 | tst' "test9" (fn _ => [] = explode "" andalso ABCDE = explode "ABCDE"); | |
61 | ||
62 | val test10 = | |
63 | tst' "test10" (fn _ => | |
64 | s1 < s2 andalso s1 <= s1 | |
65 | andalso s2 > s1 andalso s2 >=s2); | |
66 | ||
67 | val test11a = | |
68 | tst' "test11a" (fn _ => | |
69 | s2 = extract(s2, 0, SOME (size s2)) | |
70 | andalso s2 = extract(s2, 0, NONE) | |
71 | andalso "" = extract(s2, size s2, SOME 0) | |
72 | andalso "" = extract(s2, size s2, NONE) | |
73 | andalso "" = extract(s1, 0, SOME 0) | |
74 | andalso "" = extract(s1, 0, NONE)); | |
75 | ||
76 | val test11b = tst0 "test11b" ((extract(s2, ~1, SOME 0) seq "WRONG") | |
77 | handle Subscript => "OK" | _ => "WRONG"); | |
78 | val test11c = tst0 "test11c" ((extract(s2, 11, SOME 0) seq "WRONG") | |
79 | handle Subscript => "OK" | _ => "WRONG"); | |
80 | val test11d = tst0 "test11d" ((extract(s2, 0, SOME 11) seq "WRONG") | |
81 | handle Subscript => "OK" | _ => "WRONG"); | |
82 | val test11e = tst0 "test11e" ((extract(s2, 10, SOME 1) seq "WRONG") | |
83 | handle Subscript => "OK" | _ => "WRONG"); | |
84 | val test11f = tst0 "test11f" ((extract(s2, ~1, NONE) seq "WRONG") | |
85 | handle Subscript => "OK" | _ => "WRONG"); | |
86 | val test11g = tst0 "test11g" ((extract(s2, 11, NONE) seq "WRONG") | |
87 | handle Subscript => "OK" | _ => "WRONG"); | |
88 | ||
89 | val test11h = | |
90 | tst' "test11h" (fn _ => | |
91 | "ABCDE" = extract(s2, 0, SOME 5) | |
92 | andalso "FGHI" = extract(s2, 6, SOME 4) | |
93 | andalso "FGHI" = extract(s2, 6, NONE)); | |
94 | ||
95 | val test12a = | |
96 | tst' "test12a" (fn _ => | |
97 | s2 = substring(s2, 0, size s2) | |
98 | andalso "" = substring(s2, size s2, 0) | |
99 | andalso "" = substring(s1, 0, 0)); | |
100 | ||
101 | val test12b = tst0 "test12b" ((substring(s2, ~1, 0) seq "WRONG") | |
102 | handle Subscript => "OK" | _ => "WRONG"); | |
103 | val test12c = tst0 "test12c" ((substring(s2, 11, 0) seq "WRONG") | |
104 | handle Subscript => "OK" | _ => "WRONG"); | |
105 | val test12d = tst0 "test12d" ((substring(s2, 0, 11) seq "WRONG") | |
106 | handle Subscript => "OK" | _ => "WRONG"); | |
107 | val test12e = tst0 "test12e" ((substring(s2, 10, 1) seq "WRONG") | |
108 | handle Subscript => "OK" | _ => "WRONG"); | |
109 | val test12f = | |
110 | tst' "test12f" (fn _ => | |
111 | "ABCDE" = substring(s2, 0, 5) | |
112 | andalso "FGHI" = substring(s2, 6, 4)); | |
113 | val test12g = | |
114 | tst0 "test12g" (case (Int.minInt, Int.maxInt) of | |
115 | (SOME min, SOME max) => | |
116 | ((substring("", max, max); substring("", min, min); "WRONG") | |
117 | handle Subscript => "OK" | _ => "WRONG") | |
118 | | _ => "OK"); | |
119 | ||
120 | val test13a = | |
121 | tst' "test13a" (fn _ => | |
122 | (translate (fn _ => "") s2 = "" | |
123 | andalso translate (fn x => str x) "" = "" | |
124 | andalso translate (fn x => str x) s2 = s2)); | |
125 | ||
126 | val test13b = | |
127 | tst' "test13b" (fn _ => | |
128 | (translate (fn c => if c = #"\t" then "XYZ " else str c) s2 | |
129 | = "ABCDEXYZ FGHI")); | |
130 | ||
131 | val test14 = | |
132 | tst' "test14" (fn _ => | |
133 | (tokens isSpace "" = [] | |
134 | andalso tokens isSpace " \t \n" = [] | |
135 | andalso tokens (fn c => c = #",") ",asd,,def,fgh" | |
136 | = ["asd","def","fgh"])); | |
137 | ||
138 | val test15 = | |
139 | tst' "test15" (fn _ => | |
140 | (fields isSpace "" = [""] | |
141 | andalso fields isSpace " \t \n" = ["","","","","","",""] | |
142 | andalso fields (fn c => c = #",") ",asd,,def,fgh" | |
143 | = ["","asd","","def","fgh"])); | |
144 | ||
145 | val test16a = | |
146 | tst' "test16a" (fn _ => | |
147 | EQUAL = compare(s1,s1) andalso EQUAL = compare(s2,s2) | |
148 | andalso LESS = compare("A", "B") | |
149 | andalso GREATER = compare("B", "A") | |
150 | andalso LESS = compare("ABCD", "ABCDE") | |
151 | andalso GREATER = compare("ABCDE", "ABCD")); | |
152 | ||
153 | val test16b = | |
154 | tst' "test16b" (fn _ => | |
155 | EQUAL = compare(s1,s1) andalso EQUAL = compare(s2,s2) | |
156 | andalso LESS = compare("A", "a") | |
157 | andalso GREATER = compare("b", "B") | |
158 | andalso LESS = compare("abcd", "abcde") | |
159 | andalso GREATER = compare("abcde", "abcd")); | |
160 | ||
161 | ||
162 | (* Test cases for SML string escape functions. *) | |
163 | ||
164 | val test17 = | |
165 | let fun chk (arg, res) = toString (str arg) = res | |
166 | val argResList = | |
167 | [(#"\000", "\\^@"), | |
168 | (#"\001", "\\^A"), | |
169 | (#"\006", "\\^F"), | |
170 | (#"\007", "\\a"), | |
171 | (#"\008", "\\b"), | |
172 | (#"\009", "\\t"), | |
173 | (#"\010", "\\n"), | |
174 | (#"\011", "\\v"), | |
175 | (#"\012", "\\f"), | |
176 | (#"\013", "\\r"), | |
177 | (#"\014", "\\^N"), | |
178 | (#"\031", "\\^_"), | |
179 | (#"\032", " "), | |
180 | (#"\126", "~"), | |
181 | (#"\\", "\\\\"), | |
182 | (#"\"", "\\\""), | |
183 | (#"A", "A"), | |
184 | (#"\127", "\\127"), | |
185 | (#"\128", "\\128"), | |
186 | (#"\255", "\\255")] | |
187 | val (arg, res) = (implode (map #1 argResList), | |
188 | concat (map #2 argResList)) | |
189 | in tst' "test17" (fn _ => List.all chk argResList | |
190 | andalso toString arg = res) | |
191 | end; | |
192 | ||
193 | val test18 = | |
194 | let val chars = CharVector.tabulate(256, chr) | |
195 | val l = CharVector.foldl (fn (e,l) => e :: l) [] chars | |
196 | val chars = implode l | |
197 | in tst' "test18" (fn _ => fromString(toString chars) = SOME chars) end | |
198 | ||
199 | val test19 = | |
200 | let fun chkFromString (arg, res) = fromString arg = SOME (str res) | |
201 | val argResList = | |
202 | [("A", #"A"), | |
203 | ("z", #"z"), | |
204 | ("@", #"@"), | |
205 | ("~", #"~"), | |
206 | ("\\a", #"\007"), | |
207 | ("\\b", #"\008"), | |
208 | ("\\t", #"\009"), | |
209 | ("\\n", #"\010"), | |
210 | ("\\v", #"\011"), | |
211 | ("\\f", #"\012"), | |
212 | ("\\r", #"\013"), | |
213 | ("\\\\", #"\\"), | |
214 | ("\\\"", #"\""), | |
215 | ("\\^@", #"\000"), | |
216 | ("\\^A", #"\001"), | |
217 | ("\\^Z", #"\026"), | |
218 | ("\\^_", #"\031"), | |
219 | ("\\000", #"\000"), | |
220 | ("\\097", #"a"), | |
221 | ("\\255", #"\255"), | |
222 | ("\\ \t\n\n \\A", #"A"), | |
223 | ("\\ \t\n\n \\z", #"z"), | |
224 | ("\\ \t\n\n \\@", #"@"), | |
225 | ("\\ \t\n\n \\~", #"~"), | |
226 | ("\\ \t\n\n \\\\n", #"\n"), | |
227 | ("\\ \t\n\n \\\\t", #"\t"), | |
228 | ("\\ \t\n\n \\\\\\", #"\\"), | |
229 | ("\\ \t\n\n \\\\\"", #"\""), | |
230 | ("\\ \t\n\n \\\\^@", #"\000"), | |
231 | ("\\ \t\n\n \\\\^A", #"\001"), | |
232 | ("\\ \t\n\n \\\\^Z", #"\026"), | |
233 | ("\\ \t\n\n \\\\^_", #"\031"), | |
234 | ("\\ \t\n\n \\\\000", #"\000"), | |
235 | ("\\ \t\n\n \\\\097", #"a"), | |
236 | ("\\ \t\n\n \\\\255", #"\255")] | |
237 | val (arg, res) = (concat (map #1 argResList), | |
238 | implode (map #2 argResList)) | |
239 | in | |
240 | tst' "test19" (fn _ => List.all chkFromString argResList | |
241 | andalso fromString arg = SOME res) | |
242 | end; | |
243 | ||
244 | val test20 = | |
245 | tst' "test20" (fn _ => List.all (fn arg => isSome (fromString arg)) | |
246 | ["\\", | |
247 | "\\c", | |
248 | "\\F", | |
249 | "\\e", | |
250 | "\\g", | |
251 | "\\N", | |
252 | "\\T", | |
253 | "\\1", | |
254 | "\\11", | |
255 | "\\256", | |
256 | "\\-65", | |
257 | "\\~65", | |
258 | "\\?", | |
259 | "\\^`", | |
260 | "\\^a", | |
261 | "\\^z", | |
262 | "\\ a", | |
263 | "\\ a\\B", | |
264 | "\\ \\"]); | |
265 | ||
266 | ||
267 | (* Test cases for C string escape functions *) | |
268 | ||
269 | val test21 = | |
270 | let val chars = CharVector.tabulate(256, chr) | |
271 | val l = CharVector.foldl (fn (e,l) => e :: l) [] chars | |
272 | val chars = implode l | |
273 | ||
274 | in tst' "test21" (fn _ => fromCString(toCString chars) = SOME chars) end; | |
275 | ||
276 | val test22 = | |
277 | let val argResList = | |
278 | [("\010", "\\n"), | |
279 | ("\009", "\\t"), | |
280 | ("\011", "\\v"), | |
281 | ("\008", "\\b"), | |
282 | ("\013", "\\r"), | |
283 | ("\012", "\\f"), | |
284 | ("\007", "\\a"), | |
285 | ("\\", "\\\\"), | |
286 | ("?", "\\?"), | |
287 | ("'", "\\'"), | |
288 | ("\"", "\\\"")] | |
289 | val (arg, res) = (concat (map #1 argResList), | |
290 | concat (map #2 argResList)) | |
291 | in | |
292 | tst' "test22" (fn _ => | |
293 | List.all (fn (arg, res) => toCString arg = res) argResList | |
294 | andalso toCString arg = res) | |
295 | end; | |
296 | ||
297 | val test23 = | |
298 | let fun checkFromCStringSucc (arg, res) = fromCString arg = SOME res | |
299 | val argResList = | |
300 | [("\\n", "\010"), | |
301 | ("\\t", "\009"), | |
302 | ("\\v", "\011"), | |
303 | ("\\b", "\008"), | |
304 | ("\\r", "\013"), | |
305 | ("\\f", "\012"), | |
306 | ("\\a", "\007"), | |
307 | ("\\\\", "\\"), | |
308 | ("\\?", "?"), | |
309 | ("\\'", "'"), | |
310 | ("\\\"", "\""), | |
311 | ("\\1", "\001"), | |
312 | ("\\11", "\009"), | |
313 | ("\\111", "\073"), | |
314 | ("\\1007", "\0647"), | |
315 | ("\\100A", "\064A"), | |
316 | ("\\0", "\000"), | |
317 | ("\\377", "\255"), | |
318 | ("\\18", "\0018"), | |
319 | ("\\178", "\0158"), | |
320 | ("\\1C", "\001C"), | |
321 | ("\\17C", "\015C"), | |
322 | ("\\x0", "\000"), | |
323 | ("\\xff", "\255"), | |
324 | ("\\xFF", "\255"), | |
325 | ("\\x1", "\001"), | |
326 | ("\\x11", "\017"), | |
327 | ("\\xag", "\010g"), | |
328 | ("\\xAAg", "\170g"), | |
329 | ("\\x0000000a", "\010"), | |
330 | ("\\x0000000a2", "\162"), | |
331 | ("\\x0000000ag", "\010g"), | |
332 | ("\\x0000000A", "\010"), | |
333 | ("\\x0000000A2", "\162"), | |
334 | ("\\x0000000Ag", "\010g"), | |
335 | ("\\x00000000000000000000000000000000000000000000000000000000000000011+", | |
336 | "\017+")] | |
337 | val (arg, res) = (concat (map #1 argResList), | |
338 | concat (map #2 argResList)) | |
339 | in | |
340 | tst' "test23" (fn _ => List.all checkFromCStringSucc argResList | |
341 | andalso fromCString arg = SOME res) | |
342 | end; | |
343 | ||
344 | val test24 = | |
345 | let fun checkFromCStringFail arg = isSome (fromCString arg) | |
346 | in | |
347 | tst' "test24" (fn _ => List.all checkFromCStringFail | |
348 | ["\\", | |
349 | "\\X", | |
350 | "\\=", | |
351 | "\\400", | |
352 | "\\777", | |
353 | "\\8", | |
354 | "\\9", | |
355 | "\\c", | |
356 | "\\d", | |
357 | "\\x", | |
358 | "\\x100", | |
359 | "\\xG"]) | |
360 | end; | |
361 | ||
362 | val test25 = | |
363 | tst' "test25" (fn _ => | |
364 | isPrefix "" "" | |
365 | andalso isPrefix "" "abcde" | |
366 | andalso isPrefix "a" "abcde" | |
367 | andalso isPrefix "abcd" "abcde" | |
368 | andalso isPrefix "abcde" "abcde" | |
369 | andalso not (isPrefix "abcde" "") | |
370 | andalso not (isPrefix "abcdef" "abcde") | |
371 | andalso not (isPrefix "Abcde" "abcde") | |
372 | andalso not (isPrefix "abcdE" "abcde")) | |
373 | ||
374 | end |