xmlwritertest.java

解决如何把XML应用到JAVA里问题

/*
 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
 *
 * This software is open source.
 * See the bottom of this file for the licence.
 */

package org.dom4j;

import junit.textui.TestRunner;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.StringReader;
import java.io.StringWriter;

import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.dom4j.tree.BaseElement;
import org.dom4j.tree.DefaultDocument;

import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;

/**
 * A simple test harness to check that the XML Writer works
 * 
 * @author <a href="mailto:[e-mail]">James Strachan </a>
 * @version $Revision: 1.7.2.1 $
 */
public class XMLWriterTest extends AbstractTestCase {
    protected static final boolean VERBOSE = false;

    public static void main(String[] args) {
        TestRunner.run(XMLWriterTest.class);
    }

    // Test case(s)
    // -------------------------------------------------------------------------
    public void testBug1180791() throws Exception {
        String xml = "<?xml version=\"1.0\"?><root><foo>bar</foo></root>";

        SAXReader reader = new SAXReader();
        Document doc = reader.read(new StringReader(xml));
        // of with newlines
        OutputFormat format = new OutputFormat();
        format.setNewlines(true);
        //format.setTrimText(true);
        // first time
        StringWriter writer = new StringWriter();
        XMLWriter xmlwriter = new XMLWriter(writer, format);
        xmlwriter.write(doc);
        System.out.println(writer.toString());

        // 2nd time
        doc = reader.read(new StringReader(writer.toString()));
        writer = new StringWriter();
        xmlwriter = new XMLWriter(writer, format);
        xmlwriter.write(doc);
        System.out.println(writer.toString());
    }

    public void testBug1119733() throws Exception {
        Document doc = DocumentHelper
                .parseText("<root><code>foo</code> bar</root>");

        StringWriter out = new StringWriter();
        XMLWriter writer = new XMLWriter(out, OutputFormat.createPrettyPrint());
        writer.write(doc);
        writer.close();

        String xml = out.toString();

        System.out.println(xml);
        assertEquals("whitespace problem", -1, xml.indexOf("</code>bar"));
    }

    public void testBug1119733WithSAXEvents() throws Exception {
        StringWriter out = new StringWriter();
        XMLWriter writer = new XMLWriter(out, OutputFormat.createPrettyPrint());
        writer.startDocument();
        writer.startElement(null, "root", "root", new AttributesImpl());
        writer.startElement(null, "code", "code", new AttributesImpl());
        writer.characters(new char[] { 'f', 'o', 'o' }, 0, 3);
        writer.endElement(null, "code", "code");
        writer.characters(new char[] { ' ', 'b', 'a', 'r' }, 0, 4);
        writer.endElement(null, "root", "root");
        writer.endDocument();
        writer.close();

        String xml = out.toString();

        System.out.println(xml);
        assertEquals("whitespace problem", -1, xml.indexOf("</code>bar"));
    }

    public void testWriter() throws Exception {
        Object object = document;
        StringWriter out = new StringWriter();

        XMLWriter writer = new XMLWriter(out);
        writer.write(object);
        writer.close();

        String text = out.toString();

        if (VERBOSE) {
            log("Text output is [");
            log(text);
            log("]. Done");
        }

        assertTrue("Output text is bigger than 10 characters",
                text.length() > 10);
    }

    public void testEncodingFormats() throws Exception {
        testEncoding("UTF-8");
        testEncoding("UTF-16");
        testEncoding("ISO-8859-1");
    }

    public void testWritingEmptyElement() throws Exception {
        Document doc = DocumentFactory.getInstance().createDocument();
        Element grandFather = doc.addElement("grandfather");
        Element parent1 = grandFather.addElement("parent");
        Element child1 = parent1.addElement("child1");
        Element child2 = parent1.addElement("child2");
        child2.setText("test");

        Element parent2 = grandFather.addElement("parent");
        Element child3 = parent2.addElement("child3");
        child3.setText("test");

        StringWriter buffer = new StringWriter();
        OutputFormat format = OutputFormat.createPrettyPrint();
        XMLWriter writer = new XMLWriter(buffer, format);
        writer.write(doc);

        String xml = buffer.toString();

        System.out.println(xml);

        assertTrue("child2 not present",
                xml.indexOf("<child2>test</child2>") != -1);
    }

    protected void testEncoding(String encoding) throws Exception {
        ByteArrayOutputStream out = new ByteArrayOutputStream();

        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding(encoding);

        XMLWriter writer = new XMLWriter(out, format);
        writer.write(document);
        writer.close();

        log("Wrote to encoding: " + encoding);
    }

    public void testWriterBug() throws Exception {
        Element project = new BaseElement("project");
        Document doc = new DefaultDocument(project);

        ByteArrayOutputStream out = new ByteArrayOutputStream();
        XMLWriter writer = new XMLWriter(out, new OutputFormat("\t", true,
                "ISO-8859-1"));
        writer.write(doc);

        ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
        SAXReader reader = new SAXReader();
        Document doc2 = reader.read(in);

        assertTrue("Generated document has a root element", doc2
                .getRootElement() != null);
        assertEquals("Generated document has corrent named root element", doc2
                .getRootElement().getName(), "project");
    }

    public void testNamespaceBug() throws Exception {
        Document doc = DocumentHelper.createDocument();

        Element root = doc.addElement("root", "ns1");
        Element child1 = root.addElement("joe", "ns2");
        child1.addElement("zot", "ns1");

        StringWriter out = new StringWriter();
        XMLWriter writer = new XMLWriter(out, OutputFormat.createPrettyPrint());
        writer.write(doc);

        String text = out.toString();

        // System.out.println( "Generated:" + text );
        Document doc2 = DocumentHelper.parseText(text);
        root = doc2.getRootElement();
        assertEquals("root has incorrect namespace", "ns1", root
                .getNamespaceURI());

        Element joe = (Element) root.elementIterator().next();
        assertEquals("joe has correct namespace", "ns2", joe.getNamespaceURI());

        Element zot = (Element) joe.elementIterator().next();
        assertEquals("zot has correct namespace", "ns1", zot.getNamespaceURI());
    }

    /**
     * This test harness was supplied by Lari Hotari
     * 
     * @throws Exception DOCUMENT ME!
     */
    public void testContentHandler() throws Exception {
        StringWriter out = new StringWriter();
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("iso-8859-1");

        XMLWriter writer = new XMLWriter(out, format);
        generateXML(writer);
        writer.close();

        String text = out.toString();

        if (VERBOSE) {
            log("Created XML");
            log(text);
        }

        // now lets parse the output and test it with XPath
        Document doc = DocumentHelper.parseText(text);
        String value = doc.valueOf("/processes[@name='arvojoo']");
        assertEquals("Document contains the correct text", "jeejee", value);
    }

    /**
     * This test was provided by Manfred Lotz
     * 
     * @throws Exception DOCUMENT ME!
     */
    public void testWhitespaceBug() throws Exception {
        String notes = "<notes> This is a      multiline\n\rentry</notes>";
        Document doc = DocumentHelper.parseText(notes);

        OutputFormat format = new OutputFormat();
        format.setEncoding("UTF-8");
        format.setIndentSize(4);
        format.setNewlines(true);
        format.setTrimText(true);
        format.setExpandEmptyElements(true);

        StringWriter buffer = new StringWriter();
        XMLWriter writer = new XMLWriter(buffer, format);
        writer.write(doc);

        String xml = buffer.toString();
        log(xml);

        Document doc2 = DocumentHelper.parseText(xml);
        String text = doc2.valueOf("/notes");
        String expected = "This is a multiline entry";

        assertEquals("valueOf() returns the correct text padding", expected,
                text);

        assertEquals("getText() returns the correct text padding", expected,
                doc2.getRootElement().getText());
    }

    /**
     * This test was provided by Manfred Lotz
     * 
     * @throws Exception DOCUMENT ME!
     */
    public void testWhitespaceBug2() throws Exception {
        Document doc = DocumentHelper.createDocument();
        Element root = doc.addElement("root");
        Element meaning = root.addElement("meaning");
        meaning.addText("to li");
        meaning.addText("ve");

        OutputFormat format = new OutputFormat();
        format.setEncoding("UTF-8");
        format.setIndentSize(4);
        format.setNewlines(true);
        format.setTrimText(true);
        format.setExpandEmptyElements(true);

        StringWriter buffer = new StringWriter();
        XMLWriter writer = new XMLWriter(buffer, format);
        writer.write(doc);