]> matita.cs.unibo.it Git - helm.git/blob - helm/DEVEL/pxp/pxp/rtests/reader/test_reader.ml
rebuilt
[helm.git] / helm / DEVEL / pxp / pxp / rtests / reader / test_reader.ml
1 open Pxp_reader;;
2 open Pxp_types;;
3 open Minilex;;
4
5 let make_channel s =
6   (* Returns a channel reading the bytes from the string s *)
7   let rd, wr = Unix.pipe() in
8   let ch_rd = Unix.in_channel_of_descr rd in
9   let ch_wr = Unix.out_channel_of_descr wr in
10   ignore
11     (Thread.create
12        (fun () ->
13           output_string ch_wr s;
14           close_out ch_wr;
15        )
16        ()
17     );
18   ch_rd
19 ;;
20
21 (**********************************************************************)
22
23 let t001 () =
24   (* Reads from a string (without recoding it), checks the lexbuf size *)
25   let s = "0123456789abc" in
26   let r = new resolve_read_this_string s in
27   r # init_rep_encoding `Enc_iso88591;
28   r # init_warner (new drop_warnings);
29   let lb = r # open_in Anonymous in
30   let c = nextchar lb in
31   assert (c = Some '0');
32   assert (lb.Lexing.lex_curr_pos = lb.Lexing.lex_buffer_len);
33   (* Note: the end of lb.lex_buffer is filled up, so lb.lex_curr_pos must
34    * now be at the end of the buffer indicating that the buffer is now
35    * empty.
36    *)
37   ignore(nextchar lb);
38   ignore(nextchar lb);
39   ignore(nextchar lb);
40   ignore(nextchar lb);
41   ignore(nextchar lb);
42   ignore(nextchar lb);
43   ignore(nextchar lb);
44   ignore(nextchar lb);
45   let c = nextchar lb in
46   assert (c = Some '9');
47   assert (lb.Lexing.lex_curr_pos = lb.Lexing.lex_buffer_len);
48   r # change_encoding "";
49   let c = nextchar lb in
50   assert (c = Some 'a');
51   assert (lb.Lexing.lex_curr_pos < lb.Lexing.lex_buffer_len);
52   ignore(nextchar lb);
53   let c = nextchar lb in
54   assert (c = Some 'c');
55   let c = nextchar lb in
56   assert (c = None);
57   r # close_in;
58   true
59 ;;
60
61
62 let t002 () =
63   (* Like t001, but reads from a channel *)
64   let ch = make_channel "0123456789abc" in
65   let r = new resolve_read_this_channel ch in
66   r # init_rep_encoding `Enc_iso88591;
67   r # init_warner (new drop_warnings);
68   let lb = r # open_in Anonymous in
69   let c = nextchar lb in
70   assert (c = Some '0');
71   assert (lb.Lexing.lex_curr_pos = lb.Lexing.lex_buffer_len);
72   (* Note: the end of lb.lex_buffer is filled up, so lb.lex_curr_pos must
73    * now be at the end of the buffer indicating that the buffer is now
74    * empty.
75    *)
76   ignore(nextchar lb);
77   ignore(nextchar lb);
78   ignore(nextchar lb);
79   ignore(nextchar lb);
80   ignore(nextchar lb);
81   ignore(nextchar lb);
82   ignore(nextchar lb);
83   ignore(nextchar lb);
84   let c = nextchar lb in
85   assert (c = Some '9');
86   assert (lb.Lexing.lex_curr_pos = lb.Lexing.lex_buffer_len);
87   r # change_encoding "";
88   let c = nextchar lb in
89   assert (c = Some 'a');
90   assert (lb.Lexing.lex_curr_pos < lb.Lexing.lex_buffer_len);
91   ignore(nextchar lb);
92   let c = nextchar lb in
93   assert (c = Some 'c');
94   let c = nextchar lb in
95   assert (c = None);
96   r # close_in;
97   true
98 ;;
99
100
101 let t003 () =
102   (* Tests non-automatic encoding conversion from ISO-8859-1 to UTF-8 *)
103   let s = "0«»°áàâãäÁÀÂÃÄéèêëíìîïÍÌÎÏóòôõøöÓÒÔÕØÖúùûüýÿÝßç¡¿ñÑ" in
104   let r = new resolve_read_this_string ~fixenc:`Enc_iso88591 s in
105   r # init_rep_encoding `Enc_utf8;
106   r # init_warner (new drop_warnings);
107   let lb = r # open_in Anonymous in
108   let c = ref (nextchar lb) in
109   assert (!c = Some '0');
110   assert (lb.Lexing.lex_curr_pos < lb.Lexing.lex_buffer_len);
111   (* Note: because we initialize the resolver with ~fixenc, the resolver can
112    * fill the buffer with more than one byte from the beginning.
113    *)
114   let u = ref "" in
115   while !c <> None do
116     ( match !c with
117           Some x -> u := !u ^ String.make 1 x
118         | None -> ()
119     );
120     c := nextchar lb
121   done;
122   r # close_in;
123   !u = "0\194\171\194\187\194\176\195\161\195\160\195\162\195\163\195\164\195\129\195\128\195\130\195\131\195\132\195\169\195\168\195\170\195\171\195\173\195\172\195\174\195\175\195\141\195\140\195\142\195\143\195\179\195\178\195\180\195\181\195\184\195\182\195\147\195\146\195\148\195\149\195\152\195\150\195\186\195\185\195\187\195\188\195\189\195\191\195\157\195\159\195\167\194\161\194\191\195\177\195\145"
124 ;;
125
126
127 let t004 () =
128   (* Tests non-automatic encoding conversion from UTF-8 to ISO-8859-1 *)
129   let s = "0\194\171\194\187\194\176\195\161\195\160\195\162\195\163\195\164\195\129\195\128\195\130\195\131\195\132\195\169\195\168\195\170\195\171\195\173\195\172\195\174\195\175\195\141\195\140\195\142\195\143\195\179\195\178\195\180\195\181\195\184\195\182\195\147\195\146\195\148\195\149\195\152\195\150\195\186\195\185\195\187\195\188\195\189\195\191\195\157\195\159\195\167\194\161\194\191\195\177\195\145" in
130   let r = new resolve_read_this_string ~fixenc:`Enc_utf8 s in
131   r # init_rep_encoding `Enc_iso88591;
132   r # init_warner (new drop_warnings);
133   let lb = r # open_in Anonymous in
134   let c = ref (nextchar lb) in
135   assert (!c = Some '0');
136   assert (lb.Lexing.lex_curr_pos < lb.Lexing.lex_buffer_len);
137   (* Note: because we initialize the resolver with ~fixenc, the resolver can
138    * fill the buffer with more than one byte from the beginning.
139    *)
140   let u = ref "" in
141   while !c <> None do
142     ( match !c with
143           Some x -> u := !u ^ String.make 1 x
144         | None -> ()
145     );
146     c := nextchar lb
147   done;
148   r # close_in;
149   !u = "0«»°áàâãäÁÀÂÃÄéèêëíìîïÍÌÎÏóòôõøöÓÒÔÕØÖúùûüýÿÝßç¡¿ñÑ"
150 ;;
151
152
153 let t005 () =
154   (* Tests automatic encoding conversion from UTF-8 to ISO-8859-1 *)
155   let s = "0\194\171\194\187\194\176\195\161\195\160\195\162\195\163\195\164\195\129\195\128\195\130\195\131\195\132\195\169\195\168\195\170\195\171\195\173\195\172\195\174\195\175\195\141\195\140\195\142\195\143\195\179\195\178\195\180\195\181\195\184\195\182\195\147\195\146\195\148\195\149\195\152\195\150\195\186\195\185\195\187\195\188\195\189\195\191\195\157\195\159\195\167\194\161\194\191\195\177\195\145" in
156   let r = new resolve_read_this_string s in
157   r # init_rep_encoding `Enc_iso88591;
158   r # init_warner (new drop_warnings);
159   let lb = r # open_in Anonymous in
160   let c = ref (nextchar lb) in
161   assert (!c = Some '0');
162   assert (lb.Lexing.lex_curr_pos = lb.Lexing.lex_buffer_len);
163   let u = ref "" in
164   while !c <> None do
165     ( match !c with
166           Some x -> u := !u ^ String.make 1 x
167         | None -> ()
168     );
169     c := nextchar lb
170   done;
171   r # close_in;
172   !u = "0«»°áàâãäÁÀÂÃÄéèêëíìîïÍÌÎÏóòôõøöÓÒÔÕØÖúùûüýÿÝßç¡¿ñÑ"
173 ;;
174
175
176 let t006 () =
177   (* Tests automatic encoding conversion from UTF-16-BE to UTF-8 
178    * This variant invokes change_encoding early.
179    *)
180   let s = "\254\255\0000\000«\000»\000°\000á\000à\000â\000ã\000ä\000Á\000À\000Â\000Ã\000Ä\000é\000è\000ê\000ë\000í\000ì\000î\000ï\000Í\000Ì\000Î\000Ï\000ó\000ò\000ô\000õ\000ø\000ö\000Ó\000Ò\000Ô\000Õ\000Ø\000Ö\000ú\000ù\000û\000ü\000ý\000ÿ\000Ý\000ß\000ç\000¡\000¿\000ñ\000Ñ" in
181   let r = new resolve_read_this_string s in
182   r # init_rep_encoding `Enc_utf8;
183   r # init_warner (new drop_warnings);
184   let lb = r # open_in Anonymous in
185   let c = ref (nextchar lb) in
186   assert (!c = Some '0');
187   assert (lb.Lexing.lex_curr_pos = lb.Lexing.lex_buffer_len);
188   r # change_encoding "";
189   let u = ref "" in
190   while !c <> None do
191     ( match !c with
192           Some x -> u := !u ^ String.make 1 x
193         | None -> ()
194     );
195     c := nextchar lb
196   done;
197   r # close_in;
198   !u = "0\194\171\194\187\194\176\195\161\195\160\195\162\195\163\195\164\195\129\195\128\195\130\195\131\195\132\195\169\195\168\195\170\195\171\195\173\195\172\195\174\195\175\195\141\195\140\195\142\195\143\195\179\195\178\195\180\195\181\195\184\195\182\195\147\195\146\195\148\195\149\195\152\195\150\195\186\195\185\195\187\195\188\195\189\195\191\195\157\195\159\195\167\194\161\194\191\195\177\195\145"
199 ;;
200
201
202 let t007 () =
203   (* Tests automatic encoding conversion from UTF-16-BE to UTF-8 
204    * This variant does not invoke change_encoding
205    *)
206   let s = "\254\255\0000\000«\000»\000°\000á\000à\000â\000ã\000ä\000Á\000À\000Â\000Ã\000Ä\000é\000è\000ê\000ë\000í\000ì\000î\000ï\000Í\000Ì\000Î\000Ï\000ó\000ò\000ô\000õ\000ø\000ö\000Ó\000Ò\000Ô\000Õ\000Ø\000Ö\000ú\000ù\000û\000ü\000ý\000ÿ\000Ý\000ß\000ç\000¡\000¿\000ñ\000Ñ" in
207   let r = new resolve_read_this_string s in
208   r # init_rep_encoding `Enc_utf8;
209   r # init_warner (new drop_warnings);
210   let lb = r # open_in Anonymous in
211   let c = ref (nextchar lb) in
212   assert (!c = Some '0');
213   assert (lb.Lexing.lex_curr_pos = lb.Lexing.lex_buffer_len);
214   let u = ref "" in
215   while !c <> None do
216     ( match !c with
217           Some x -> u := !u ^ String.make 1 x
218         | None -> ()
219     );
220     c := nextchar lb
221   done;
222   r # close_in;
223   !u = "0\194\171\194\187\194\176\195\161\195\160\195\162\195\163\195\164\195\129\195\128\195\130\195\131\195\132\195\169\195\168\195\170\195\171\195\173\195\172\195\174\195\175\195\141\195\140\195\142\195\143\195\179\195\178\195\180\195\181\195\184\195\182\195\147\195\146\195\148\195\149\195\152\195\150\195\186\195\185\195\187\195\188\195\189\195\191\195\157\195\159\195\167\194\161\194\191\195\177\195\145"
224 ;;
225
226 (**********************************************************************)
227
228 let t100 () =
229   (* Reads from a file without recoding it *)
230   let r = new resolve_as_file () in
231   r # init_rep_encoding `Enc_utf8;
232   r # init_warner (new drop_warnings);
233   let cwd = Sys.getcwd() in
234   let lb = r # open_in (System ("file://localhost" ^ cwd ^ "/t100.dat")) in
235   let c = nextchar lb in
236   assert (c = Some '0');
237   assert (lb.Lexing.lex_curr_pos = lb.Lexing.lex_buffer_len);
238   (* Note: the end of lb.lex_buffer is filled up, so lb.lex_curr_pos must
239    * now be at the end of the buffer indicating that the buffer is now
240    * empty.
241    *)
242   for i = 1 to 8 do
243     ignore(nextchar lb);
244   done;
245   let c = nextchar lb in
246   assert (c = Some '9');
247   r # close_in;
248   true
249 ;;
250
251 let t101 () =
252   (* Reads from a file without recoding it *)
253   let r = new resolve_as_file () in
254   r # init_rep_encoding `Enc_utf8;
255   r # init_warner (new drop_warnings);
256   let cwd = Sys.getcwd() in
257   let lb = r # open_in (System ("//localhost" ^ cwd ^ "/t100.dat")) in
258   let c = nextchar lb in
259   assert (c = Some '0');
260   assert (lb.Lexing.lex_curr_pos = lb.Lexing.lex_buffer_len);
261   (* Note: the end of lb.lex_buffer is filled up, so lb.lex_curr_pos must
262    * now be at the end of the buffer indicating that the buffer is now
263    * empty.
264    *)
265   for i = 1 to 8 do
266     ignore(nextchar lb);
267   done;
268   let c = nextchar lb in
269   assert (c = Some '9');
270   r # close_in;
271   true
272 ;;
273
274 let t102 () =
275   (* Reads from a file without recoding it *)
276   let r = new resolve_as_file () in
277   r # init_rep_encoding `Enc_utf8;
278   r # init_warner (new drop_warnings);
279   let cwd = Sys.getcwd() in
280   let lb = r # open_in (System (cwd ^ "/t100.dat")) in
281   let c = nextchar lb in
282   assert (c = Some '0');
283   assert (lb.Lexing.lex_curr_pos = lb.Lexing.lex_buffer_len);
284   (* Note: the end of lb.lex_buffer is filled up, so lb.lex_curr_pos must
285    * now be at the end of the buffer indicating that the buffer is now
286    * empty.
287    *)
288   for i = 1 to 8 do
289     ignore(nextchar lb);
290   done;
291   let c = nextchar lb in
292   assert (c = Some '9');
293   r # close_in;
294   true
295 ;;
296
297 let t103 () =
298   (* Reads from a file without recoding it *)
299   let r = new resolve_as_file () in
300   r # init_rep_encoding `Enc_utf8;
301   r # init_warner (new drop_warnings);
302   let lb = r # open_in (System "t100.dat") in
303   let c = nextchar lb in
304   assert (c = Some '0');
305   assert (lb.Lexing.lex_curr_pos = lb.Lexing.lex_buffer_len);
306   (* Note: the end of lb.lex_buffer is filled up, so lb.lex_curr_pos must
307    * now be at the end of the buffer indicating that the buffer is now
308    * empty.
309    *)
310   for i = 1 to 8 do
311     ignore(nextchar lb);
312   done;
313   let c = nextchar lb in
314   assert (c = Some '9');
315   r # close_in;
316   true
317 ;;
318
319 (**********************************************************************)
320
321 let t110 () =
322   (* Checks whether relative URLs are properly handled *)
323   let r = new resolve_as_file () in
324   r # init_rep_encoding `Enc_utf8;
325   r # init_warner (new drop_warnings);
326   let lb = r # open_in (System "t100.dat") in
327   let c = nextchar lb in
328   assert (c = Some '0');
329   assert (lb.Lexing.lex_curr_pos = lb.Lexing.lex_buffer_len);
330   (* Note: the end of lb.lex_buffer is filled up, so lb.lex_curr_pos must
331    * now be at the end of the buffer indicating that the buffer is now
332    * empty.
333    *)
334   for i = 1 to 8 do
335     ignore(nextchar lb);
336   done;
337   let r' = r # clone in
338   let lb' = r' # open_in (System "t100.dat") in
339   let c = nextchar lb' in
340   assert (c = Some '0');
341   for i = 1 to 8 do
342     ignore(nextchar lb');
343   done;
344   let c = nextchar lb' in
345   assert (c = Some '9');
346   r' # close_in;
347   let c = nextchar lb in
348   assert (c = Some '9');
349   r # close_in;
350   true
351 ;;
352
353 (**********************************************************************)
354 (* Tests whether the encoding handling of System IDs is okay *)
355
356 let t200 () =
357   (* Check the technique for the following tests:
358    * [Checks also 'combine' to some extent.)
359    *)
360   let r1 = new resolve_read_this_string
361              ~id:(System "b.xml")
362              ~fixenc:`Enc_iso88591
363              "ae" in
364   let r2 = new resolve_read_this_string
365              ~id:(System "a.xml")
366              ~fixenc:`Enc_iso88591
367              "<!DOCTYPE a [ <!ELEMENT a ANY> <!ENTITY ae SYSTEM 'b.xml'> ]> <a>&ae;</a>" in
368   let r = new combine [ r1; r2 ] in
369   (* It should now be possible to resolve &ae; *)
370   let _ =
371     Pxp_yacc.parse_document_entity 
372       { Pxp_yacc.default_config with Pxp_yacc.encoding = `Enc_iso88591 }
373       (Pxp_yacc.ExtID(System "a.xml", r))
374       Pxp_yacc.default_spec
375   in
376   true
377 ;;
378
379
380 let t201 () =
381   (* Check that System IDs are converted to UTF-8. rep_encoding = ISO-8859-1 *)
382   let r1 = new resolve_read_this_string
383              ~id:(System "\195\164.xml")      (* This is an UTF-8 "ä"! *)
384              ~fixenc:`Enc_iso88591
385              "ae" in
386   let r2 = new resolve_read_this_string
387              ~id:(System "a.xml")
388              ~fixenc:`Enc_iso88591
389              "<!DOCTYPE a [ <!ELEMENT a ANY> <!ENTITY ae SYSTEM 'ä.xml'> ]> <a>&ae;</a>" in
390   let r = new combine [ r1; r2 ] in
391   (* It should now be possible to resolve &ae; *)
392   let _ =
393     Pxp_yacc.parse_document_entity 
394       { Pxp_yacc.default_config with Pxp_yacc.encoding = `Enc_iso88591 }
395       (Pxp_yacc.ExtID(System "a.xml", r))
396       Pxp_yacc.default_spec
397   in
398   true
399 ;;
400
401
402 let t202 () =
403   (* Check that System IDs are converted to UTF-8. rep_encoding = UTF-8 *)
404   let r1 = new resolve_read_this_string
405              ~id:(System "\195\164.xml")
406              ~fixenc:`Enc_iso88591
407              "ae" in
408   let r2 = new resolve_read_this_string
409              ~id:(System "a.xml")
410              ~fixenc:`Enc_iso88591
411              "<!DOCTYPE a [ <!ELEMENT a ANY> <!ENTITY ae SYSTEM 'ä.xml'> ]> <a>&ae;</a>" in
412   let r = new combine [ r1; r2 ] in
413   (* It should now be possible to resolve &ae; *)
414   let _ =
415     Pxp_yacc.parse_document_entity 
416       { Pxp_yacc.default_config with Pxp_yacc.encoding = `Enc_utf8 }
417       (Pxp_yacc.ExtID(System "a.xml", r))
418       Pxp_yacc.default_spec
419   in
420   true
421 ;;
422
423 (**********************************************************************)
424
425 let test f n =
426   try
427     print_string ("Reader test " ^ n);
428     flush stdout;
429     if f() then
430       print_endline " ok"
431     else
432       print_endline " FAILED!!!!";
433   with
434       error ->
435         print_endline (" FAILED: " ^ string_of_exn error)
436 ;;
437
438 test t001 "001";;
439 test t002 "002";;
440 test t003 "003";;
441 test t004 "004";;
442 test t005 "005";;
443 test t006 "006";;
444 test t007 "007";;
445
446 test t100 "100";;
447 test t101 "101";;
448 test t102 "102";;
449 test t103 "103";;
450
451 test t110 "110";;
452
453 test t200 "200";;
454 test t201 "201";;
455 test t202 "202";;