1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.springframework.xml.transform;
18
19 import java.io.ByteArrayInputStream;
20 import java.io.ByteArrayOutputStream;
21 import java.io.InputStream;
22 import java.io.OutputStream;
23 import java.io.Reader;
24 import java.io.StringReader;
25 import java.io.StringWriter;
26 import java.io.Writer;
27 import javax.xml.parsers.DocumentBuilder;
28 import javax.xml.parsers.DocumentBuilderFactory;
29 import javax.xml.stream.XMLEventReader;
30 import javax.xml.stream.XMLEventWriter;
31 import javax.xml.stream.XMLInputFactory;
32 import javax.xml.stream.XMLOutputFactory;
33 import javax.xml.stream.XMLStreamReader;
34 import javax.xml.stream.XMLStreamWriter;
35 import javax.xml.transform.Result;
36 import javax.xml.transform.Source;
37 import javax.xml.transform.dom.DOMResult;
38 import javax.xml.transform.dom.DOMSource;
39 import javax.xml.transform.sax.SAXResult;
40 import javax.xml.transform.sax.SAXSource;
41 import javax.xml.transform.stream.StreamResult;
42 import javax.xml.transform.stream.StreamSource;
43
44 import org.springframework.util.xml.StaxUtils;
45
46 import org.junit.Assert;
47 import org.junit.Test;
48 import org.w3c.dom.Document;
49 import org.w3c.dom.Element;
50 import org.xml.sax.ContentHandler;
51 import org.xml.sax.InputSource;
52 import org.xml.sax.XMLReader;
53 import org.xml.sax.ext.DefaultHandler2;
54 import org.xml.sax.ext.LexicalHandler;
55 import org.xml.sax.helpers.DefaultHandler;
56 import org.xml.sax.helpers.XMLReaderFactory;
57
58 import static org.easymock.EasyMock.*;
59
60 public class TraxUtilsTest {
61
62 @Test
63 public void testGetDocument() throws Exception {
64 DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
65 documentBuilderFactory.setNamespaceAware(true);
66 DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
67 Document document = documentBuilder.newDocument();
68 Assert.assertSame("Invalid document", document, TraxUtils.getDocument(new DOMSource(document)));
69 Element element = document.createElement("element");
70 document.appendChild(element);
71 Assert.assertSame("Invalid document", document, TraxUtils.getDocument(new DOMSource(element)));
72 }
73
74 @Test
75 public void testDoWithDomSource() throws Exception {
76 DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
77 DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
78 Document document = documentBuilder.newDocument();
79
80 TraxUtils.SourceCallback mock = createMock(TraxUtils.SourceCallback.class);
81 mock.domSource(document);
82
83 replay(mock);
84
85 TraxUtils.doWithSource(new DOMSource(document), mock);
86
87 verify(mock);
88 }
89
90 @Test
91 public void testDoWithDomResult() throws Exception {
92 DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
93 DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
94 Document document = documentBuilder.newDocument();
95
96 TraxUtils.ResultCallback mock = createMock(TraxUtils.ResultCallback.class);
97 mock.domResult(document);
98
99 replay(mock);
100
101 TraxUtils.doWithResult(new DOMResult(document), mock);
102
103 verify(mock);
104 }
105
106 @Test
107 public void testDoWithSaxSource() throws Exception {
108 XMLReader reader = XMLReaderFactory.createXMLReader();
109 InputSource inputSource = new InputSource();
110
111 TraxUtils.SourceCallback mock = createMock(TraxUtils.SourceCallback.class);
112 mock.saxSource(reader, inputSource);
113
114 replay(mock);
115
116 TraxUtils.doWithSource(new SAXSource(reader, inputSource), mock);
117
118 verify(mock);
119 }
120
121 @Test
122 public void testDoWithSaxResult() throws Exception {
123 ContentHandler contentHandler = new DefaultHandler();
124 LexicalHandler lexicalHandler = new DefaultHandler2();
125
126 TraxUtils.ResultCallback mock = createMock(TraxUtils.ResultCallback.class);
127 mock.saxResult(contentHandler, lexicalHandler);
128
129 replay(mock);
130
131 SAXResult result = new SAXResult(contentHandler);
132 result.setLexicalHandler(lexicalHandler);
133 TraxUtils.doWithResult(result, mock);
134
135 verify(mock);
136 }
137
138 @Test
139 public void testDoWithStaxSourceEventReader() throws Exception {
140 XMLInputFactory inputFactory = XMLInputFactory.newInstance();
141 XMLEventReader eventReader = inputFactory.createXMLEventReader(new StringReader("<element/>"));
142
143 TraxUtils.SourceCallback mock = createMock(TraxUtils.SourceCallback.class);
144 mock.staxSource(eventReader);
145
146 replay(mock);
147
148 TraxUtils.doWithSource(StaxUtils.createStaxSource(eventReader), mock);
149
150 verify(mock);
151 }
152
153 @Test
154 public void testDoWithStaxResultEventWriter() throws Exception {
155 XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
156 XMLEventWriter eventWriter = outputFactory.createXMLEventWriter(new StringWriter());
157
158 TraxUtils.ResultCallback mock = createMock(TraxUtils.ResultCallback.class);
159 mock.staxResult(eventWriter);
160
161 replay(mock);
162
163 TraxUtils.doWithResult(StaxUtils.createStaxResult(eventWriter), mock);
164
165 verify(mock);
166 }
167
168 @Test
169 public void testDoWithStaxSourceStreamReader() throws Exception {
170 XMLInputFactory inputFactory = XMLInputFactory.newInstance();
171 XMLStreamReader streamReader = inputFactory.createXMLStreamReader(new StringReader("<element/>"));
172
173 TraxUtils.SourceCallback mock = createMock(TraxUtils.SourceCallback.class);
174 mock.staxSource(streamReader);
175
176 replay(mock);
177
178 TraxUtils.doWithSource(StaxUtils.createStaxSource(streamReader), mock);
179
180 verify(mock);
181 }
182
183 @Test
184 public void testDoWithStaxResultStreamWriter() throws Exception {
185 XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
186 XMLStreamWriter streamWriter = outputFactory.createXMLStreamWriter(new StringWriter());
187
188 TraxUtils.ResultCallback mock = createMock(TraxUtils.ResultCallback.class);
189 mock.staxResult(streamWriter);
190
191 replay(mock);
192
193 TraxUtils.doWithResult(StaxUtils.createStaxResult(streamWriter), mock);
194
195 verify(mock);
196 }
197
198 @Test
199 public void testDoWithStreamSourceInputStream() throws Exception {
200 byte[] xml = "<element/>".getBytes("UTF-8");
201 InputStream inputStream = new ByteArrayInputStream(xml);
202
203 TraxUtils.SourceCallback mock = createMock(TraxUtils.SourceCallback.class);
204 mock.streamSource(inputStream);
205
206 replay(mock);
207
208 TraxUtils.doWithSource(new StreamSource(inputStream), mock);
209
210 verify(mock);
211 }
212
213 @Test
214 public void testDoWithStreamResultOutputStream() throws Exception {
215 OutputStream outputStream = new ByteArrayOutputStream();
216
217 TraxUtils.ResultCallback mock = createMock(TraxUtils.ResultCallback.class);
218 mock.streamResult(outputStream);
219
220 replay(mock);
221
222 TraxUtils.doWithResult(new StreamResult(outputStream), mock);
223
224 verify(mock);
225 }
226
227 @Test
228 public void testDoWithStreamSourceReader() throws Exception {
229 String xml = "<element/>";
230 Reader reader = new StringReader(xml);
231
232 TraxUtils.SourceCallback mock = createMock(TraxUtils.SourceCallback.class);
233 mock.streamSource(reader);
234
235 replay(mock);
236
237 TraxUtils.doWithSource(new StreamSource(reader), mock);
238
239 verify(mock);
240 }
241
242 @Test
243 public void testDoWithStreamResultWriter() throws Exception {
244 Writer writer = new StringWriter();
245
246 TraxUtils.ResultCallback mock = createMock(TraxUtils.ResultCallback.class);
247 mock.streamResult(writer);
248
249 replay(mock);
250
251 TraxUtils.doWithResult(new StreamResult(writer), mock);
252
253 verify(mock);
254 }
255
256 @Test
257 public void testDoWithSystemIdSource() throws Exception {
258 String systemId = "http://www.springframework.org/dtd/spring-beans.dtd";
259
260 TraxUtils.SourceCallback mock = createMock(TraxUtils.SourceCallback.class);
261 mock.source(systemId);
262
263 replay(mock);
264
265 TraxUtils.doWithSource(new StreamSource(systemId), mock);
266
267 verify(mock);
268 }
269
270 @Test
271 public void testDoWithSystemIdResult() throws Exception {
272 String systemId = "http://www.springframework.org/dtd/spring-beans.dtd";
273
274 TraxUtils.ResultCallback mock = createMock(TraxUtils.ResultCallback.class);
275 mock.result(systemId);
276
277 replay(mock);
278
279 TraxUtils.doWithResult(new StreamResult(systemId), mock);
280
281 verify(mock);
282 }
283
284
285 @Test
286 public void testDoWithInvalidSource() throws Exception {
287 Source source = new Source() {
288
289 public void setSystemId(String systemId) {
290 }
291
292 public String getSystemId() {
293 return null;
294 }
295 };
296
297 try {
298 TraxUtils.doWithSource(source, null);
299 Assert.fail("IllegalArgumentException expected");
300 }
301 catch (IllegalArgumentException ex) {
302
303 }
304 }
305
306 @Test
307 public void testDoWithInvalidResult() throws Exception {
308 Result result = new Result() {
309
310 public void setSystemId(String systemId) {
311 }
312
313 public String getSystemId() {
314 return null;
315 }
316 };
317
318 try {
319 TraxUtils.doWithResult(result, null);
320 Assert.fail("IllegalArgumentException expected");
321 }
322 catch (IllegalArgumentException ex) {
323
324 }
325 }
326 }