tchekai704
/
src-spring-framework
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

StaxUtils relies on JAXP 1.4 (as included in JDK 1.6+)

pull/263/head
Juergen Hoeller 12 years ago
parent
87e5f19c3f
commit
7f0a780925
7 changed files with 39 additions and 710 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 113
      spring-core/src/main/java/org/springframework/util/xml/StaxResult.java
  2. 117
      spring-core/src/main/java/org/springframework/util/xml/StaxSource.java
  3. 234
      spring-core/src/main/java/org/springframework/util/xml/StaxUtils.java
  4. 77
      spring-core/src/test/java/org/springframework/util/xml/StaxResultTests.java
  5. 108
      spring-core/src/test/java/org/springframework/util/xml/StaxSourceTests.java
  6. 93
      spring-core/src/test/java/org/springframework/util/xml/StaxUtilsTest.java
  7. 7
      spring-core/src/test/java/org/springframework/util/xml/XMLEventStreamReaderTests.java

113
spring-core/src/main/java/org/springframework/util/xml/StaxResult.java
Unescape View File

@ -1,113 +0,0 @@
/*
* 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}.
*
* <p>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.
*
* <p>Even though {@code StaxResult} extends from {@code SAXResult}, calling the methods of
* {@code SAXResult} is <strong>not supported</strong>. 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");
}
}

117
spring-core/src/main/java/org/springframework/util/xml/StaxSource.java
Unescape View File

@ -1,117 +0,0 @@
/*
* 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}.
*
* <p>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.
*
* <p>Even though {@code StaxSource} extends from {@code SAXSource}, calling the methods of
* {@code SAXSource} is <strong>not supported</strong>. 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");
}
}

234
spring-core/src/main/java/org/springframework/util/xml/StaxUtils.java
Unescape View File

@ -31,10 +31,10 @@ import org.xml.sax.ContentHandler;
import org.xml.sax.XMLReader; import org.xml.sax.XMLReader;
import org.springframework.util.Assert; import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
/** /**
* Convenience methods for working with the StAX API. * 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.
* *
* <p>In particular, methods for using StAX ({@code javax.xml.stream}) in combination with the TrAX API * <p>In particular, methods for using StAX ({@code javax.xml.stream}) in combination with the TrAX API
* ({@code javax.xml.transform}), and converting StAX readers/writers into SAX readers/handlers and vice-versa. * ({@code javax.xml.transform}), and converting StAX readers/writers into SAX readers/handlers and vice-versa.
@ -45,218 +45,104 @@ import org.springframework.util.ClassUtils;
*/ */
public abstract class StaxUtils { public abstract class StaxUtils {
// JAXP 1.4 is only available on JDK 1.6+
private static boolean jaxp14Available =
ClassUtils.isPresent("javax.xml.transform.stax.StAXSource", StaxUtils.class.getClassLoader());
// Stax Source
/** /**
* Create a custom, non-JAXP 1.4 StAX {@link Source} for the given {@link XMLStreamReader}. * Create a JAXP 1.4 {@link StAXSource} for the given {@link XMLStreamReader}.
* @param streamReader the StAX stream reader * @param streamReader the StAX stream reader
* @return a source wrapping the {@code streamReader} * @return a source wrapping the {@code streamReader}
*/ */
public static Source createCustomStaxSource(XMLStreamReader streamReader) {
return new StaxSource(streamReader);
}
/**
* Create a StAX {@link Source} for the given {@link XMLStreamReader}.
* <p>If JAXP 1.4 is available, this method returns a {@link StAXSource};
* otherwise it returns a custom StAX Source.
* @param streamReader the StAX stream reader
* @return a source wrapping the {@code streamReader}
* @see #createCustomStaxSource(XMLStreamReader)
*/
public static Source createStaxSource(XMLStreamReader streamReader) { public static Source createStaxSource(XMLStreamReader streamReader) {
if (jaxp14Available) { return new StAXSource(streamReader);
return Jaxp14StaxHandler.createStaxSource(streamReader);
}
else {
return createCustomStaxSource(streamReader);
}
} }
/** /**
* Create a custom, non-JAXP 1.4 StAX {@link Source} for the given {@link XMLEventReader}. * 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}
*/
public static Source createCustomStaxSource(XMLEventReader eventReader) {
return new StaxSource(eventReader);
}
/**
* Create a StAX {@link Source} for the given {@link XMLEventReader}.
* <p>If JAXP 1.4 is available, this method returns a {@link StAXSource};
* otherwise it returns a custom StAX Source.
* @param eventReader the StAX event reader * @param eventReader the StAX event reader
* @return a source wrapping the {@code eventReader} * @return a source wrapping the {@code eventReader}
* @throws XMLStreamException in case of StAX errors * @throws XMLStreamException in case of StAX errors
* @see #createCustomStaxSource(XMLEventReader)
*/ */
public static Source createStaxSource(XMLEventReader eventReader) throws XMLStreamException { public static Source createStaxSource(XMLEventReader eventReader) throws XMLStreamException {
if (jaxp14Available) { return new StAXSource(eventReader);
return Jaxp14StaxHandler.createStaxSource(eventReader);
}
else {
return createCustomStaxSource(eventReader);
}
} }
/** /**
* Indicate whether the given {@link Source} is a StAX Source. * Indicate whether the given {@link Source} is a StAX Source.
* @return {@code true} if {@code source} is a custom StAX source or JAXP * @return {@code true} if {@code source} is a JAXP 1.4 {@link StAXSource};
* 1.4 {@link StAXSource}; {@code false} otherwise. * {@code false} otherwise.
*/ */
public static boolean isStaxSource(Source source) { public static boolean isStaxSource(Source source) {
return (source instanceof StaxSource || (jaxp14Available && Jaxp14StaxHandler.isStaxSource(source))); return (source instanceof StAXSource);
}
// Stax Result
/**
* 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 StAX {@link Result} for the given {@link XMLStreamWriter}. * Create a JAXP 1.4 {@link StAXResult} for the given {@link XMLStreamWriter}.
* <p>If JAXP 1.4 is available, this method returns a {@link StAXResult};
* otherwise it returns a custom StAX Result.
* @param streamWriter the StAX stream writer * @param streamWriter the StAX stream writer
* @return a result wrapping the {@code streamWriter} * @return a result wrapping the {@code streamWriter}
* @see #createCustomStaxResult(XMLStreamWriter)
*/ */
public static Result createStaxResult(XMLStreamWriter streamWriter) { public static Result createStaxResult(XMLStreamWriter streamWriter) {
if (jaxp14Available) { return new StAXResult(streamWriter);
return Jaxp14StaxHandler.createStaxResult(streamWriter);
}
else {
return createCustomStaxResult(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);
} }
/** /**
* Create a StAX {@link Result} for the given {@link XMLEventWriter}. * Create a JAXP 1.4 {@link StAXResult} for the given {@link XMLEventWriter}.
* <p>If JAXP 1.4 is available, this method returns a {@link StAXResult}; otherwise it returns a
* custom StAX Result.
* @param eventWriter the StAX event writer * @param eventWriter the StAX event writer
* @return a result wrapping {@code streamReader} * @return a result wrapping {@code streamReader}
* @throws XMLStreamException in case of StAX errors * @throws XMLStreamException in case of StAX errors
* @see #createCustomStaxResult(XMLEventWriter)
*/ */
public static Result createStaxResult(XMLEventWriter eventWriter) throws XMLStreamException { public static Result createStaxResult(XMLEventWriter eventWriter) throws XMLStreamException {
if (jaxp14Available) { return new StAXResult(eventWriter);
return Jaxp14StaxHandler.createStaxResult(eventWriter);
}
else {
return createCustomStaxResult(eventWriter);
}
} }
/** /**
* Indicate whether the given {@link javax.xml.transform.Result} is a StAX Result. * Indicate whether the given {@link javax.xml.transform.Result} is a StAX Result.
* @return {@code true} if {@code result} is a custom Stax Result or JAXP 1.4 * @return {@code true} if {@code result} is a JAXP 1.4 {@link StAXResult};
* {@link StAXResult}; {@code false} otherwise. * {@code false} otherwise.
*/ */
public static boolean isStaxResult(Result result) { public static boolean isStaxResult(Result result) {
return (result instanceof StaxResult || (jaxp14Available && Jaxp14StaxHandler.isStaxResult(result))); return (result instanceof StAXResult);
} }
/** /**
* Return the {@link XMLStreamReader} for the given StAX Source. * Return the {@link XMLStreamReader} for the given StAX Source.
* @param source a {@linkplain #createCustomStaxSource(XMLStreamReader) custom StAX Source} or * @param source a JAXP 1.4 {@link StAXSource}
* JAXP 1.4 {@link StAXSource}
* @return the {@link XMLStreamReader} * @return the {@link XMLStreamReader}
* @throws IllegalArgumentException if {@code source} is neither a custom StAX Source * @throws IllegalArgumentException if {@code source} isn't a JAXP 1.4 {@link StAXSource}
* nor JAXP 1.4 {@link StAXSource}
*/ */
public static XMLStreamReader getXMLStreamReader(Source source) { public static XMLStreamReader getXMLStreamReader(Source source) {
if (source instanceof StaxSource) { Assert.isInstanceOf(StAXSource.class, source);
return ((StaxSource) source).getXMLStreamReader(); return ((StAXSource) source).getXMLStreamReader();
}
else if (jaxp14Available) {
return Jaxp14StaxHandler.getXMLStreamReader(source);
}
else {
throw new IllegalArgumentException("Source '" + source + "' is neither StaxSource nor StAXSource");
}
} }
/** /**
* Return the {@link XMLEventReader} for the given StAX Source. * Return the {@link XMLEventReader} for the given StAX Source.
* @param source a {@linkplain #createCustomStaxSource(XMLEventReader) custom StAX Source} or * @param source a JAXP 1.4 {@link StAXSource}
* JAXP 1.4 {@link StAXSource}
* @return the {@link XMLEventReader} * @return the {@link XMLEventReader}
* @throws IllegalArgumentException if {@code source} is neither a custom StAX Source * @throws IllegalArgumentException if {@code source} isn't a JAXP 1.4 {@link StAXSource}
* nor a JAXP 1.4 {@link StAXSource}
*/ */
public static XMLEventReader getXMLEventReader(Source source) { public static XMLEventReader getXMLEventReader(Source source) {
if (source instanceof StaxSource) { Assert.isInstanceOf(StAXSource.class, source);
return ((StaxSource) source).getXMLEventReader(); return ((StAXSource) source).getXMLEventReader();
}
else if (jaxp14Available) {
return Jaxp14StaxHandler.getXMLEventReader(source);
}
else {
throw new IllegalArgumentException("Source '" + source + "' is neither StaxSource nor StAXSource");
}
} }
/** /**
* Return the {@link XMLStreamWriter} for the given StAX Result. * Return the {@link XMLStreamWriter} for the given StAX Result.
* @param result a {@linkplain #createCustomStaxResult(XMLStreamWriter) custom StAX Result} or * @param result a JAXP 1.4 {@link StAXResult}
* JAXP 1.4 {@link StAXResult}
* @return the {@link XMLStreamReader} * @return the {@link XMLStreamReader}
* @throws IllegalArgumentException if {@code source} is neither a custom StAX Result * @throws IllegalArgumentException if {@code source} isn't a JAXP 1.4 {@link StAXResult}
* nor a JAXP 1.4 {@link StAXResult}
*/ */
public static XMLStreamWriter getXMLStreamWriter(Result result) { public static XMLStreamWriter getXMLStreamWriter(Result result) {
if (result instanceof StaxResult) { Assert.isInstanceOf(StAXResult.class, result);
return ((StaxResult) result).getXMLStreamWriter(); return ((StAXResult) result).getXMLStreamWriter();
}
else if (jaxp14Available) {
return Jaxp14StaxHandler.getXMLStreamWriter(result);
}
else {
throw new IllegalArgumentException("Result '" + result + "' is neither StaxResult nor StAXResult");
}
} }
/** /**
* Return the {@link XMLEventWriter} for the given StAX Result. * Return the {@link XMLEventWriter} for the given StAX Result.
* @param result a {@linkplain #createCustomStaxResult(XMLEventWriter) custom StAX Result} or * @param result a JAXP 1.4 {@link StAXResult}
* JAXP 1.4 {@link StAXResult}
* @return the {@link XMLStreamReader} * @return the {@link XMLStreamReader}
* @throws IllegalArgumentException if {@code source} is neither a custom StAX Result * @throws IllegalArgumentException if {@code source} isn't a JAXP 1.4 {@link StAXResult}
* nor a JAXP 1.4 {@link StAXResult}
*/ */
public static XMLEventWriter getXMLEventWriter(Result result) { public static XMLEventWriter getXMLEventWriter(Result result) {
if (result instanceof StaxResult) { Assert.isInstanceOf(StAXResult.class, result);
return ((StaxResult) result).getXMLEventWriter(); return ((StAXResult) result).getXMLEventWriter();
}
else if (jaxp14Available) {
return Jaxp14StaxHandler.getXMLEventWriter(result);
}
else {
throw new IllegalArgumentException("Result '" + result + "' is neither StaxResult nor StAXResult");
}
} }
/** /**
@ -296,8 +182,9 @@ public abstract class StaxUtils {
} }
/** /**
* Return a {@link XMLStreamReader} that reads from a {@link XMLEventReader}. Useful, because the StAX * Return a {@link XMLStreamReader} that reads from a {@link XMLEventReader}.
* {@code XMLInputFactory} allows one to create a event reader from a stream reader, but not vice-versa. * Useful because the StAX {@code XMLInputFactory} allows one to create an
* event reader from a stream reader, but not vice-versa.
* @return a stream reader that reads from an event reader * @return a stream reader that reads from an event reader
*/ */
public static XMLStreamReader createEventStreamReader(XMLEventReader eventReader) throws XMLStreamException { public static XMLStreamReader createEventStreamReader(XMLEventReader eventReader) throws XMLStreamException {
@ -322,55 +209,4 @@ public abstract class StaxUtils {
return new XMLEventStreamWriter(eventWriter, eventFactory); return new XMLEventStreamWriter(eventWriter, eventFactory);
} }
/**
* Inner class to avoid a static JAXP 1.4 dependency.
*/
private static class Jaxp14StaxHandler {
private static Source createStaxSource(XMLStreamReader streamReader) {
return new StAXSource(streamReader);
}
private static Source createStaxSource(XMLEventReader eventReader) throws XMLStreamException {
return new StAXSource(eventReader);
}
private static Result createStaxResult(XMLStreamWriter streamWriter) {
return new StAXResult(streamWriter);
}
private static Result createStaxResult(XMLEventWriter eventWriter) {
return new StAXResult(eventWriter);
}
private static boolean isStaxSource(Source source) {
return (source instanceof StAXSource);
}
private static boolean isStaxResult(Result result) {
return (result instanceof StAXResult);
}
private static XMLStreamReader getXMLStreamReader(Source source) {
Assert.isInstanceOf(StAXSource.class, source);
return ((StAXSource) source).getXMLStreamReader();
}
private static XMLEventReader getXMLEventReader(Source source) {
Assert.isInstanceOf(StAXSource.class, source);
return ((StAXSource) source).getXMLEventReader();
}
private static XMLStreamWriter getXMLStreamWriter(Result result) {
Assert.isInstanceOf(StAXResult.class, result);
return ((StAXResult) result).getXMLStreamWriter();
}
private static XMLEventWriter getXMLEventWriter(Result result) {
Assert.isInstanceOf(StAXResult.class, result);
return ((StAXResult) result).getXMLEventWriter();
}
}
} }

77
spring-core/src/test/java/org/springframework/util/xml/StaxResultTests.java
Unescape View File

@ -1,77 +0,0 @@
/*
* 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 static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import org.junit.Before;
import org.junit.Test;
public class StaxResultTests {
private static final String XML = "<root xmlns='namespace'><child/></root>";
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());
}
}

108
spring-core/src/test/java/org/springframework/util/xml/StaxSourceTests.java
Unescape View File

@ -1,108 +0,0 @@
/*
* 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 static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
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;
public class StaxSourceTests {
private static final String XML = "<root xmlns='namespace'><child/></root>";
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);
}
}

93
spring-core/src/test/java/org/springframework/util/xml/StaxUtilsTest.java
Unescape View File

@ -1,93 +0,0 @@
/*
* 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 static org.junit.Assert.*;
import org.junit.Test;
public class StaxUtilsTest {
@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 = "<element/>";
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 = "<element/>";
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));
}
}

7
spring-core/src/test/java/org/springframework/util/xml/XMLEventStreamReaderTests.java
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2011 the original author or authors. * Copyright 2002-2013 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -22,6 +22,7 @@ import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory; import javax.xml.stream.XMLInputFactory;
import javax.xml.transform.Transformer; import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory; import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stax.StAXSource;
import javax.xml.transform.stream.StreamResult; import javax.xml.transform.stream.StreamResult;
import org.junit.Before; import org.junit.Before;
@ -54,10 +55,10 @@ public class XMLEventStreamReaderTests {
@Test @Test
public void readCorrect() throws Exception { public void readCorrect() throws Exception {
Transformer transformer = TransformerFactory.newInstance().newTransformer(); Transformer transformer = TransformerFactory.newInstance().newTransformer();
StaxSource source = new StaxSource(streamReader); StAXSource source = new StAXSource(streamReader);
StringWriter writer = new StringWriter(); StringWriter writer = new StringWriter();
transformer.transform(source, new StreamResult(writer)); transformer.transform(source, new StreamResult(writer));
assertXMLEqual(XML, writer.toString()); assertXMLEqual(XML, writer.toString());
} }
} }

Write Preview
Loading…
Cancel
Save