1   
2   
3   
4   
5   
6   
7   
8   package org.dom4j;
9   
10  import junit.textui.TestRunner;
11  
12  import java.io.ByteArrayInputStream;
13  import java.io.ByteArrayOutputStream;
14  import java.io.StringReader;
15  import java.io.StringWriter;
16  
17  import org.dom4j.io.OutputFormat;
18  import org.dom4j.io.SAXReader;
19  import org.dom4j.io.XMLWriter;
20  import org.dom4j.tree.BaseElement;
21  import org.dom4j.tree.DefaultDocument;
22  
23  import org.xml.sax.ContentHandler;
24  import org.xml.sax.SAXException;
25  import org.xml.sax.helpers.AttributesImpl;
26  
27  /***
28   * A simple test harness to check that the XML Writer works
29   * 
30   * @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>
31   * @version $Revision: 1.7.2.1 $
32   */
33  public class XMLWriterTest extends AbstractTestCase {
34      protected static final boolean VERBOSE = false;
35  
36      public static void main(String[] args) {
37          TestRunner.run(XMLWriterTest.class);
38      }
39  
40      
41      
42      public void testBug1180791() throws Exception {
43          String xml = "<?xml version=\"1.0\"?><root><foo>bar</foo></root>";
44  
45          SAXReader reader = new SAXReader();
46          Document doc = reader.read(new StringReader(xml));
47          
48          OutputFormat format = new OutputFormat();
49          format.setNewlines(true);
50          
51          
52          StringWriter writer = new StringWriter();
53          XMLWriter xmlwriter = new XMLWriter(writer, format);
54          xmlwriter.write(doc);
55          System.out.println(writer.toString());
56  
57          
58          doc = reader.read(new StringReader(writer.toString()));
59          writer = new StringWriter();
60          xmlwriter = new XMLWriter(writer, format);
61          xmlwriter.write(doc);
62          System.out.println(writer.toString());
63      }
64  
65      public void testBug1119733() throws Exception {
66          Document doc = DocumentHelper
67                  .parseText("<root><code>foo</code> bar</root>");
68  
69          StringWriter out = new StringWriter();
70          XMLWriter writer = new XMLWriter(out, OutputFormat.createPrettyPrint());
71          writer.write(doc);
72          writer.close();
73  
74          String xml = out.toString();
75  
76          System.out.println(xml);
77          assertEquals("whitespace problem", -1, xml.indexOf("</code>bar"));
78      }
79  
80      public void testBug1119733WithSAXEvents() throws Exception {
81          StringWriter out = new StringWriter();
82          XMLWriter writer = new XMLWriter(out, OutputFormat.createPrettyPrint());
83          writer.startDocument();
84          writer.startElement(null, "root", "root", new AttributesImpl());
85          writer.startElement(null, "code", "code", new AttributesImpl());
86          writer.characters(new char[] { 'f', 'o', 'o' }, 0, 3);
87          writer.endElement(null, "code", "code");
88          writer.characters(new char[] { ' ', 'b', 'a', 'r' }, 0, 4);
89          writer.endElement(null, "root", "root");
90          writer.endDocument();
91          writer.close();
92  
93          String xml = out.toString();
94  
95          System.out.println(xml);
96          assertEquals("whitespace problem", -1, xml.indexOf("</code>bar"));
97      }
98  
99      public void testWriter() throws Exception {
100         Object object = document;
101         StringWriter out = new StringWriter();
102 
103         XMLWriter writer = new XMLWriter(out);
104         writer.write(object);
105         writer.close();
106 
107         String text = out.toString();
108 
109         if (VERBOSE) {
110             log("Text output is [");
111             log(text);
112             log("]. Done");
113         }
114 
115         assertTrue("Output text is bigger than 10 characters",
116                 text.length() > 10);
117     }
118 
119     public void testEncodingFormats() throws Exception {
120         testEncoding("UTF-8");
121         testEncoding("UTF-16");
122         testEncoding("ISO-8859-1");
123     }
124 
125     public void testWritingEmptyElement() throws Exception {
126         Document doc = DocumentFactory.getInstance().createDocument();
127         Element grandFather = doc.addElement("grandfather");
128         Element parent1 = grandFather.addElement("parent");
129         Element child1 = parent1.addElement("child1");
130         Element child2 = parent1.addElement("child2");
131         child2.setText("test");
132 
133         Element parent2 = grandFather.addElement("parent");
134         Element child3 = parent2.addElement("child3");
135         child3.setText("test");
136 
137         StringWriter buffer = new StringWriter();
138         OutputFormat format = OutputFormat.createPrettyPrint();
139         XMLWriter writer = new XMLWriter(buffer, format);
140         writer.write(doc);
141 
142         String xml = buffer.toString();
143 
144         System.out.println(xml);
145 
146         assertTrue("child2 not present",
147                 xml.indexOf("<child2>test</child2>") != -1);
148     }
149 
150     protected void testEncoding(String encoding) throws Exception {
151         ByteArrayOutputStream out = new ByteArrayOutputStream();
152 
153         OutputFormat format = OutputFormat.createPrettyPrint();
154         format.setEncoding(encoding);
155 
156         XMLWriter writer = new XMLWriter(out, format);
157         writer.write(document);
158         writer.close();
159 
160         log("Wrote to encoding: " + encoding);
161     }
162 
163     public void testWriterBug() throws Exception {
164         Element project = new BaseElement("project");
165         Document doc = new DefaultDocument(project);
166 
167         ByteArrayOutputStream out = new ByteArrayOutputStream();
168         XMLWriter writer = new XMLWriter(out, new OutputFormat("\t", true,
169                 "ISO-8859-1"));
170         writer.write(doc);
171 
172         ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
173         SAXReader reader = new SAXReader();
174         Document doc2 = reader.read(in);
175 
176         assertTrue("Generated document has a root element", doc2
177                 .getRootElement() != null);
178         assertEquals("Generated document has corrent named root element", doc2
179                 .getRootElement().getName(), "project");
180     }
181 
182     public void testNamespaceBug() throws Exception {
183         Document doc = DocumentHelper.createDocument();
184 
185         Element root = doc.addElement("root", "ns1");
186         Element child1 = root.addElement("joe", "ns2");
187         child1.addElement("zot", "ns1");
188 
189         StringWriter out = new StringWriter();
190         XMLWriter writer = new XMLWriter(out, OutputFormat.createPrettyPrint());
191         writer.write(doc);
192 
193         String text = out.toString();
194 
195         
196         Document doc2 = DocumentHelper.parseText(text);
197         root = doc2.getRootElement();
198         assertEquals("root has incorrect namespace", "ns1", root
199                 .getNamespaceURI());
200 
201         Element joe = (Element) root.elementIterator().next();
202         assertEquals("joe has correct namespace", "ns2", joe.getNamespaceURI());
203 
204         Element zot = (Element) joe.elementIterator().next();
205         assertEquals("zot has correct namespace", "ns1", zot.getNamespaceURI());
206     }
207 
208     /***
209      * This test harness was supplied by Lari Hotari
210      * 
211      * @throws Exception DOCUMENT ME!
212      */
213     public void testContentHandler() throws Exception {
214         StringWriter out = new StringWriter();
215         OutputFormat format = OutputFormat.createPrettyPrint();
216         format.setEncoding("iso-8859-1");
217 
218         XMLWriter writer = new XMLWriter(out, format);
219         generateXML(writer);
220         writer.close();
221 
222         String text = out.toString();
223 
224         if (VERBOSE) {
225             log("Created XML");
226             log(text);
227         }
228 
229         
230         Document doc = DocumentHelper.parseText(text);
231         String value = doc.valueOf("/processes[@name='arvojoo']");
232         assertEquals("Document contains the correct text", "jeejee", value);
233     }
234 
235     /***
236      * This test was provided by Manfred Lotz
237      * 
238      * @throws Exception DOCUMENT ME!
239      */
240     public void testWhitespaceBug() throws Exception {
241         String notes = "<notes> This is a      multiline\n\rentry</notes>";
242         Document doc = DocumentHelper.parseText(notes);
243 
244         OutputFormat format = new OutputFormat();
245         format.setEncoding("UTF-8");
246         format.setIndentSize(4);
247         format.setNewlines(true);
248         format.setTrimText(true);
249         format.setExpandEmptyElements(true);
250 
251         StringWriter buffer = new StringWriter();
252         XMLWriter writer = new XMLWriter(buffer, format);
253         writer.write(doc);
254 
255         String xml = buffer.toString();
256         log(xml);
257 
258         Document doc2 = DocumentHelper.parseText(xml);
259         String text = doc2.valueOf("/notes");
260         String expected = "This is a multiline entry";
261 
262         assertEquals("valueOf() returns the correct text padding", expected,
263                 text);
264 
265         assertEquals("getText() returns the correct text padding", expected,
266                 doc2.getRootElement().getText());
267     }
268 
269     /***
270      * This test was provided by Manfred Lotz
271      * 
272      * @throws Exception DOCUMENT ME!
273      */
274     public void testWhitespaceBug2() throws Exception {
275         Document doc = DocumentHelper.createDocument();
276         Element root = doc.addElement("root");
277         Element meaning = root.addElement("meaning");
278         meaning.addText("to li");
279         meaning.addText("ve");
280 
281         OutputFormat format = new OutputFormat();
282         format.setEncoding("UTF-8");
283         format.setIndentSize(4);
284         format.setNewlines(true);
285         format.setTrimText(true);
286         format.setExpandEmptyElements(true);
287 
288         StringWriter buffer = new StringWriter();
289         XMLWriter writer = new XMLWriter(buffer, format);
290         writer.write(doc);
291 
292         String xml = buffer.toString();
293         log(xml);
294 
295         Document doc2 = DocumentHelper.parseText(xml);
296         String text = doc2.valueOf("/root/meaning");
297         String expected = "to live";
298 
299         assertEquals("valueOf() returns the correct text padding", expected,
300                 text);
301 
302         assertEquals("getText() returns the correct text padding", expected,
303                 doc2.getRootElement().element("meaning").getText());
304     }
305 
306     public void testPadding() throws Exception {
307         Document doc = DocumentFactory.getInstance().createDocument();
308         Element root = doc.addElement("root");
309         root.addText("prefix    ");
310         root.addElement("b");
311         root.addText("      suffix");
312 
313         OutputFormat format = new OutputFormat("", false);
314         format.setOmitEncoding(true);
315         format.setSuppressDeclaration(true);
316         format.setExpandEmptyElements(true);
317         format.setPadText(true);
318         format.setTrimText(true);
319 
320         StringWriter buffer = new StringWriter();
321         XMLWriter writer = new XMLWriter(buffer, format);
322         writer.write(doc);
323 
324         String xml = buffer.toString();
325 
326         System.out.println("xml: " + xml);
327 
328         String expected = "<root>prefix <b></b> suffix</root>";
329         assertEquals(expected, xml);
330     }
331 
332     public void testPadding2() throws Exception {
333         Document doc = DocumentFactory.getInstance().createDocument();
334         Element root = doc.addElement("root");
335         root.addText("prefix");
336         root.addElement("b");
337         root.addText("suffix");
338 
339         OutputFormat format = new OutputFormat("", false);
340         format.setOmitEncoding(true);
341         format.setSuppressDeclaration(true);
342         format.setExpandEmptyElements(true);
343         format.setPadText(true);
344         format.setTrimText(true);
345 
346         StringWriter buffer = new StringWriter();
347         XMLWriter writer = new XMLWriter(buffer, format);
348         writer.write(doc);
349 
350         String xml = buffer.toString();
351 
352         System.out.println("xml: " + xml);
353 
354         String expected = "<root>prefix<b></b>suffix</root>";
355         assertEquals(expected, xml);
356     }
357 
358     
359 
360 
361     public void testPrettyPrinting() throws Exception {
362         Document doc = DocumentFactory.getInstance().createDocument();
363         doc.addElement("summary").addAttribute("date", "6/7/8").addElement(
364                 "orderline").addText("puffins").addElement("ranjit")
365                 .addComment("Ranjit is a happy Puffin");
366 
367         XMLWriter writer = new XMLWriter(System.out, OutputFormat
368                 .createPrettyPrint());
369         writer.write(doc);
370 
371         doc = DocumentFactory.getInstance().createDocument();
372         doc.addElement("summary").addAttribute("date", "6/7/8").addElement(
373                 "orderline").addText("puffins").addElement("ranjit")
374                 .addComment("Ranjit is a happy Puffin").addComment(
375                         "another comment").addElement("anotherElement");
376         writer.write(doc);
377     }
378 
379     public void testAttributeQuotes() throws Exception {
380         Document doc = DocumentFactory.getInstance().createDocument();
381         doc.addElement("root").addAttribute("test", "text with ' in it");
382 
383         StringWriter out = new StringWriter();
384         XMLWriter writer = new XMLWriter(out, OutputFormat
385                 .createCompactFormat());
386         writer.write(doc);
387 
388         String expected = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
389                 + "<root test=\"text with ' in it\"/>";
390         assertEquals(expected, out.toString());
391     }
392 
393     public void testBug868408() throws Exception {
394         Document doc = getDocument("/xml/web.xml");
395         Document doc2 = DocumentHelper.parseText(doc.asXML());
396         assertEquals(doc.asXML(), doc2.asXML());
397     }
398 
399     public void testBug923882() throws Exception {
400         Document doc = DocumentFactory.getInstance().createDocument();
401         Element root = doc.addElement("root");
402         root.addText("this is ");
403         root.addText(" sim");
404         root.addText("ple text ");
405         root.addElement("child");
406         root.addText(" contai");
407         root.addText("ning spaces and");
408         root.addText(" multiple textnodes");
409 
410         OutputFormat format = new OutputFormat();
411         format.setEncoding("UTF-8");
412         format.setIndentSize(4);
413         format.setNewlines(true);
414         format.setTrimText(true);
415         format.setExpandEmptyElements(true);
416 
417         StringWriter buffer = new StringWriter();
418         XMLWriter writer = new XMLWriter(buffer, format);
419         writer.write(doc);
420 
421         String xml = buffer.toString();
422         log(xml);
423 
424         int start = xml.indexOf("<root");
425         int end = xml.indexOf("/root>") + 6;
426         String eol = "\n"; 
427         String expected = "<root>this is simple text" + eol
428                 + "    <child></child>containing spaces and multiple textnodes"
429                 + eol + "</root>";
430         System.out.println("Expected:");
431         System.out.println(expected);
432         System.out.println("Obtained:");
433         System.out.println(xml.substring(start, end));
434         assertEquals(expected, xml.substring(start, end));
435     }
436 
437     public void testEscapeXML() throws Exception {
438         ByteArrayOutputStream os = new ByteArrayOutputStream();
439         OutputFormat format = new OutputFormat(null, false, "ISO-8859-2");
440         format.setSuppressDeclaration(true);
441 
442         XMLWriter writer = new XMLWriter(os, format);
443 
444         Document document = DocumentFactory.getInstance().createDocument();
445         Element root = document.addElement("root");
446         root.setText("bla &#c bla");
447 
448         writer.write(document);
449 
450         String result = os.toString();
451         System.out.println(result);
452 
453         Document doc2 = DocumentHelper.parseText(result);
454         doc2.normalize(); 
455         System.out.println(doc2.getRootElement().getText());
456         assertNodesEqual(document, doc2);
457     }
458 
459     public void testWriteEntities() throws Exception {
460         String xml = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n"
461                 + "<!DOCTYPE xml [<!ENTITY copy \"©\"> "
462                 + "<!ENTITY trade \"™\"> "
463                 + "<!ENTITY deg \"°\"> " + "<!ENTITY gt \">\"> "
464                 + "<!ENTITY sup2 \"²\"> "
465                 + "<!ENTITY frac14 \"¼\"> "
466                 + "<!ENTITY quot \""\"> "
467                 + "<!ENTITY frac12 \"½\"> "
468                 + "<!ENTITY euro \"€\"> "
469                 + "<!ENTITY Omega \"Ω\"> ]>\n" + "<root />";
470 
471         SAXReader reader = new SAXReader("org.apache.xerces.parsers.SAXParser");
472         reader.setIncludeInternalDTDDeclarations(true);
473 
474         Document doc = reader.read(new StringReader(xml));
475         StringWriter wr = new StringWriter();
476         XMLWriter writer = new XMLWriter(wr);
477         writer.write(doc);
478 
479         String xml2 = wr.toString();
480         System.out.println(xml2);
481 
482         Document doc2 = DocumentHelper.parseText(xml2);
483 
484         assertNodesEqual(doc, doc2);
485     }
486 
487     public void testEscapeChars() throws Exception {
488         Document document = DocumentFactory.getInstance().createDocument();
489         Element root = document.addElement("root");
490         root.setText("blahblah " + '\u008f');
491 
492         XMLWriter writer = new XMLWriter();
493         StringWriter strWriter = new StringWriter();
494         writer.setWriter(strWriter);
495         writer.setMaximumAllowedCharacter(127);
496         writer.write(document);
497 
498         String xml = strWriter.toString();
499     }
500 
501     public void testEscapeText() throws SAXException {
502         StringWriter writer = new StringWriter();
503         XMLWriter xmlWriter = new XMLWriter(writer);
504         xmlWriter.setEscapeText(false);
505 
506         String txt = "<test></test>";
507 
508         xmlWriter.startDocument();
509         xmlWriter.characters(txt.toCharArray(), 0, txt.length());
510         xmlWriter.endDocument();
511 
512         String output = writer.toString();
513         System.out.println(output);
514         assertTrue(output.indexOf("<test>") != -1);
515     }
516 
517     public void testNullCData() {
518         Element e = DocumentHelper.createElement("test");
519         e.add(DocumentHelper.createElement("another").addCDATA(null));
520 
521         Document doc = DocumentHelper.createDocument(e);
522 
523         assertEquals(-1, e.asXML().indexOf("null"));
524         assertEquals(-1, doc.asXML().indexOf("null"));
525 
526         System.out.println(e.asXML());
527         System.out.println(doc.asXML());
528     }
529 
530     protected void generateXML(ContentHandler handler) throws SAXException {
531         handler.startDocument();
532 
533         AttributesImpl attrs = new AttributesImpl();
534         attrs.clear();
535         attrs.addAttribute("", "", "name", "CDATA", "arvojoo");
536         handler.startElement("", "", "processes", attrs);
537 
538         String text = "jeejee";
539         char[] textch = text.toCharArray();
540         handler.characters(textch, 0, textch.length);
541         handler.endElement("", "", "processes");
542         handler.endDocument();
543     }
544 }
545 
546 
547 
548 
549 
550 
551 
552 
553 
554 
555 
556 
557 
558 
559 
560 
561 
562 
563 
564 
565 
566 
567 
568 
569 
570 
571 
572 
573 
574 
575 
576 
577 
578 
579 
580 
581