source: contrib/MailArchiver/sources/vendor/mime4j/custom/core/src/test/java/org/apache/james/mime4j/stream/MimeEntityTest.java @ 6785

Revision 6785, 30.4 KB checked in by rafaelraymundo, 12 years ago (diff)

Ticket #2946 - Liberado codigo do MailArchiver?. Documentação na subpasta DOCS.

Line 
1/****************************************************************
2 * Licensed to the Apache Software Foundation (ASF) under one   *
3 * or more contributor license agreements.  See the NOTICE file *
4 * distributed with this work for additional information        *
5 * regarding copyright ownership.  The ASF licenses this file   *
6 * to you under the Apache License, Version 2.0 (the            *
7 * "License"); you may not use this file except in compliance   *
8 * with the License.  You may obtain a copy of the License at   *
9 *                                                              *
10 *   http://www.apache.org/licenses/LICENSE-2.0                 *
11 *                                                              *
12 * Unless required by applicable law or agreed to in writing,   *
13 * software distributed under the License is distributed on an  *
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
15 * KIND, either express or implied.  See the License for the    *
16 * specific language governing permissions and limitations      *
17 * under the License.                                           *
18 ****************************************************************/
19
20package org.apache.james.mime4j.stream;
21
22import java.io.ByteArrayInputStream;
23import java.io.IOException;
24import java.util.Locale;
25
26import junit.framework.TestCase;
27
28import org.apache.commons.io.IOUtils;
29import org.apache.james.mime4j.MimeException;
30import org.apache.james.mime4j.io.BufferedLineReaderInputStream;
31import org.apache.james.mime4j.io.LineNumberInputStream;
32import org.apache.james.mime4j.io.MaxHeaderLengthLimitException;
33import org.apache.james.mime4j.io.MaxHeaderLimitException;
34import org.apache.james.mime4j.io.MaxLineLimitException;
35
36public class MimeEntityTest extends TestCase {
37
38    public void testSimpleEntity() throws Exception {
39        String message =
40            "To: Road Runner <runner@example.org>\r\n" +
41            "From: Wile E. Cayote <wile@example.org>\r\n" +
42            "Date: Tue, 12 Feb 2008 17:34:09 +0000 (GMT)\r\n" +
43            "Subject: Mail\r\n" +
44            "Content-Type: text/plain\r\n" +
45            "\r\n" +
46            "a very important message";
47        byte[] raw = message.getBytes("US-ASCII");
48        ByteArrayInputStream instream = new ByteArrayInputStream(raw);
49        LineNumberInputStream lineInput = new LineNumberInputStream(instream);
50        BufferedLineReaderInputStream rawstream = new BufferedLineReaderInputStream(lineInput, 12);
51
52        MimeEntity entity = new MimeEntity(
53                lineInput,
54                rawstream, new DefaultBodyDescriptor());
55
56
57        assertEquals(EntityState.T_START_MESSAGE, entity.getState());
58        entity.advance();
59        assertEquals(EntityState.T_START_HEADER, entity.getState());
60        entity.advance();
61        assertEquals(EntityState.T_FIELD, entity.getState());
62        assertEquals("To", entity.getField().getName());
63        assertEquals("Road Runner <runner@example.org>", entity.getField().getBody());
64        entity.advance();
65        assertEquals(EntityState.T_FIELD, entity.getState());
66        assertEquals("From", entity.getField().getName());
67        assertEquals("Wile E. Cayote <wile@example.org>", entity.getField().getBody());
68        entity.advance();
69        assertEquals(EntityState.T_FIELD, entity.getState());
70        assertEquals("Date", entity.getField().getName());
71        assertEquals("Tue, 12 Feb 2008 17:34:09 +0000 (GMT)", entity.getField().getBody());
72        entity.advance();
73        assertEquals(EntityState.T_FIELD, entity.getState());
74        assertEquals("Subject", entity.getField().getName());
75        assertEquals("Mail", entity.getField().getBody());
76        entity.advance();
77        assertEquals(EntityState.T_FIELD, entity.getState());
78        assertEquals("Content-Type", entity.getField().getName());
79        assertEquals("text/plain", entity.getField().getBody());
80        entity.advance();
81        assertEquals(EntityState.T_END_HEADER, entity.getState());
82        try {
83            entity.getField().getName();
84            fail("IllegalStateException should have been thrown");
85        } catch (IllegalStateException expected) {
86        }
87        try {
88            entity.getField().getBody();
89            fail("IllegalStateException should have been thrown");
90        } catch (IllegalStateException expected) {
91        }
92
93        entity.advance();
94        assertEquals(EntityState.T_BODY, entity.getState());
95        assertEquals("a very important message", IOUtils.toString(entity.getContentStream()));
96        entity.advance();
97        assertEquals(EntityState.T_END_MESSAGE, entity.getState());
98        try {
99            entity.getContentStream();
100            fail("IllegalStateException should have been thrown");
101        } catch (IllegalStateException expected) {
102        }
103        entity.advance();
104        assertEquals(EntityState.T_END_OF_STREAM, entity.getState());
105        try {
106            entity.advance();
107            fail("IllegalStateException should have been thrown");
108        } catch (IllegalStateException expected) {
109        }
110    }
111
112    public void testObsoleteSyntaxEntity() throws Exception {
113        String message =
114            "To         : Road Runner <runner@example.org>\r\n" +
115            "From       : Wile E. Cayote <wile@example.org>\r\n" +
116            "Date       :Tue, 12 Feb 2008 17:34:09 +0000 (GMT)\r\n" +
117            "Subject    :Mail\r\n" +
118            "     \r\n" +
119            " with a folded subject \r\n" +
120            "Content-Type: text/plain\r\n" +
121            "\r\n" +
122            "a very important message";
123        byte[] raw = message.getBytes("US-ASCII");
124        ByteArrayInputStream instream = new ByteArrayInputStream(raw);
125        LineNumberInputStream lineInput = new LineNumberInputStream(instream);
126        BufferedLineReaderInputStream rawstream = new BufferedLineReaderInputStream(lineInput, 12);
127
128        MimeEntity entity = new MimeEntity(
129                lineInput,
130                rawstream, new DefaultBodyDescriptor());
131
132
133        assertEquals(EntityState.T_START_MESSAGE, entity.getState());
134        entity.advance();
135        assertEquals(EntityState.T_START_HEADER, entity.getState());
136        entity.advance();
137        assertEquals(EntityState.T_FIELD, entity.getState());
138        assertEquals("To", entity.getField().getName());
139        assertEquals("Road Runner <runner@example.org>", entity.getField().getBody());
140        entity.advance();
141        assertEquals(EntityState.T_FIELD, entity.getState());
142        assertEquals("From", entity.getField().getName());
143        assertEquals("Wile E. Cayote <wile@example.org>", entity.getField().getBody());
144        entity.advance();
145        assertEquals(EntityState.T_FIELD, entity.getState());
146        assertEquals("Date", entity.getField().getName());
147        assertEquals("Tue, 12 Feb 2008 17:34:09 +0000 (GMT)", entity.getField().getBody());
148        entity.advance();
149        assertEquals(EntityState.T_FIELD, entity.getState());
150        assertEquals("Subject", entity.getField().getName());
151        assertEquals("Mail      with a folded subject ", entity.getField().getBody());
152        entity.advance();
153        assertEquals(EntityState.T_FIELD, entity.getState());
154        assertEquals("Content-Type", entity.getField().getName());
155        assertEquals("text/plain", entity.getField().getBody());
156        entity.advance();
157        assertEquals(EntityState.T_END_HEADER, entity.getState());
158        try {
159            entity.getField().getName();
160            fail("IllegalStateException should have been thrown");
161        } catch (IllegalStateException expected) {
162        }
163        try {
164            entity.getField().getBody();
165            fail("IllegalStateException should have been thrown");
166        } catch (IllegalStateException expected) {
167        }
168
169        entity.advance();
170        assertEquals(EntityState.T_BODY, entity.getState());
171        assertEquals("a very important message", IOUtils.toString(entity.getContentStream()));
172        entity.advance();
173        assertEquals(EntityState.T_END_MESSAGE, entity.getState());
174        try {
175            entity.getContentStream();
176            fail("IllegalStateException should have been thrown");
177        } catch (IllegalStateException expected) {
178        }
179        entity.advance();
180        assertEquals(EntityState.T_END_OF_STREAM, entity.getState());
181        try {
182            entity.advance();
183            fail("IllegalStateException should have been thrown");
184        } catch (IllegalStateException expected) {
185        }
186    }
187
188    public void testMultipartEntity() throws Exception {
189        String message =
190            "To: Road Runner <runner@example.org>\r\n" +
191            "From: Wile E. Cayote <wile@example.org>\r\n" +
192            "Date: Tue, 12 Feb 2008 17:34:09 +0000 (GMT)\r\n" +
193            "Subject: Mail\r\n" +
194            "Content-Type: multipart/mixed;boundary=1729\r\n" +
195            "\r\n" +
196            "Hello!\r\n" +
197            "--1729\r\n" +
198            "Content-Type: text/plain; charset=US-ASCII\r\n" +
199            "\r\n" +
200            "blah blah blah\r\n" +
201            "--1729\r\n" +
202            "Content-Type: text/plain; charset=US-ASCII\r\n" +
203            "\r\n" +
204            "yada yada yada\r\n" +
205            "--1729--\r\n" +
206            "Goodbye!";
207        byte[] raw = message.getBytes("US-ASCII");
208        ByteArrayInputStream instream = new ByteArrayInputStream(raw);
209        LineNumberInputStream lineInput = new LineNumberInputStream(instream);
210        BufferedLineReaderInputStream rawstream = new BufferedLineReaderInputStream(lineInput, 24);
211
212        MimeEntity entity = new MimeEntity(
213                lineInput,
214                rawstream, new DefaultBodyDescriptor());
215
216        assertEquals(EntityState.T_START_MESSAGE, entity.getState());
217        entity.advance();
218        assertEquals(EntityState.T_START_HEADER, entity.getState());
219        entity.advance();
220        assertEquals(EntityState.T_FIELD, entity.getState());
221        assertEquals("To", entity.getField().getName());
222        assertEquals("Road Runner <runner@example.org>", entity.getField().getBody());
223        entity.advance();
224        assertEquals(EntityState.T_FIELD, entity.getState());
225        assertEquals("From", entity.getField().getName());
226        assertEquals("Wile E. Cayote <wile@example.org>", entity.getField().getBody());
227        entity.advance();
228        assertEquals(EntityState.T_FIELD, entity.getState());
229        assertEquals("Date", entity.getField().getName());
230        assertEquals("Tue, 12 Feb 2008 17:34:09 +0000 (GMT)", entity.getField().getBody());
231        entity.advance();
232        assertEquals(EntityState.T_FIELD, entity.getState());
233        assertEquals("Subject", entity.getField().getName());
234        assertEquals("Mail", entity.getField().getBody());
235        entity.advance();
236        assertEquals(EntityState.T_FIELD, entity.getState());
237        assertEquals("Content-Type", entity.getField().getName());
238        assertEquals("multipart/mixed;boundary=1729", entity.getField().getBody());
239        entity.advance();
240        assertEquals(EntityState.T_END_HEADER, entity.getState());
241        entity.advance();
242        assertEquals(EntityState.T_START_MULTIPART, entity.getState());
243        entity.advance();
244        assertEquals(EntityState.T_PREAMBLE, entity.getState());
245        assertEquals("Hello!", IOUtils.toString(entity.getContentStream()));
246
247        EntityStateMachine p1 = entity.advance();
248        assertNotNull(p1);
249
250        assertEquals(EntityState.T_START_BODYPART, p1.getState());
251        p1.advance();
252        assertEquals(EntityState.T_START_HEADER, p1.getState());
253        p1.advance();
254        assertEquals(EntityState.T_FIELD, p1.getState());
255        assertEquals("Content-Type", p1.getField().getName());
256        assertEquals("text/plain; charset=US-ASCII", p1.getField().getBody());
257        p1.advance();
258        assertEquals(EntityState.T_END_HEADER, p1.getState());
259        p1.advance();
260        assertEquals(EntityState.T_BODY, p1.getState());
261        assertEquals("blah blah blah", IOUtils.toString(p1.getContentStream()));
262        p1.advance();
263        assertEquals(EntityState.T_END_BODYPART, p1.getState());
264        p1.advance();
265        assertEquals(EntityState.T_END_OF_STREAM, p1.getState());
266
267        EntityStateMachine p2 = entity.advance();
268        assertNotNull(p2);
269
270        assertEquals(EntityState.T_START_BODYPART, p2.getState());
271        p2.advance();
272        assertEquals(EntityState.T_START_HEADER, p2.getState());
273        p2.advance();
274        assertEquals(EntityState.T_FIELD, p2.getState());
275        assertEquals("Content-Type", p2.getField().getName());
276        assertEquals("text/plain; charset=US-ASCII", p2.getField().getBody());
277        p2.advance();
278        assertEquals(EntityState.T_END_HEADER, p2.getState());
279        p2.advance();
280        assertEquals(EntityState.T_BODY, p2.getState());
281        assertEquals("yada yada yada", IOUtils.toString(p2.getContentStream()));
282        p2.advance();
283        assertEquals(EntityState.T_END_BODYPART, p2.getState());
284        p2.advance();
285        assertEquals(EntityState.T_END_OF_STREAM, p2.getState());
286
287        entity.advance();
288        assertEquals(EntityState.T_EPILOGUE, entity.getState());
289        assertEquals("Goodbye!", IOUtils.toString(entity.getContentStream()));
290        entity.advance();
291        assertEquals(EntityState.T_END_MULTIPART, entity.getState());
292        entity.advance();
293        assertEquals(EntityState.T_END_MESSAGE, entity.getState());
294        entity.advance();
295        assertEquals(EntityState.T_END_OF_STREAM, entity.getState());
296    }
297
298    public void testRawEntity() throws Exception {
299        String message =
300            "To: Road Runner <runner@example.org>\r\n" +
301            "From: Wile E. Cayote <wile@example.org>\r\n" +
302            "Date: Tue, 12 Feb 2008 17:34:09 +0000 (GMT)\r\n" +
303            "Subject: Mail\r\n" +
304            "Content-Type: multipart/mixed;boundary=1729\r\n" +
305            "\r\n" +
306            "Hello!\r\n" +
307            "--1729\r\n" +
308            "Content-Type: text/plain; charset=US-ASCII\r\n" +
309            "\r\n" +
310            "blah blah blah\r\n" +
311            "--1729\r\n" +
312            "Content-Type: text/plain; charset=US-ASCII\r\n" +
313            "\r\n" +
314            "yada yada yada\r\n" +
315            "--1729--\r\n" +
316            "Goodbye!";
317        byte[] raw = message.getBytes("US-ASCII");
318        ByteArrayInputStream instream = new ByteArrayInputStream(raw);
319        LineNumberInputStream lineInput = new LineNumberInputStream(instream);
320        BufferedLineReaderInputStream rawstream = new BufferedLineReaderInputStream(lineInput, 24);
321
322        MimeEntity entity = new MimeEntity(
323                lineInput,
324                rawstream, new DefaultBodyDescriptor());
325
326        entity.setRecursionMode(RecursionMode.M_RAW);
327
328        assertEquals(EntityState.T_START_MESSAGE, entity.getState());
329        entity.advance();
330        assertEquals(EntityState.T_START_HEADER, entity.getState());
331        entity.advance();
332        assertEquals(EntityState.T_FIELD, entity.getState());
333        assertEquals("To", entity.getField().getName());
334        assertEquals("Road Runner <runner@example.org>", entity.getField().getBody());
335        entity.advance();
336        assertEquals(EntityState.T_FIELD, entity.getState());
337        assertEquals("From", entity.getField().getName());
338        assertEquals("Wile E. Cayote <wile@example.org>", entity.getField().getBody());
339        entity.advance();
340        assertEquals(EntityState.T_FIELD, entity.getState());
341        assertEquals("Date", entity.getField().getName());
342        assertEquals("Tue, 12 Feb 2008 17:34:09 +0000 (GMT)", entity.getField().getBody());
343        entity.advance();
344        assertEquals(EntityState.T_FIELD, entity.getState());
345        assertEquals("Subject", entity.getField().getName());
346        assertEquals("Mail", entity.getField().getBody());
347        entity.advance();
348        assertEquals(EntityState.T_FIELD, entity.getState());
349        assertEquals("Content-Type", entity.getField().getName());
350        assertEquals("multipart/mixed;boundary=1729", entity.getField().getBody());
351        entity.advance();
352        assertEquals(EntityState.T_END_HEADER, entity.getState());
353        entity.advance();
354        assertEquals(EntityState.T_START_MULTIPART, entity.getState());
355
356        entity.advance();
357        assertEquals(EntityState.T_PREAMBLE, entity.getState());
358        assertEquals("Hello!", IOUtils.toString(entity.getContentStream()));
359
360        EntityStateMachine p1 = entity.advance();
361        assertNotNull(p1);
362
363        assertEquals(EntityState.T_RAW_ENTITY, p1.getState());
364        assertNull(p1.getBodyDescriptor());
365        assertNull(p1.getField());
366        assertEquals(
367                "Content-Type: text/plain; charset=US-ASCII\r\n" +
368                "\r\n" +
369                "blah blah blah", IOUtils.toString(p1.getContentStream()));
370        p1.advance();
371        assertEquals(EntityState.T_END_OF_STREAM, p1.getState());
372
373        EntityStateMachine p2 = entity.advance();
374        assertNotNull(p2);
375
376        assertEquals(EntityState.T_RAW_ENTITY, p2.getState());
377        assertNull(p2.getBodyDescriptor());
378        assertNull(p2.getField());
379        assertEquals(
380                "Content-Type: text/plain; charset=US-ASCII\r\n" +
381                "\r\n" +
382                "yada yada yada", IOUtils.toString(p2.getContentStream()));
383        p2.advance();
384        assertEquals(EntityState.T_END_OF_STREAM, p2.getState());
385
386        entity.advance();
387        assertEquals(EntityState.T_EPILOGUE, entity.getState());
388        assertEquals("Goodbye!", IOUtils.toString(entity.getContentStream()));
389        entity.advance();
390        assertEquals(EntityState.T_END_MULTIPART, entity.getState());
391        entity.advance();
392        assertEquals(EntityState.T_END_MESSAGE, entity.getState());
393        entity.advance();
394        assertEquals(EntityState.T_END_OF_STREAM, entity.getState());
395    }
396
397    public void testMaxLineLimitCheck() throws Exception {
398        MimeEntityConfig config = new MimeEntityConfig();
399        config.setMaxLineLen(50);
400
401        String message =
402            "To: Road Runner <runner@example.org>\r\n" +
403            "From: Wile E. Cayote <wile@example.org>\r\n" +
404            "Date: Tue, 12 Feb 2008 17:34:09 +0000 (GMT)\r\n" +
405            "Subject: Mail\r\n" +
406            "DoS: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\r\n" +
407            "Content-Type: text/plain\r\n" +
408            "\r\n" +
409            "a very important message";
410        byte[] raw = message.getBytes("US-ASCII");
411        ByteArrayInputStream instream = new ByteArrayInputStream(raw);
412        LineNumberInputStream lineInput = new LineNumberInputStream(instream);
413        BufferedLineReaderInputStream rawstream = new BufferedLineReaderInputStream(lineInput, 12, config.getMaxLineLen());
414
415        MimeEntity entity = new MimeEntity(
416                lineInput,
417                rawstream,
418                config,
419                new DefaultBodyDescriptor());
420
421        assertEquals(EntityState.T_START_MESSAGE, entity.getState());
422        entity.advance(); // advances to T_START_HEADER
423        assertEquals(EntityState.T_START_HEADER, entity.getState());
424        entity.advance(); // reads To: into field buffer, From: into line buffer
425        assertEquals(EntityState.T_FIELD, entity.getState());
426        entity.advance(); // reads Date: into line buffer
427        assertEquals(EntityState.T_FIELD, entity.getState());
428        entity.advance(); // reads Subject: into line buffer
429        assertEquals(EntityState.T_FIELD, entity.getState());
430        try {
431            entity.advance(); // reads DoS: into line buffer
432            fail("MimeException caused by MaxLineLimitException should have been thrown");
433        } catch (MimeException expected) {
434            assertTrue(expected.getCause() instanceof MaxLineLimitException);
435        }
436    }
437
438    public void testMaxHeaderLimitCheckFoldedLines() throws Exception {
439        String message =
440            "To: Road Runner <runner@example.org>\r\n" +
441            "From: Wile E. Cayote <wile@example.org>\r\n" +
442            "Date: Tue, 12 Feb 2008 17:34:09 +0000 (GMT)\r\n" +
443            "Subject: Mail\r\n" +
444            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
445            "    xxxxxxxxxxxxxxxxxxxxx\r\n" +
446            "    xxxxxxxxxxxxxxxxxxxxx\r\n" +
447            "    xxxxxxxxxxxxxxxxxxxxx\r\n" +
448            "    xxxxxxxxxxxxxxxxxxxxx\r\n" +
449            "    xxxxxxxxxxxxxxxxxxxxx\r\n" +
450            "    xxxxxxxxxxxxxxxxxxxxx\r\n" +
451            "    xxxxxxxxxxxxxxxxxxxxx\r\n" +
452            "    xxxxxxxxxxxxxxxxxxxxx\r\n" +
453            "    xxxxxxxxxxxxxxxxxxxxx\r\n" +
454            "    xxxxxxxxxxxxxxxxxxxxx\r\n" +
455            "    xxxxxxxxxxxxxxxxxxxxx\r\n" +
456            "Content-Type: text/plain\r\n" +
457            "\r\n" +
458            "a very important message";
459        byte[] raw = message.getBytes("US-ASCII");
460        ByteArrayInputStream instream = new ByteArrayInputStream(raw);
461        LineNumberInputStream lineInput = new LineNumberInputStream(instream);
462        BufferedLineReaderInputStream rawstream = new BufferedLineReaderInputStream(lineInput, 12);
463
464        MimeEntityConfig config = new MimeEntityConfig();
465        config.setMaxLineLen(100);
466        config.setMaxHeaderLen(200);
467        MimeEntity entity = new MimeEntity(
468                lineInput,
469                rawstream,
470                config,
471                new DefaultBodyDescriptor());
472
473        assertEquals(EntityState.T_START_MESSAGE, entity.getState());
474        entity.advance();
475        assertEquals(EntityState.T_START_HEADER, entity.getState());
476        entity.advance();
477        assertEquals(EntityState.T_FIELD, entity.getState());
478        entity.advance();
479        assertEquals(EntityState.T_FIELD, entity.getState());
480        entity.advance();
481        assertEquals(EntityState.T_FIELD, entity.getState());
482        entity.advance();
483        assertEquals(EntityState.T_FIELD, entity.getState());
484        try {
485            entity.advance();
486            fail("MimeException caused by MaxLineLimitException should have been thrown");
487        } catch (MaxHeaderLengthLimitException expected) {
488        }
489    }
490
491    public void testMaxHeaderLengthMayExceedMaxLineLength() throws Exception {
492        MimeEntityConfig config = new MimeEntityConfig();
493        config.setMaxLineLen(50);
494        config.setMaxHeaderLen(130);
495
496        String message =
497            "To: Road Runner <runner@example.org>\r\n" +
498            "From: Wile E. Cayote <wile@example.org>\r\n" +
499            "Date: Tue, 12 Feb 2008 17:34:09 +0000 (GMT)\r\n" +
500            "Subject: Mail\r\n" +
501            "X-LongHeader: xxxxxxxxxxxxxxxxxxxxxxx\r\n" +
502            "    xxxxxxxxxxxxxxxxxxxxxxx\r\n" +
503            "    xxxxxxxxxxxxxxxxxxxxxxx\r\n" +
504            "    xxxxxxxxxxxxxxxxxxxxxxx\r\n" +
505            "Content-Type: text/plain\r\n" +
506            "\r\n" +
507            "a very important message";
508        byte[] raw = message.getBytes("US-ASCII");
509        ByteArrayInputStream instream = new ByteArrayInputStream(raw);
510        LineNumberInputStream lineInput = new LineNumberInputStream(instream);
511        BufferedLineReaderInputStream rawstream = new BufferedLineReaderInputStream(lineInput, 12, config.getMaxLineLen());
512
513        MimeEntity entity = new MimeEntity(
514                lineInput,
515                rawstream,
516                config,
517                new DefaultBodyDescriptor());
518
519        assertEquals(EntityState.T_START_MESSAGE, entity.getState());
520        entity.advance();
521        assertEquals(EntityState.T_START_HEADER, entity.getState());
522        for (int i = 0; i < 6; i++) {
523            entity.advance();
524            assertEquals(EntityState.T_FIELD, entity.getState());
525        }
526        entity.advance();
527        assertEquals(EntityState.T_END_HEADER, entity.getState());
528    }
529
530    public void testMaxHeaderCount() throws Exception {
531        String message =
532            "To: Road Runner <runner@example.org>\r\n" +
533            "From: Wile E. Cayote <wile@example.org>\r\n" +
534            "Date: Tue, 12 Feb 2008 17:34:09 +0000 (GMT)\r\n" +
535            "Subject: Mail\r\n" +
536            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
537            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
538            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
539            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
540            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
541            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
542            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
543            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
544            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
545            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
546            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
547            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
548            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
549            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
550            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
551            "DoS: xxxxxxxxxxxxxxxxxxxxx\r\n" +
552            "Content-Type: text/plain\r\n" +
553            "\r\n" +
554            "a very important message";
555        byte[] raw = message.getBytes("US-ASCII");
556        ByteArrayInputStream instream = new ByteArrayInputStream(raw);
557        LineNumberInputStream lineInput = new LineNumberInputStream(instream);
558        BufferedLineReaderInputStream rawstream = new BufferedLineReaderInputStream(lineInput, 12);
559
560        MimeEntityConfig config = new MimeEntityConfig();
561        config.setMaxHeaderCount(20);
562        MimeEntity entity = new MimeEntity(
563                lineInput,
564                rawstream,
565                config,
566                new DefaultBodyDescriptor());
567
568        assertEquals(EntityState.T_START_MESSAGE, entity.getState());
569        entity.advance();
570        assertEquals(EntityState.T_START_HEADER, entity.getState());
571
572        for (int i = 0; i < 20; i++) {
573            entity.advance();
574            assertEquals(EntityState.T_FIELD, entity.getState());
575        }
576        try {
577            entity.advance();
578            fail("MaxHeaderLimitException should have been thrown");
579        } catch (MaxHeaderLimitException expected) {
580        }
581    }
582
583    public void testMaxContentLimitCheck() throws Exception {
584        String message =
585            "To: Road Runner <runner@example.org>\r\n" +
586            "From: Wile E. Cayote <wile@example.org>\r\n" +
587            "Date: Tue, 12 Feb 2008 17:34:09 +0000 (GMT)\r\n" +
588            "Subject: Mail\r\n" +
589            "Content-Type: text/plain\r\n" +
590            "\r\n" +
591            "DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS\r\n" +
592            "DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS\r\n" +
593            "DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS\r\n" +
594            "DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS\r\n" +
595            "DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS\r\n" +
596            "DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS\r\n" +
597            "DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS\r\n" +
598            "DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS\r\n" +
599            "DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS\r\n" +
600            "DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS DoS\r\n";
601        byte[] raw = message.getBytes("US-ASCII");
602        ByteArrayInputStream instream = new ByteArrayInputStream(raw);
603        LineNumberInputStream lineInput = new LineNumberInputStream(instream);
604        BufferedLineReaderInputStream rawstream = new BufferedLineReaderInputStream(lineInput, 12);
605
606        MimeEntityConfig config = new MimeEntityConfig();
607        config.setMaxContentLen(100);
608        MimeEntity entity = new MimeEntity(
609                lineInput,
610                rawstream,
611                config,
612                new DefaultBodyDescriptor());
613
614        assertEquals(EntityState.T_START_MESSAGE, entity.getState());
615        entity.advance();
616        assertEquals(EntityState.T_START_HEADER, entity.getState());
617        entity.advance();
618        assertEquals(EntityState.T_FIELD, entity.getState());
619        entity.advance();
620        assertEquals(EntityState.T_FIELD, entity.getState());
621        entity.advance();
622        assertEquals(EntityState.T_FIELD, entity.getState());
623        entity.advance();
624        assertEquals(EntityState.T_FIELD, entity.getState());
625        entity.advance();
626        assertEquals(EntityState.T_FIELD, entity.getState());
627        entity.advance();
628        assertEquals(EntityState.T_END_HEADER, entity.getState());
629        entity.advance();
630        assertEquals(EntityState.T_BODY, entity.getState());
631        try {
632            IOUtils.toByteArray(entity.getContentStream());
633            fail("IOException should have been thrown");
634        } catch (IOException expected) {
635        }
636    }
637
638    public void testSkipFields() throws Exception {
639        String message =
640            "To: Road Runner <runner@example.org>\r\n" +
641            "From: Wile E. Cayote <wile@example.org>\r\n" +
642            "Date: Tue, 12 Feb 2008 17:34:09 +0000 (GMT)\r\n" +
643            "Subject: Mail\r\n" +
644            "Content-Type: text/plain\r\n" +
645            "\r\n" +
646            "a very important message";
647        byte[] raw = message.getBytes("US-ASCII");
648        ByteArrayInputStream instream = new ByteArrayInputStream(raw);
649        LineNumberInputStream lineInput = new LineNumberInputStream(instream);
650        BufferedLineReaderInputStream rawstream = new BufferedLineReaderInputStream(lineInput, 12);
651
652        DefaultFieldBuilder fieldBuilder = new DefaultFieldBuilder(-1) {
653
654            @Override
655            public RawField build() throws MimeException {
656                RawField raw = super.build();
657                String name = raw.getName().toLowerCase(Locale.US);
658                if (name.equals("content-type") || name.equals("subject")) {
659                    return raw;
660                } else {
661                    return null;
662                }
663            }
664
665        };
666
667        MimeEntity entity = new MimeEntity(
668                lineInput,
669                rawstream, fieldBuilder, new DefaultBodyDescriptor());
670
671
672        assertEquals(EntityState.T_START_MESSAGE, entity.getState());
673        entity.advance();
674        assertEquals(EntityState.T_START_HEADER, entity.getState());
675        entity.advance();
676        assertEquals(EntityState.T_FIELD, entity.getState());
677        assertEquals("Subject", entity.getField().getName());
678        assertEquals("Mail", entity.getField().getBody());
679        entity.advance();
680        assertEquals(EntityState.T_FIELD, entity.getState());
681        assertEquals("Content-Type", entity.getField().getName());
682        assertEquals("text/plain", entity.getField().getBody());
683        entity.advance();
684        assertEquals(EntityState.T_END_HEADER, entity.getState());
685        entity.advance();
686        assertEquals(EntityState.T_BODY, entity.getState());
687        assertEquals("a very important message", IOUtils.toString(entity.getContentStream()));
688        entity.advance();
689        assertEquals(EntityState.T_END_MESSAGE, entity.getState());
690    }
691
692}
Note: See TracBrowser for help on using the repository browser.