From 1ee816b473998b3cbdcd5b4c356b715f78e9adf2 Mon Sep 17 00:00:00 2001 From: Juergen Hoeller Date: Tue, 26 Nov 2013 01:40:34 +0100 Subject: [PATCH] Re-introduced custom StaxSource and StaxResult for Spring Web Services --- .../springframework/util/xml/StaxResult.java | 113 ++++++++++++++ .../springframework/util/xml/StaxSource.java | 117 ++++++++++++++ .../springframework/util/xml/StaxUtils.java | 144 +++++++++++++----- .../util/xml/StaxResultTests.java | 81 ++++++++++ .../util/xml/StaxSourceTests.java | 110 +++++++++++++ .../util/xml/StaxUtilsTests.java | 97 ++++++++++++ 6 files changed, 623 insertions(+), 39 deletions(-) create mode 100644 spring-core/src/main/java/org/springframework/util/xml/StaxResult.java create mode 100644 spring-core/src/main/java/org/springframework/util/xml/StaxSource.java create mode 100644 spring-core/src/test/java/org/springframework/util/xml/StaxResultTests.java create mode 100644 spring-core/src/test/java/org/springframework/util/xml/StaxSourceTests.java create mode 100644 spring-core/src/test/java/org/springframework/util/xml/StaxUtilsTests.java diff --git a/spring-core/src/main/java/org/springframework/util/xml/StaxResult.java b/spring-core/src/main/java/org/springframework/util/xml/StaxResult.java new file mode 100644 index 0000000000..801769cdfa --- /dev/null +++ b/spring-core/src/main/java/org/springframework/util/xml/StaxResult.java @@ -0,0 +1,113 @@ +/* + * Copyright 2002-2013 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.util.xml; + +import javax.xml.stream.XMLEventFactory; +import javax.xml.stream.XMLEventWriter; +import javax.xml.stream.XMLStreamWriter; +import javax.xml.transform.sax.SAXResult; + +import org.xml.sax.ContentHandler; + +/** + * Implementation of the {@code Result} tagging interface for StAX writers. Can be constructed with + * an {@code XMLEventConsumer} or an {@code XMLStreamWriter}. + * + *

This class is necessary because there is no implementation of {@code Source} for StaxReaders + * in JAXP 1.3. There is a {@code StAXResult} in JAXP 1.4 (JDK 1.6), but this class is kept around + * for backwards compatibility reasons. + * + *

Even though {@code StaxResult} extends from {@code SAXResult}, calling the methods of + * {@code SAXResult} is not supported. In general, the only supported operation + * on this class is to use the {@code ContentHandler} obtained via {@link #getHandler()} to parse an + * input source using an {@code XMLReader}. Calling {@link #setHandler(org.xml.sax.ContentHandler)} + * will result in {@code UnsupportedOperationException}s. + * + * @author Arjen Poutsma + * @since 3.0 + * @see XMLEventWriter + * @see XMLStreamWriter + * @see javax.xml.transform.Transformer + */ +class StaxResult extends SAXResult { + + private XMLEventWriter eventWriter; + + private XMLStreamWriter streamWriter; + + + /** + * Construct a new instance of the {@code StaxResult} with the specified {@code XMLStreamWriter}. + * @param streamWriter the {@code XMLStreamWriter} to write to + */ + StaxResult(XMLStreamWriter streamWriter) { + super.setHandler(new StaxStreamContentHandler(streamWriter)); + this.streamWriter = streamWriter; + } + + /** + * Construct a new instance of the {@code StaxResult} with the specified {@code XMLEventWriter}. + * @param eventWriter the {@code XMLEventWriter} to write to + */ + StaxResult(XMLEventWriter eventWriter) { + super.setHandler(new StaxEventContentHandler(eventWriter)); + this.eventWriter = eventWriter; + } + + /** + * Construct a new instance of the {@code StaxResult} with the specified {@code XMLEventWriter} + * and {@code XMLEventFactory}. + * @param eventWriter the {@code XMLEventWriter} to write to + * @param eventFactory the {@code XMLEventFactory} to use for creating events + */ + StaxResult(XMLEventWriter eventWriter, XMLEventFactory eventFactory) { + super.setHandler(new StaxEventContentHandler(eventWriter, eventFactory)); + this.eventWriter = eventWriter; + } + + + /** + * Return the {@code XMLEventWriter} used by this {@code StaxResult}. If this {@code StaxResult} + * was created with an {@code XMLStreamWriter}, the result will be {@code null}. + * @return the StAX event writer used by this result + * @see #StaxResult(javax.xml.stream.XMLEventWriter) + */ + XMLEventWriter getXMLEventWriter() { + return this.eventWriter; + } + + /** + * Return the {@code XMLStreamWriter} used by this {@code StaxResult}. If this {@code StaxResult} + * was created with an {@code XMLEventConsumer}, the result will be {@code null}. + * @return the StAX stream writer used by this result + * @see #StaxResult(javax.xml.stream.XMLStreamWriter) + */ + XMLStreamWriter getXMLStreamWriter() { + return this.streamWriter; + } + + + /** + * Throws an {@code UnsupportedOperationException}. + * @throws UnsupportedOperationException always + */ + @Override + public void setHandler(ContentHandler handler) { + throw new UnsupportedOperationException("setHandler is not supported"); + } + +} diff --git a/spring-core/src/main/java/org/springframework/util/xml/StaxSource.java b/spring-core/src/main/java/org/springframework/util/xml/StaxSource.java new file mode 100644 index 0000000000..5706a4317e --- /dev/null +++ b/spring-core/src/main/java/org/springframework/util/xml/StaxSource.java @@ -0,0 +1,117 @@ +/* + * Copyright 2002-2013 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.util.xml; + +import javax.xml.stream.XMLEventReader; +import javax.xml.stream.XMLStreamReader; +import javax.xml.transform.sax.SAXSource; + +import org.xml.sax.InputSource; +import org.xml.sax.XMLReader; + +/** + * Implementation of the {@code Source} tagging interface for StAX readers. Can be constructed with + * an {@code XMLEventReader} or an {@code XMLStreamReader}. + * + *

This class is necessary because there is no implementation of {@code Source} for StAX Readers + * in JAXP 1.3. There is a {@code StAXSource} in JAXP 1.4 (JDK 1.6), but this class is kept around + * for backwards compatibility reasons. + * + *

Even though {@code StaxSource} extends from {@code SAXSource}, calling the methods of + * {@code SAXSource} is not supported. In general, the only supported operation + * on this class is to use the {@code XMLReader} obtained via {@link #getXMLReader()} to parse the + * input source obtained via {@link #getInputSource()}. Calling {@link #setXMLReader(XMLReader)} + * or {@link #setInputSource(InputSource)} will result in {@code UnsupportedOperationException}s. + * + * @author Arjen Poutsma + * @since 3.0 + * @see XMLEventReader + * @see XMLStreamReader + * @see javax.xml.transform.Transformer + */ +class StaxSource extends SAXSource { + + private XMLEventReader eventReader; + + private XMLStreamReader streamReader; + + + /** + * Construct a new instance of the {@code StaxSource} with the specified {@code XMLStreamReader}. + * The supplied stream reader must be in {@code XMLStreamConstants.START_DOCUMENT} or + * {@code XMLStreamConstants.START_ELEMENT} state. + * @param streamReader the {@code XMLStreamReader} to read from + * @throws IllegalStateException if the reader is not at the start of a document or element + */ + StaxSource(XMLStreamReader streamReader) { + super(new StaxStreamXMLReader(streamReader), new InputSource()); + this.streamReader = streamReader; + } + + /** + * Construct a new instance of the {@code StaxSource} with the specified {@code XMLEventReader}. + * The supplied event reader must be in {@code XMLStreamConstants.START_DOCUMENT} or + * {@code XMLStreamConstants.START_ELEMENT} state. + * @param eventReader the {@code XMLEventReader} to read from + * @throws IllegalStateException if the reader is not at the start of a document or element + */ + StaxSource(XMLEventReader eventReader) { + super(new StaxEventXMLReader(eventReader), new InputSource()); + this.eventReader = eventReader; + } + + + /** + * Return the {@code XMLEventReader} used by this {@code StaxSource}. If this {@code StaxSource} + * was created with an {@code XMLStreamReader}, the result will be {@code null}. + * @return the StAX event reader used by this source + * @see StaxSource#StaxSource(javax.xml.stream.XMLEventReader) + */ + XMLEventReader getXMLEventReader() { + return this.eventReader; + } + + /** + * Return the {@code XMLStreamReader} used by this {@code StaxSource}. If this {@code StaxSource} + * was created with an {@code XMLEventReader}, the result will be {@code null}. + * @return the StAX event reader used by this source + * @see StaxSource#StaxSource(javax.xml.stream.XMLEventReader) + */ + XMLStreamReader getXMLStreamReader() { + return this.streamReader; + } + + + /** + * Throws an {@code UnsupportedOperationException}. + * @throws UnsupportedOperationException always + */ + @Override + public void setInputSource(InputSource inputSource) { + throw new UnsupportedOperationException("setInputSource is not supported"); + } + + /** + * Throws an {@code UnsupportedOperationException}. + * @throws UnsupportedOperationException always + */ + @Override + public void setXMLReader(XMLReader reader) { + throw new UnsupportedOperationException("setXMLReader is not supported"); + } + +} diff --git a/spring-core/src/main/java/org/springframework/util/xml/StaxUtils.java b/spring-core/src/main/java/org/springframework/util/xml/StaxUtils.java index 74392ccb5c..e19381a588 100644 --- a/spring-core/src/main/java/org/springframework/util/xml/StaxUtils.java +++ b/spring-core/src/main/java/org/springframework/util/xml/StaxUtils.java @@ -30,8 +30,6 @@ import javax.xml.transform.stax.StAXSource; import org.xml.sax.ContentHandler; import org.xml.sax.XMLReader; -import org.springframework.util.Assert; - /** * Convenience methods for working with the StAX API. Partly historic due to JAXP 1.3 compatibility; * as of Spring 4.0, relying on JAXP 1.4 as included in JDK 1.6 and higher. @@ -58,19 +56,75 @@ public abstract class StaxUtils { * Create a JAXP 1.4 a {@link StAXSource} for the given {@link XMLEventReader}. * @param eventReader the StAX event reader * @return a source wrapping the {@code eventReader} - * @throws XMLStreamException in case of StAX errors */ public static Source createStaxSource(XMLEventReader eventReader) throws XMLStreamException { return new StAXSource(eventReader); } /** - * Indicate whether the given {@link Source} is a StAX Source. - * @return {@code true} if {@code source} is a JAXP 1.4 {@link StAXSource}; - * {@code false} otherwise. + * Create a custom, non-JAXP 1.4 StAX {@link Source} for the given {@link XMLStreamReader}. + * @param streamReader the StAX stream reader + * @return a source wrapping the {@code streamReader} + */ + public static Source createCustomStaxSource(XMLStreamReader streamReader) { + return new StaxSource(streamReader); + } + + /** + * Create a custom, non-JAXP 1.4 StAX {@link Source} for the given {@link XMLEventReader}. + * @param eventReader the StAX event reader + * @return a source wrapping the {@code eventReader} + */ + public static Source createCustomStaxSource(XMLEventReader eventReader) { + return new StaxSource(eventReader); + } + + /** + * Indicate whether the given {@link Source} is a JAXP 1.4 StAX Source or + * custom StAX Source. + * @return {@code true} if {@code source} is a JAXP 1.4 {@link StAXSource} or + * custom StAX Source; {@code false} otherwise */ public static boolean isStaxSource(Source source) { - return (source instanceof StAXSource); + return (source instanceof StAXSource || source instanceof StaxSource); + } + + /** + * Return the {@link XMLStreamReader} for the given StAX Source. + * @param source a JAXP 1.4 {@link StAXSource} + * @return the {@link XMLStreamReader} + * @throws IllegalArgumentException if {@code source} isn't a JAXP 1.4 {@link StAXSource} + * or custom StAX Source + */ + public static XMLStreamReader getXMLStreamReader(Source source) { + if (source instanceof StAXSource) { + return ((StAXSource) source).getXMLStreamReader(); + } + else if (source instanceof StaxSource) { + return ((StaxSource) source).getXMLStreamReader(); + } + else { + throw new IllegalArgumentException("Source '" + source + "' is neither StaxSource nor StAXSource"); + } + } + + /** + * Return the {@link XMLEventReader} for the given StAX Source. + * @param source a JAXP 1.4 {@link StAXSource} + * @return the {@link XMLEventReader} + * @throws IllegalArgumentException if {@code source} isn't a JAXP 1.4 {@link StAXSource} + * or custom StAX Source + */ + public static XMLEventReader getXMLEventReader(Source source) { + if (source instanceof StAXSource) { + return ((StAXSource) source).getXMLEventReader(); + } + else if (source instanceof StaxSource) { + return ((StaxSource) source).getXMLEventReader(); + } + else { + throw new IllegalArgumentException("Source '" + source + "' is neither StaxSource nor StAXSource"); + } } /** @@ -86,41 +140,37 @@ public abstract class StaxUtils { * Create a JAXP 1.4 {@link StAXResult} for the given {@link XMLEventWriter}. * @param eventWriter the StAX event writer * @return a result wrapping {@code streamReader} - * @throws XMLStreamException in case of StAX errors */ - public static Result createStaxResult(XMLEventWriter eventWriter) throws XMLStreamException { + public static Result createStaxResult(XMLEventWriter eventWriter) { return new StAXResult(eventWriter); } /** - * Indicate whether the given {@link javax.xml.transform.Result} is a StAX Result. - * @return {@code true} if {@code result} is a JAXP 1.4 {@link StAXResult}; - * {@code false} otherwise. + * Create a custom, non-JAXP 1.4 StAX {@link Result} for the given {@link XMLStreamWriter}. + * @param streamWriter the StAX stream writer + * @return a source wrapping the {@code streamWriter} + */ + public static Result createCustomStaxResult(XMLStreamWriter streamWriter) { + return new StaxResult(streamWriter); + } + + /** + * Create a custom, non-JAXP 1.4 StAX {@link Result} for the given {@link XMLEventWriter}. + * @param eventWriter the StAX event writer + * @return a source wrapping the {@code eventWriter} + */ + public static Result createCustomStaxResult(XMLEventWriter eventWriter) { + return new StaxResult(eventWriter); + } + + /** + * Indicate whether the given {@link Result} is a JAXP 1.4 StAX Result or + * custom StAX Result. + * @return {@code true} if {@code result} is a JAXP 1.4 {@link StAXResult} or + * custom StAX Result; {@code false} otherwise */ public static boolean isStaxResult(Result result) { - return (result instanceof StAXResult); - } - - /** - * Return the {@link XMLStreamReader} for the given StAX Source. - * @param source a JAXP 1.4 {@link StAXSource} - * @return the {@link XMLStreamReader} - * @throws IllegalArgumentException if {@code source} isn't a JAXP 1.4 {@link StAXSource} - */ - public static XMLStreamReader getXMLStreamReader(Source source) { - Assert.isInstanceOf(StAXSource.class, source); - return ((StAXSource) source).getXMLStreamReader(); - } - - /** - * Return the {@link XMLEventReader} for the given StAX Source. - * @param source a JAXP 1.4 {@link StAXSource} - * @return the {@link XMLEventReader} - * @throws IllegalArgumentException if {@code source} isn't a JAXP 1.4 {@link StAXSource} - */ - public static XMLEventReader getXMLEventReader(Source source) { - Assert.isInstanceOf(StAXSource.class, source); - return ((StAXSource) source).getXMLEventReader(); + return (result instanceof StAXResult || result instanceof StaxResult); } /** @@ -128,10 +178,18 @@ public abstract class StaxUtils { * @param result a JAXP 1.4 {@link StAXResult} * @return the {@link XMLStreamReader} * @throws IllegalArgumentException if {@code source} isn't a JAXP 1.4 {@link StAXResult} + * or custom StAX Result */ public static XMLStreamWriter getXMLStreamWriter(Result result) { - Assert.isInstanceOf(StAXResult.class, result); - return ((StAXResult) result).getXMLStreamWriter(); + if (result instanceof StAXResult) { + return ((StAXResult) result).getXMLStreamWriter(); + } + else if (result instanceof StaxResult) { + return ((StaxResult) result).getXMLStreamWriter(); + } + else { + throw new IllegalArgumentException("Result '" + result + "' is neither StaxResult nor StAXResult"); + } } /** @@ -139,10 +197,18 @@ public abstract class StaxUtils { * @param result a JAXP 1.4 {@link StAXResult} * @return the {@link XMLStreamReader} * @throws IllegalArgumentException if {@code source} isn't a JAXP 1.4 {@link StAXResult} + * or custom StAX Result */ public static XMLEventWriter getXMLEventWriter(Result result) { - Assert.isInstanceOf(StAXResult.class, result); - return ((StAXResult) result).getXMLEventWriter(); + if (result instanceof StAXResult) { + return ((StAXResult) result).getXMLEventWriter(); + } + else if (result instanceof StaxResult) { + return ((StaxResult) result).getXMLEventWriter(); + } + else { + throw new IllegalArgumentException("Result '" + result + "' is neither StaxResult nor StAXResult"); + } } /** diff --git a/spring-core/src/test/java/org/springframework/util/xml/StaxResultTests.java b/spring-core/src/test/java/org/springframework/util/xml/StaxResultTests.java new file mode 100644 index 0000000000..4a8254a77e --- /dev/null +++ b/spring-core/src/test/java/org/springframework/util/xml/StaxResultTests.java @@ -0,0 +1,81 @@ +/* + * Copyright 2002-2009 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.util.xml; + +import java.io.Reader; +import java.io.StringReader; +import java.io.StringWriter; +import javax.xml.stream.XMLEventWriter; +import javax.xml.stream.XMLOutputFactory; +import javax.xml.stream.XMLStreamWriter; +import javax.xml.transform.Source; +import javax.xml.transform.Transformer; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.stream.StreamSource; + +import org.junit.Before; +import org.junit.Test; + +import static org.custommonkey.xmlunit.XMLAssert.*; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +/** + * @author Arjen Poutsma + */ +public class StaxResultTests { + + private static final String XML = ""; + + private Transformer transformer; + + private XMLOutputFactory inputFactory; + + @Before + public void setUp() throws Exception { + TransformerFactory transformerFactory = TransformerFactory.newInstance(); + transformer = transformerFactory.newTransformer(); + inputFactory = XMLOutputFactory.newInstance(); + } + + @Test + public void streamWriterSource() throws Exception { + StringWriter stringWriter = new StringWriter(); + XMLStreamWriter streamWriter = inputFactory.createXMLStreamWriter(stringWriter); + Reader reader = new StringReader(XML); + Source source = new StreamSource(reader); + StaxResult result = new StaxResult(streamWriter); + assertEquals("Invalid streamWriter returned", streamWriter, result.getXMLStreamWriter()); + assertNull("EventWriter returned", result.getXMLEventWriter()); + transformer.transform(source, result); + assertXMLEqual("Invalid result", XML, stringWriter.toString()); + } + + @Test + public void eventWriterSource() throws Exception { + StringWriter stringWriter = new StringWriter(); + XMLEventWriter eventWriter = inputFactory.createXMLEventWriter(stringWriter); + Reader reader = new StringReader(XML); + Source source = new StreamSource(reader); + StaxResult result = new StaxResult(eventWriter); + assertEquals("Invalid eventWriter returned", eventWriter, result.getXMLEventWriter()); + assertNull("StreamWriter returned", result.getXMLStreamWriter()); + transformer.transform(source, result); + assertXMLEqual("Invalid result", XML, stringWriter.toString()); + } + +} \ No newline at end of file diff --git a/spring-core/src/test/java/org/springframework/util/xml/StaxSourceTests.java b/spring-core/src/test/java/org/springframework/util/xml/StaxSourceTests.java new file mode 100644 index 0000000000..2f303c5eff --- /dev/null +++ b/spring-core/src/test/java/org/springframework/util/xml/StaxSourceTests.java @@ -0,0 +1,110 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.util.xml; + +import java.io.StringReader; +import java.io.StringWriter; +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.stream.XMLEventReader; +import javax.xml.stream.XMLInputFactory; +import javax.xml.stream.XMLStreamReader; +import javax.xml.transform.Transformer; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.dom.DOMResult; +import javax.xml.transform.stream.StreamResult; + +import org.junit.Before; +import org.junit.Test; +import org.w3c.dom.Document; +import org.xml.sax.InputSource; + +import static org.custommonkey.xmlunit.XMLAssert.*; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +/** + * @author Arjen Poutsma + */ +public class StaxSourceTests { + + private static final String XML = ""; + + private Transformer transformer; + + private XMLInputFactory inputFactory; + + private DocumentBuilder documentBuilder; + + @Before + public void setUp() throws Exception { + TransformerFactory transformerFactory = TransformerFactory.newInstance(); + transformer = transformerFactory.newTransformer(); + inputFactory = XMLInputFactory.newInstance(); + DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance(); + documentBuilderFactory.setNamespaceAware(true); + documentBuilder = documentBuilderFactory.newDocumentBuilder(); + } + + @Test + public void streamReaderSourceToStreamResult() throws Exception { + XMLStreamReader streamReader = inputFactory.createXMLStreamReader(new StringReader(XML)); + StaxSource source = new StaxSource(streamReader); + assertEquals("Invalid streamReader returned", streamReader, source.getXMLStreamReader()); + assertNull("EventReader returned", source.getXMLEventReader()); + StringWriter writer = new StringWriter(); + transformer.transform(source, new StreamResult(writer)); + assertXMLEqual("Invalid result", XML, writer.toString()); + } + + @Test + public void streamReaderSourceToDOMResult() throws Exception { + XMLStreamReader streamReader = inputFactory.createXMLStreamReader(new StringReader(XML)); + StaxSource source = new StaxSource(streamReader); + assertEquals("Invalid streamReader returned", streamReader, source.getXMLStreamReader()); + assertNull("EventReader returned", source.getXMLEventReader()); + + Document expected = documentBuilder.parse(new InputSource(new StringReader(XML))); + Document result = documentBuilder.newDocument(); + transformer.transform(source, new DOMResult(result)); + assertXMLEqual("Invalid result", expected, result); + } + + @Test + public void eventReaderSourceToStreamResult() throws Exception { + XMLEventReader eventReader = inputFactory.createXMLEventReader(new StringReader(XML)); + StaxSource source = new StaxSource(eventReader); + assertEquals("Invalid eventReader returned", eventReader, source.getXMLEventReader()); + assertNull("StreamReader returned", source.getXMLStreamReader()); + StringWriter writer = new StringWriter(); + transformer.transform(source, new StreamResult(writer)); + assertXMLEqual("Invalid result", XML, writer.toString()); + } + + @Test + public void eventReaderSourceToDOMResult() throws Exception { + XMLEventReader eventReader = inputFactory.createXMLEventReader(new StringReader(XML)); + StaxSource source = new StaxSource(eventReader); + assertEquals("Invalid eventReader returned", eventReader, source.getXMLEventReader()); + assertNull("StreamReader returned", source.getXMLStreamReader()); + + Document expected = documentBuilder.parse(new InputSource(new StringReader(XML))); + Document result = documentBuilder.newDocument(); + transformer.transform(source, new DOMResult(result)); + assertXMLEqual("Invalid result", expected, result); + } +} diff --git a/spring-core/src/test/java/org/springframework/util/xml/StaxUtilsTests.java b/spring-core/src/test/java/org/springframework/util/xml/StaxUtilsTests.java new file mode 100644 index 0000000000..a6cc1ab66f --- /dev/null +++ b/spring-core/src/test/java/org/springframework/util/xml/StaxUtilsTests.java @@ -0,0 +1,97 @@ +/* + * Copyright 2002-2010 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.util.xml; + +import java.io.StringReader; +import java.io.StringWriter; +import javax.xml.stream.XMLInputFactory; +import javax.xml.stream.XMLOutputFactory; +import javax.xml.stream.XMLStreamReader; +import javax.xml.stream.XMLStreamWriter; +import javax.xml.transform.Result; +import javax.xml.transform.Source; +import javax.xml.transform.dom.DOMResult; +import javax.xml.transform.dom.DOMSource; +import javax.xml.transform.sax.SAXResult; +import javax.xml.transform.sax.SAXSource; +import javax.xml.transform.stax.StAXResult; +import javax.xml.transform.stax.StAXSource; +import javax.xml.transform.stream.StreamResult; +import javax.xml.transform.stream.StreamSource; + +import org.junit.Test; + +import static org.junit.Assert.*; + +/** + * @author Arjen Poutsma + */ +public class StaxUtilsTests { + + @Test + public void isStaxSourceInvalid() throws Exception { + assertFalse("A StAX Source", StaxUtils.isStaxSource(new DOMSource())); + assertFalse("A StAX Source", StaxUtils.isStaxSource(new SAXSource())); + assertFalse("A StAX Source", StaxUtils.isStaxSource(new StreamSource())); + } + + @Test + public void isStaxSource() throws Exception { + XMLInputFactory inputFactory = XMLInputFactory.newInstance(); + String expected = ""; + XMLStreamReader streamReader = inputFactory.createXMLStreamReader(new StringReader(expected)); + Source source = StaxUtils.createCustomStaxSource(streamReader); + + assertTrue("Not a StAX Source", StaxUtils.isStaxSource(source)); + } + + @Test + public void isStaxSourceJaxp14() throws Exception { + XMLInputFactory inputFactory = XMLInputFactory.newInstance(); + String expected = ""; + XMLStreamReader streamReader = inputFactory.createXMLStreamReader(new StringReader(expected)); + StAXSource source = new StAXSource(streamReader); + + assertTrue("Not a StAX Source", StaxUtils.isStaxSource(source)); + } + + @Test + public void isStaxResultInvalid() throws Exception { + assertFalse("A StAX Result", StaxUtils.isStaxResult(new DOMResult())); + assertFalse("A StAX Result", StaxUtils.isStaxResult(new SAXResult())); + assertFalse("A StAX Result", StaxUtils.isStaxResult(new StreamResult())); + } + + @Test + public void isStaxResult() throws Exception { + XMLOutputFactory outputFactory = XMLOutputFactory.newInstance(); + XMLStreamWriter streamWriter = outputFactory.createXMLStreamWriter(new StringWriter()); + Result result = StaxUtils.createCustomStaxResult(streamWriter); + + assertTrue("Not a StAX Result", StaxUtils.isStaxResult(result)); + } + + @Test + public void isStaxResultJaxp14() throws Exception { + XMLOutputFactory outputFactory = XMLOutputFactory.newInstance(); + XMLStreamWriter streamWriter = outputFactory.createXMLStreamWriter(new StringWriter()); + StAXResult result = new StAXResult(streamWriter); + + assertTrue("Not a StAX Result", StaxUtils.isStaxResult(result)); + } + +}