Source code: org/apache/http/impl/entity/TestDefaultEntityDeserializer.java
1 /*
2 * $HeadURL: https://svn.apache.org/repos/asf/jakarta/httpcomponents/httpcore/tags/4.0-alpha2/src/test/org/apache/http/impl/entity/TestDefaultEntityDeserializer.java $
3 * $Revision: 385860 $
4 * $Date: 2006-03-14 20:25:26 +0100 (Tue, 14 Mar 2006) $
5 * ====================================================================
6 *
7 * Copyright 2002-2004 The Apache Software Foundation
8 *
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 * ====================================================================
21 *
22 * This software consists of voluntary contributions made by many
23 * individuals on behalf of the Apache Software Foundation. For more
24 * information on the Apache Software Foundation, please see
25 * <http://www.apache.org/>.
26 *
27 */
28
29 package org.apache.http.impl.entity;
30
31 import java.io.InputStream;
32
33 import org.apache.http.Header;
34 import org.apache.http.HttpEntity;
35 import org.apache.http.HttpMessage;
36 import org.apache.http.ProtocolException;
37 import org.apache.http.entity.EntityDeserializer;
38 import org.apache.http.impl.entity.DefaultEntityDeserializer;
39 import org.apache.http.io.ChunkedInputStream;
40 import org.apache.http.io.ContentLengthInputStream;
41 import org.apache.http.io.HttpDataInputStream;
42 import org.apache.http.io.HttpDataReceiver;
43 import org.apache.http.mockup.HttpDataReceiverMockup;
44 import org.apache.http.mockup.HttpMessageMockup;
45 import org.apache.http.params.HttpProtocolParams;
46
47 import junit.framework.Test;
48 import junit.framework.TestCase;
49 import junit.framework.TestSuite;
50
51 public class TestDefaultEntityDeserializer extends TestCase {
52
53 public TestDefaultEntityDeserializer(String testName) {
54 super(testName);
55 }
56
57 // ------------------------------------------------------- TestCase Methods
58
59 public static Test suite() {
60 return new TestSuite(TestDefaultEntityDeserializer.class);
61 }
62
63 // ------------------------------------------------------------------- Main
64 public static void main(String args[]) {
65 String[] testCaseName = { TestDefaultEntityDeserializer.class.getName() };
66 junit.textui.TestRunner.main(testCaseName);
67 }
68
69 public void testIllegalGenerateArg() throws Exception {
70 EntityDeserializer entitygen = new DefaultEntityDeserializer();
71 try {
72 entitygen.deserialize(null, null);
73 fail("IllegalArgumentException should have been thrown");
74 } catch (IllegalArgumentException ex) {
75 // expected
76 }
77 try {
78 entitygen.deserialize(new HttpDataReceiverMockup(new byte[] {}) , null);
79 fail("IllegalArgumentException should have been thrown");
80 } catch (IllegalArgumentException ex) {
81 // expected
82 }
83 }
84
85 public void testEntityWithTransferEncoding() throws Exception {
86 HttpDataReceiver datareceiver = new HttpDataReceiverMockup("0\r\n", "US-ASCII");
87 HttpMessage message = new HttpMessageMockup();
88
89 // lenient mode
90 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, false);
91 message.addHeader(new Header("Content-Type", "unknown"));
92 message.addHeader(new Header("Transfer-Encoding", "identity, chunked"));
93 message.addHeader(new Header("Content-Length", "plain wrong"));
94 EntityDeserializer entitygen = new DefaultEntityDeserializer();
95 HttpEntity entity = entitygen.deserialize(datareceiver, message);
96 assertNotNull(entity);
97 assertEquals(-1, entity.getContentLength());
98 assertTrue(entity.isChunked());
99 assertTrue(entity.getContent() instanceof ChunkedInputStream);
100
101 // strict mode
102 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, true);
103 entity = entitygen.deserialize(datareceiver, message);
104 assertNotNull(entity);
105 assertEquals(-1, entity.getContentLength());
106 assertTrue(entity.isChunked());
107 assertTrue(entity.getContent() instanceof ChunkedInputStream);
108 }
109
110 public void testEntityWithIdentityTransferEncoding() throws Exception {
111 HttpDataReceiver datareceiver =
112 new HttpDataReceiverMockup(new byte[] {});
113 HttpMessage message = new HttpMessageMockup();
114
115 // lenient mode
116 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, false);
117 message.addHeader(new Header("Content-Type", "unknown"));
118 message.addHeader(new Header("Transfer-Encoding", "identity"));
119 message.addHeader(new Header("Content-Length", "plain wrong"));
120 EntityDeserializer entitygen = new DefaultEntityDeserializer();
121 HttpEntity entity = entitygen.deserialize(datareceiver, message);
122 assertNotNull(entity);
123 assertEquals(-1, entity.getContentLength());
124 assertFalse(entity.isChunked());
125 }
126
127 public void testEntityWithUnsupportedTransferEncoding() throws Exception {
128 HttpDataReceiver datareceiver = new HttpDataReceiverMockup("0\r\n", "US-ASCII");
129 HttpMessage message = new HttpMessageMockup();
130
131 // lenient mode
132 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, false);
133 message.addHeader(new Header("Content-Type", "unknown"));
134 message.addHeader(new Header("Transfer-Encoding", "whatever; param=value, chunked"));
135 message.addHeader(new Header("Content-Length", "plain wrong"));
136 EntityDeserializer entitygen = new DefaultEntityDeserializer();
137 HttpEntity entity = entitygen.deserialize(datareceiver, message);
138 assertNotNull(entity);
139 assertEquals(-1, entity.getContentLength());
140 assertTrue(entity.isChunked());
141 assertTrue(entity.getContent() instanceof ChunkedInputStream);
142
143 // strict mode
144 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, true);
145 try {
146 entitygen.deserialize(datareceiver, message);
147 fail("ProtocolException should have been thrown");
148 } catch (ProtocolException ex) {
149 // expected
150 }
151 }
152
153 public void testChunkedTransferEncodingMustBeLast() throws Exception {
154 HttpDataReceiver datareceiver = new HttpDataReceiverMockup("0\r\n", "US-ASCII");
155 HttpMessage message = new HttpMessageMockup();
156
157 // lenient mode
158 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, false);
159 message.addHeader(new Header("Content-Type", "unknown"));
160 message.addHeader(new Header("Transfer-Encoding", "chunked, identity"));
161 message.addHeader(new Header("Content-Length", "plain wrong"));
162 EntityDeserializer entitygen = new DefaultEntityDeserializer();
163 HttpEntity entity = entitygen.deserialize(datareceiver, message);
164 assertNotNull(entity);
165 assertEquals(-1, entity.getContentLength());
166 assertFalse(entity.isChunked());
167 assertFalse(entity.getContent() instanceof ChunkedInputStream);
168
169 // strict mode
170 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, true);
171 try {
172 entitygen.deserialize(datareceiver, message);
173 fail("ProtocolException should have been thrown");
174 } catch (ProtocolException ex) {
175 // expected
176 }
177 }
178
179 public void testEntityWithContentLength() throws Exception {
180 HttpDataReceiver datareceiver = new HttpDataReceiverMockup(new byte[] {});
181 HttpMessage message = new HttpMessageMockup();
182
183 // lenient mode
184 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, false);
185 message.addHeader(new Header("Content-Type", "unknown"));
186 message.addHeader(new Header("Content-Length", "0"));
187 EntityDeserializer entitygen = new DefaultEntityDeserializer();
188 HttpEntity entity = entitygen.deserialize(datareceiver, message);
189 assertNotNull(entity);
190 assertEquals(0, entity.getContentLength());
191 assertFalse(entity.isChunked());
192 assertTrue(entity.getContent() instanceof ContentLengthInputStream);
193 }
194
195 public void testEntityWithMultipleContentLength() throws Exception {
196 HttpDataReceiver datareceiver = new HttpDataReceiverMockup(new byte[] {'0'});
197 HttpMessage message = new HttpMessageMockup();
198
199 // lenient mode
200 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, false);
201 message.addHeader(new Header("Content-Type", "unknown"));
202 message.addHeader(new Header("Content-Length", "0"));
203 message.addHeader(new Header("Content-Length", "0"));
204 message.addHeader(new Header("Content-Length", "1"));
205 EntityDeserializer entitygen = new DefaultEntityDeserializer();
206 HttpEntity entity = entitygen.deserialize(datareceiver, message);
207 assertNotNull(entity);
208 assertEquals(1, entity.getContentLength());
209 assertFalse(entity.isChunked());
210 InputStream instream = entity.getContent();
211 assertNotNull(instream);
212 assertTrue(instream instanceof ContentLengthInputStream);
213
214 // strict mode
215 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, true);
216 try {
217 entitygen.deserialize(datareceiver, message);
218 fail("ProtocolException should have been thrown");
219 } catch (ProtocolException ex) {
220 // expected
221 }
222 }
223
224 public void testEntityWithMultipleContentLengthSomeWrong() throws Exception {
225 HttpDataReceiver datareceiver = new HttpDataReceiverMockup(new byte[] {'0'});
226 HttpMessage message = new HttpMessageMockup();
227
228 // lenient mode
229 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, false);
230 message.addHeader(new Header("Content-Type", "unknown"));
231 message.addHeader(new Header("Content-Length", "1"));
232 message.addHeader(new Header("Content-Length", "yyy"));
233 message.addHeader(new Header("Content-Length", "xxx"));
234 EntityDeserializer entitygen = new DefaultEntityDeserializer();
235 HttpEntity entity = entitygen.deserialize(datareceiver, message);
236 assertNotNull(entity);
237 assertEquals(1, entity.getContentLength());
238 assertFalse(entity.isChunked());
239 InputStream instream = entity.getContent();
240 assertNotNull(instream);
241 assertTrue(instream instanceof ContentLengthInputStream);
242
243 // strict mode
244 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, true);
245 try {
246 entitygen.deserialize(datareceiver, message);
247 fail("ProtocolException should have been thrown");
248 } catch (ProtocolException ex) {
249 // expected
250 }
251 }
252
253 public void testEntityWithMultipleContentLengthAllWrong() throws Exception {
254 HttpDataReceiver datareceiver = new HttpDataReceiverMockup(new byte[] {'0'});
255 HttpMessage message = new HttpMessageMockup();
256
257 // lenient mode
258 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, false);
259 message.addHeader(new Header("Content-Type", "unknown"));
260 message.addHeader(new Header("Content-Length", "yyy"));
261 message.addHeader(new Header("Content-Length", "xxx"));
262 EntityDeserializer entitygen = new DefaultEntityDeserializer();
263 HttpEntity entity = entitygen.deserialize(datareceiver, message);
264 assertNotNull(entity);
265 assertEquals(-1, entity.getContentLength());
266 assertFalse(entity.isChunked());
267 InputStream instream = entity.getContent();
268 assertNotNull(instream);
269 assertFalse(instream instanceof ContentLengthInputStream);
270 assertTrue(instream instanceof HttpDataInputStream);
271
272 // strict mode
273 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, true);
274 try {
275 entitygen.deserialize(datareceiver, message);
276 fail("ProtocolException should have been thrown");
277 } catch (ProtocolException ex) {
278 // expected
279 }
280 }
281
282 public void testEntityWithInvalidContentLength() throws Exception {
283 HttpDataReceiver datareceiver = new HttpDataReceiverMockup(new byte[] {'0'});
284 HttpMessage message = new HttpMessageMockup();
285
286 // lenient mode
287 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, false);
288 message.addHeader(new Header("Content-Type", "unknown"));
289 message.addHeader(new Header("Content-Length", "xxx"));
290 EntityDeserializer entitygen = new DefaultEntityDeserializer();
291 HttpEntity entity = entitygen.deserialize(datareceiver, message);
292 assertNotNull(entity);
293 assertEquals(-1, entity.getContentLength());
294 assertFalse(entity.isChunked());
295 InputStream instream = entity.getContent();
296 assertNotNull(instream);
297 assertFalse(instream instanceof ContentLengthInputStream);
298 assertTrue(instream instanceof HttpDataInputStream);
299
300 // strict mode
301 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, true);
302 try {
303 entitygen.deserialize(datareceiver, message);
304 fail("ProtocolException should have been thrown");
305 } catch (ProtocolException ex) {
306 // expected
307 }
308 }
309
310 public void testEntityNeitherContentLengthNorTransferEncoding() throws Exception {
311 HttpDataReceiver datareceiver = new HttpDataReceiverMockup(new byte[] {'0'});
312 HttpMessage message = new HttpMessageMockup();
313
314 // lenient mode
315 message.getParams().setBooleanParameter(HttpProtocolParams.STRICT_TRANSFER_ENCODING, false);
316 EntityDeserializer entitygen = new DefaultEntityDeserializer();
317 HttpEntity entity = entitygen.deserialize(datareceiver, message);
318 assertNotNull(entity);
319 assertEquals(-1, entity.getContentLength());
320 assertFalse(entity.isChunked());
321 InputStream instream = entity.getContent();
322 assertNotNull(instream);
323 assertFalse(instream instanceof ContentLengthInputStream);
324 assertFalse(instream instanceof ChunkedInputStream);
325 assertTrue(instream instanceof HttpDataInputStream);
326 }
327
328 public void testEntityContentType() throws Exception {
329 HttpDataReceiver datareceiver = new HttpDataReceiverMockup(new byte[] {'0'});
330 HttpMessage message = new HttpMessageMockup();
331
332 message.addHeader(new Header("Content-Type", "stuff"));
333 EntityDeserializer entitygen = new DefaultEntityDeserializer();
334 HttpEntity entity = entitygen.deserialize(datareceiver, message);
335 assertNotNull(entity);
336 assertNotNull(entity.getContentType());
337 assertEquals("stuff", entity.getContentType().getValue());
338 }
339
340 public void testEntityContentEncoding() throws Exception {
341 HttpDataReceiver datareceiver = new HttpDataReceiverMockup(new byte[] {'0'});
342 HttpMessage message = new HttpMessageMockup();
343
344 message.addHeader(new Header("Content-Encoding", "what not"));
345 EntityDeserializer entitygen = new DefaultEntityDeserializer();
346 HttpEntity entity = entitygen.deserialize(datareceiver, message);
347 assertNotNull(entity);
348 assertNotNull(entity.getContentEncoding());
349 assertEquals("what not", entity.getContentEncoding().getValue());
350 }
351
352 }
353