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

Revision 6785, 17.8 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.util.List;
23
24import org.apache.james.mime4j.MimeException;
25import org.apache.james.mime4j.util.ByteSequence;
26import org.apache.james.mime4j.util.ContentUtil;
27
28import junit.framework.Assert;
29import junit.framework.TestCase;
30
31public class RawFieldParserTest extends TestCase {
32
33    public void testBasicTokenParsing() throws Exception {
34        String s = "   raw: \" some stuff \"";
35        ByteSequence raw = ContentUtil.encode(s);
36        ParserCursor cursor = new ParserCursor(0, s.length());
37
38        RawFieldParser.skipWhiteSpace(raw, cursor);
39
40        Assert.assertFalse(cursor.atEnd());
41        Assert.assertEquals(3, cursor.getPos());
42
43        StringBuilder strbuf1 = new StringBuilder();
44        RawFieldParser.copyContent(raw, cursor, new int[] { ':' }, strbuf1);
45
46        Assert.assertFalse(cursor.atEnd());
47        Assert.assertEquals(6, cursor.getPos());
48        Assert.assertEquals("raw", strbuf1.toString());
49        Assert.assertEquals(':', raw.byteAt(cursor.getPos()));
50        cursor.updatePos(cursor.getPos() + 1);
51
52        RawFieldParser.skipWhiteSpace(raw, cursor);
53
54        Assert.assertFalse(cursor.atEnd());
55        Assert.assertEquals(8, cursor.getPos());
56
57        StringBuilder strbuf2 = new StringBuilder();
58        RawFieldParser.copyQuotedContent(raw, cursor, strbuf2);
59
60        Assert.assertTrue(cursor.atEnd());
61        Assert.assertEquals(" some stuff ", strbuf2.toString());
62
63        RawFieldParser.copyQuotedContent(raw, cursor, strbuf2);
64        Assert.assertTrue(cursor.atEnd());
65
66        RawFieldParser.skipWhiteSpace(raw, cursor);
67        Assert.assertTrue(cursor.atEnd());
68    }
69
70    public void testTokenParsingWithQuotedPairs() throws Exception {
71        String s = "raw: \"\\\"some\\stuff\\\\\"";
72        ByteSequence raw = ContentUtil.encode(s);
73        ParserCursor cursor = new ParserCursor(0, s.length());
74
75        RawFieldParser.skipWhiteSpace(raw, cursor);
76
77        Assert.assertFalse(cursor.atEnd());
78        Assert.assertEquals(0, cursor.getPos());
79
80        StringBuilder strbuf1 = new StringBuilder();
81        RawFieldParser.copyContent(raw, cursor, new int[] { ':' }, strbuf1);
82
83        Assert.assertFalse(cursor.atEnd());
84        Assert.assertEquals("raw", strbuf1.toString());
85        Assert.assertEquals(':', raw.byteAt(cursor.getPos()));
86        cursor.updatePos(cursor.getPos() + 1);
87
88        RawFieldParser.skipWhiteSpace(raw, cursor);
89
90        Assert.assertFalse(cursor.atEnd());
91
92        StringBuilder strbuf2 = new StringBuilder();
93        RawFieldParser.copyQuotedContent(raw, cursor, strbuf2);
94
95        Assert.assertTrue(cursor.atEnd());
96        Assert.assertEquals("\"some\\stuff\\", strbuf2.toString());
97    }
98
99    public void testTokenParsingIncompleteQuote() throws Exception {
100        String s = "\"stuff and more stuff  ";
101        ByteSequence raw = ContentUtil.encode(s);
102        ParserCursor cursor = new ParserCursor(0, s.length());
103        StringBuilder strbuf1 = new StringBuilder();
104        RawFieldParser.copyQuotedContent(raw, cursor, strbuf1);
105        Assert.assertEquals("stuff and more stuff  ", strbuf1.toString());
106    }
107
108    public void testSkipComments() throws Exception {
109        String s = "(some (((maybe))human readable) stuff())";
110        ByteSequence raw = ContentUtil.encode(s);
111        ParserCursor cursor = new ParserCursor(0, s.length());
112
113        RawFieldParser.skipComment(raw, cursor);
114        Assert.assertTrue(cursor.atEnd());
115    }
116
117    public void testSkipCommentsWithQuotedPairs() throws Exception {
118        String s = "(some (((\\)maybe))human readable\\() stuff())";
119        ByteSequence raw = ContentUtil.encode(s);
120        ParserCursor cursor = new ParserCursor(0, s.length());
121
122        RawFieldParser.skipComment(raw, cursor);
123        Assert.assertTrue(cursor.atEnd());
124    }
125
126    public void testTokenParsingTokensWithUnquotedBlanks() throws Exception {
127        String s = "  stuff and   \tsome\tmore  stuff  ;";
128        ByteSequence raw = ContentUtil.encode(s);
129        ParserCursor cursor = new ParserCursor(0, s.length());
130        String result = RawFieldParser.parseToken(raw, cursor, new int[] { ';' });
131        Assert.assertEquals("stuff and some more stuff", result);
132    }
133
134    public void testTokenParsingTokensWithComments() throws Exception {
135        String s = " (blah-blah)  stuff(blah-blah) and some mo(blah-blah)re  stuff (blah-blah) ;";
136        ByteSequence raw = ContentUtil.encode(s);
137        ParserCursor cursor = new ParserCursor(0, s.length());
138        String result = RawFieldParser.parseToken(raw, cursor, new int[] { ';' });
139        Assert.assertEquals("stuff and some more stuff", result);
140    }
141
142    public void testTokenParsingMixedValuesAndQuotedValues() throws Exception {
143        String s = "  stuff and    \" some more \"   \"stuff  ;";
144        ByteSequence raw = ContentUtil.encode(s);
145        ParserCursor cursor = new ParserCursor(0, s.length());
146        String result = RawFieldParser.parseValue(raw, cursor, new int[] { ';' });
147        Assert.assertEquals("stuff and  some more  stuff  ;", result);
148    }
149
150    public void testTokenParsingQuotedValuesWithComments() throws Exception {
151        String s = " (blah blah)  \"(stuff)(and)(some)(more)(stuff)\" (yada yada) ";
152        ByteSequence raw = ContentUtil.encode(s);
153        ParserCursor cursor = new ParserCursor(0, s.length());
154        String result = RawFieldParser.parseValue(raw, cursor, new int[] { ';' });
155        Assert.assertEquals("(stuff)(and)(some)(more)(stuff)", result);
156    }
157
158    public void testBasicParsing() throws Exception {
159        String s = "raw: stuff;\r\n  more stuff";
160        ByteSequence raw = ContentUtil.encode(s);
161
162        RawFieldParser parser = new RawFieldParser();
163
164        RawField field = parser.parseField(raw);
165        Assert.assertSame(raw, field.getRaw());
166        Assert.assertEquals("raw", field.getName());
167        Assert.assertEquals("stuff;  more stuff", field.getBody());
168        Assert.assertEquals(s, field.toString());
169    }
170
171    public void testParsingNoBlankAfterColon() throws Exception {
172        String s = "raw:stuff";
173        ByteSequence raw = ContentUtil.encode(s);
174
175        RawFieldParser parser = new RawFieldParser();
176
177        RawField field = parser.parseField(raw);
178        Assert.assertSame(raw, field.getRaw());
179        Assert.assertEquals("raw", field.getName());
180        Assert.assertEquals("stuff", field.getBody());
181        Assert.assertEquals(s, field.toString());
182    }
183
184    public void testParsingObsoleteSyntax() throws Exception {
185        String s = "raw  \t  : stuff;\r\n  more stuff";
186        ByteSequence raw = ContentUtil.encode(s);
187
188        RawFieldParser parser = new RawFieldParser();
189
190        RawField field = parser.parseField(raw);
191        Assert.assertSame(raw, field.getRaw());
192        Assert.assertEquals("raw", field.getName());
193        Assert.assertEquals("stuff;  more stuff", field.getBody());
194        Assert.assertEquals(s, field.toString());
195    }
196
197    public void testParsingInvalidSyntax1() throws Exception {
198        String s = "raw    stuff;\r\n  more stuff";
199        ByteSequence raw = ContentUtil.encode(s);
200
201        RawFieldParser parser = new RawFieldParser();
202
203        try {
204            parser.parseField(raw);
205            fail("MimeException should have been thrown");
206        } catch (MimeException expected) {
207        }
208    }
209
210    public void testParsingInvalidSyntax2() throws Exception {
211        String s = "raw    \t \t";
212        ByteSequence raw = ContentUtil.encode(s);
213
214        RawFieldParser parser = new RawFieldParser();
215
216        try {
217            parser.parseField(raw);
218            fail("MimeException should have been thrown");
219        } catch (MimeException expected) {
220        }
221    }
222
223    public void testNameValueParseBasics() {
224        RawFieldParser parser = new RawFieldParser();
225        String s = "test";
226        ByteSequence buf = ContentUtil.encode(s);
227        ParserCursor cursor = new ParserCursor(0, s.length());
228
229        NameValuePair param = parser.parseParameter(buf, cursor);
230        assertEquals("test", param.getName());
231        assertEquals(null, param.getValue());
232        assertEquals(s.length(), cursor.getPos());
233        assertTrue(cursor.atEnd());
234
235        s = "test;";
236        buf = ContentUtil.encode(s);
237        cursor = new ParserCursor(0, s.length());
238
239        param = parser.parseParameter(buf, cursor);
240        assertEquals("test", param.getName());
241        assertEquals(null, param.getValue());
242        assertEquals(s.length(), cursor.getPos());
243        assertTrue(cursor.atEnd());
244
245        s = "test=stuff";
246        buf = ContentUtil.encode(s);
247        cursor = new ParserCursor(0, s.length());
248
249        param = parser.parseParameter(buf, cursor);
250        assertEquals("test", param.getName());
251        assertEquals("stuff", param.getValue());
252        assertEquals(s.length(), cursor.getPos());
253        assertTrue(cursor.atEnd());
254
255        s = "   test  =   stuff ";
256        buf = ContentUtil.encode(s);
257        cursor = new ParserCursor(0, s.length());
258
259        param = parser.parseParameter(buf, cursor);
260        assertEquals("test", param.getName());
261        assertEquals("stuff", param.getValue());
262        assertEquals(s.length(), cursor.getPos());
263        assertTrue(cursor.atEnd());
264
265        s = "   test  =   stuff ;1234";
266        buf = ContentUtil.encode(s);
267        cursor = new ParserCursor(0, s.length());
268
269        param = parser.parseParameter(buf, cursor);
270        assertEquals("test", param.getName());
271        assertEquals("stuff", param.getValue());
272        assertEquals(s.length() - 4, cursor.getPos());
273        assertFalse(cursor.atEnd());
274
275        s = "test  = \"stuff\"";
276        buf = ContentUtil.encode(s);
277        cursor = new ParserCursor(0, s.length());
278
279        param = parser.parseParameter(buf, cursor);
280        assertEquals("test", param.getName());
281        assertEquals("stuff", param.getValue());
282
283        s = "test  = text(text of some kind)/stuff(stuff of some kind)";
284        buf = ContentUtil.encode(s);
285        cursor = new ParserCursor(0, s.length());
286
287        param = parser.parseParameter(buf, cursor);
288        assertEquals("test", param.getName());
289        assertEquals("text/stuff", param.getValue());
290
291        s = "test  = \"  stuff\\\"\"";
292        buf = ContentUtil.encode(s);
293        cursor = new ParserCursor(0, s.length());
294
295        param = parser.parseParameter(buf, cursor);
296        assertEquals("test", param.getName());
297        assertEquals("  stuff\"", param.getValue());
298
299        s = "test  = \"  stuff\\\\\\\"\"";
300        buf = ContentUtil.encode(s);
301        cursor = new ParserCursor(0, s.length());
302
303        param = parser.parseParameter(buf, cursor);
304        assertEquals("test", param.getName());
305        assertEquals("  stuff\\\"", param.getValue());
306
307        s = "  test";
308        buf = ContentUtil.encode(s);
309        cursor = new ParserCursor(0, s.length());
310
311        param = parser.parseParameter(buf, cursor);
312        assertEquals("test", param.getName());
313        assertEquals(null, param.getValue());
314
315        s = "  ";
316        buf = ContentUtil.encode(s);
317        cursor = new ParserCursor(0, s.length());
318
319        param = parser.parseParameter(buf, cursor);
320        assertEquals("", param.getName());
321        assertEquals(null, param.getValue());
322
323        s = " = stuff ";
324        buf = ContentUtil.encode(s);
325        cursor = new ParserCursor(0, s.length());
326
327        param = parser.parseParameter(buf, cursor);
328        assertEquals("", param.getName());
329        assertEquals("stuff", param.getValue());
330    }
331
332    public void testNameValueListParseBasics() {
333        RawFieldParser parser = new RawFieldParser();
334        ByteSequence buf = ContentUtil.encode(
335                "test; test1 =  stuff   ; test2 =  \"stuff; stuff\"; test3=\"stuff");
336        ParserCursor cursor = new ParserCursor(0, buf.length());
337        List<NameValuePair> params = parser.parseParameters(buf, cursor);
338
339        assertEquals("test", params.get(0).getName());
340        assertEquals(null, params.get(0).getValue());
341        assertEquals("test1", params.get(1).getName());
342        assertEquals("stuff", params.get(1).getValue());
343        assertEquals("test2", params.get(2).getName());
344        assertEquals("stuff; stuff", params.get(2).getValue());
345        assertEquals("test3", params.get(3).getName());
346        assertEquals("stuff", params.get(3).getValue());
347        assertEquals(buf.length(), cursor.getPos());
348        assertTrue(cursor.atEnd());
349    }
350
351    public void testNameValueListParseEmpty() {
352        ByteSequence buf = ContentUtil.encode("    ");
353        RawFieldParser parser = new RawFieldParser();
354        ParserCursor cursor = new ParserCursor(0, buf.length());
355        List<NameValuePair> params = parser.parseParameters(buf, cursor);
356        assertEquals(0, params.size());
357    }
358
359    public void testNameValueListParseEscaped() {
360        ByteSequence buf = ContentUtil.encode(
361          "test1 =  \"\\\"stuff\\\"\"; test2= \"\\\\\"; test3 = \"stuff; stuff\"");
362        RawFieldParser parser = new RawFieldParser();
363        ParserCursor cursor = new ParserCursor(0, buf.length());
364        List<NameValuePair> params = parser.parseParameters(buf, cursor);
365        assertEquals(3, params.size());
366        assertEquals("test1", params.get(0).getName());
367        assertEquals("\"stuff\"", params.get(0).getValue());
368        assertEquals("test2", params.get(1).getName());
369        assertEquals("\\", params.get(1).getValue());
370        assertEquals("test3", params.get(2).getName());
371        assertEquals("stuff; stuff", params.get(2).getValue());
372    }
373
374    public void testRawBodyParse() {
375        ByteSequence buf = ContentUtil.encode(
376                "  text/plain ; charset=ISO-8859-1; "
377                + "boundary=foo; param1=value1; param2=\"value2\"; param3=value3");
378        RawFieldParser parser = new RawFieldParser();
379        ParserCursor cursor = new ParserCursor(0, buf.length());
380        RawBody body = parser.parseRawBody(buf, cursor);
381        assertNotNull(body);
382        assertEquals("text/plain", body.getValue());
383        List<NameValuePair> params = body.getParams();
384        assertEquals(5, params.size());
385        assertEquals("charset", params.get(0).getName());
386        assertEquals("ISO-8859-1", params.get(0).getValue());
387        assertEquals("boundary", params.get(1).getName());
388        assertEquals("foo", params.get(1).getValue());
389        assertEquals("param1", params.get(2).getName());
390        assertEquals("value1", params.get(2).getValue());
391        assertEquals("param2", params.get(3).getName());
392        assertEquals("value2", params.get(3).getValue());
393        assertEquals("param3", params.get(4).getName());
394        assertEquals("value3", params.get(4).getValue());
395    }
396
397    public void testRawBodyParseWithComments() {
398        ByteSequence buf = ContentUtil.encode(
399                "  text/(nothing special)plain ; charset=(latin)ISO-8859-1; "
400                + "boundary=foo(bar);");
401        RawFieldParser parser = new RawFieldParser();
402        ParserCursor cursor = new ParserCursor(0, buf.length());
403        RawBody body = parser.parseRawBody(buf, cursor);
404        assertNotNull(body);
405        assertEquals("text/plain", body.getValue());
406        List<NameValuePair> params = body.getParams();
407        assertEquals(2, params.size());
408        assertEquals("charset", params.get(0).getName());
409        assertEquals("ISO-8859-1", params.get(0).getValue());
410        assertEquals("boundary", params.get(1).getName());
411        assertEquals("foo", params.get(1).getValue());
412    }
413
414    public void testRawBodyParseEmptyParam() {
415        ByteSequence buf = ContentUtil.encode(
416                "multipart/alternative;; boundary=\"boundary\"");
417        RawFieldParser parser = new RawFieldParser();
418        ParserCursor cursor = new ParserCursor(0, buf.length());
419        RawBody body = parser.parseRawBody(buf, cursor);
420        assertNotNull(body);
421        assertEquals("multipart/alternative", body.getValue());
422        List<NameValuePair> params = body.getParams();
423        assertEquals(2, params.size());
424        assertEquals("", params.get(0).getName());
425        assertEquals(null, params.get(0).getValue());
426        assertEquals("boundary", params.get(1).getName());
427        assertEquals("boundary", params.get(1).getValue());
428    }
429
430    public void testRawBodyParseFolded() {
431        ByteSequence buf = ContentUtil.encode(
432                "multipart/alternative; boundary=\"simple\r\n boundary\"");
433        RawFieldParser parser = new RawFieldParser();
434        ParserCursor cursor = new ParserCursor(0, buf.length());
435        RawBody body = parser.parseRawBody(buf, cursor);
436        assertNotNull(body);
437        assertEquals("multipart/alternative", body.getValue());
438        List<NameValuePair> params = body.getParams();
439        assertEquals(1, params.size());
440        assertEquals("boundary", params.get(0).getName());
441        assertEquals("simple boundary", params.get(0).getValue());
442    }
443
444}
Note: See TracBrowser for help on using the repository browser.