View Javadoc
1   /*
2    * ====================================================================
3    * Licensed to the Apache Software Foundation (ASF) under one
4    * or more contributor license agreements.  See the NOTICE file
5    * distributed with this work for additional information
6    * regarding copyright ownership.  The ASF licenses this file
7    * to you under the Apache License, Version 2.0 (the
8    * "License"); you may not use this file except in compliance
9    * with the License.  You may obtain a copy of the License at
10   *
11   *   http://www.apache.org/licenses/LICENSE-2.0
12   *
13   * Unless required by applicable law or agreed to in writing,
14   * software distributed under the License is distributed on an
15   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16   * KIND, either express or implied.  See the License for the
17   * specific language governing permissions and limitations
18   * under the License.
19   * ====================================================================
20   *
21   * This software consists of voluntary contributions made by many
22   * individuals on behalf of the Apache Software Foundation.  For more
23   * information on the Apache Software Foundation, please see
24   * <http://www.apache.org/>.
25   *
26   */
27  package org.apache.http.message;
28  
29  import org.apache.http.HeaderElement;
30  import org.apache.http.NameValuePair;
31  import org.apache.http.util.CharArrayBuffer;
32  import org.junit.Assert;
33  import org.junit.Test;
34  
35  /**
36   * Tests for header value parsing.
37   *
38   * @version $Id$
39   */
40  public class TestBasicHeaderValueParser {
41  
42      @Test
43      public void testParseHeaderElements() throws Exception {
44          final String headerValue = "name1 = value1; name2; name3=\"value3\" , name4=value4; " +
45              "name5=value5, name6= ; name7 = value7; name8 = \" value8\"";
46          final HeaderElement[] elements = BasicHeaderValueParser.parseElements(headerValue, null);
47          // there are 3 elements
48          Assert.assertEquals(3,elements.length);
49          // 1st element
50          Assert.assertEquals("name1",elements[0].getName());
51          Assert.assertEquals("value1",elements[0].getValue());
52          // 1st element has 2 getParameters()
53          Assert.assertEquals(2,elements[0].getParameters().length);
54          Assert.assertEquals("name2",elements[0].getParameters()[0].getName());
55          Assert.assertEquals(null, elements[0].getParameters()[0].getValue());
56          Assert.assertEquals("name3",elements[0].getParameters()[1].getName());
57          Assert.assertEquals("value3",elements[0].getParameters()[1].getValue());
58          // 2nd element
59          Assert.assertEquals("name4",elements[1].getName());
60          Assert.assertEquals("value4",elements[1].getValue());
61          // 2nd element has 1 parameter
62          Assert.assertEquals(1,elements[1].getParameters().length);
63          Assert.assertEquals("name5",elements[1].getParameters()[0].getName());
64          Assert.assertEquals("value5",elements[1].getParameters()[0].getValue());
65          // 3rd element
66          Assert.assertEquals("name6",elements[2].getName());
67          Assert.assertEquals("",elements[2].getValue());
68          // 3rd element has 2 getParameters()
69          Assert.assertEquals(2,elements[2].getParameters().length);
70          Assert.assertEquals("name7",elements[2].getParameters()[0].getName());
71          Assert.assertEquals("value7",elements[2].getParameters()[0].getValue());
72          Assert.assertEquals("name8",elements[2].getParameters()[1].getName());
73          Assert.assertEquals(" value8",elements[2].getParameters()[1].getValue());
74      }
75  
76      @Test
77      public void testParseHEEscaped() {
78          final String s =
79            "test1 =  \"\\\"stuff\\\"\", test2= \"\\\\\", test3 = \"stuff, stuff\"";
80          final HeaderElement[] elements = BasicHeaderValueParser.parseElements(s, null);
81          Assert.assertEquals(3, elements.length);
82          Assert.assertEquals("test1", elements[0].getName());
83          Assert.assertEquals("\"stuff\"", elements[0].getValue());
84          Assert.assertEquals("test2", elements[1].getName());
85          Assert.assertEquals("\\", elements[1].getValue());
86          Assert.assertEquals("test3", elements[2].getName());
87          Assert.assertEquals("stuff, stuff", elements[2].getValue());
88      }
89  
90      @Test
91      public void testHEFringeCase1() throws Exception {
92          final String headerValue = "name1 = value1,";
93          final HeaderElement[] elements = BasicHeaderValueParser.parseElements(headerValue, null);
94          Assert.assertEquals("Number of elements", 1, elements.length);
95      }
96  
97      @Test
98      public void testHEFringeCase2() throws Exception {
99          final String headerValue = "name1 = value1, ";
100         final HeaderElement[] elements = BasicHeaderValueParser.parseElements(headerValue, null);
101         Assert.assertEquals("Number of elements", 1, elements.length);
102     }
103 
104     @Test
105     public void testHEFringeCase3() throws Exception {
106         final String headerValue = ",, ,, ,";
107         final HeaderElement[] elements = BasicHeaderValueParser.parseElements(headerValue, null);
108         Assert.assertEquals("Number of elements", 0, elements.length);
109     }
110 
111     @Test
112     public void testNVParseUsingCursor() {
113 
114         final HeaderValueParser parser = BasicHeaderValueParser.INSTANCE;
115 
116         String s = "test";
117         CharArrayBuffer buffer = new CharArrayBuffer(16);
118         buffer.append(s);
119         ParserCursor cursor = new ParserCursor(0, s.length());
120 
121         NameValuePair param = parser.parseNameValuePair(buffer, cursor);
122         Assert.assertEquals("test", param.getName());
123         Assert.assertEquals(null, param.getValue());
124         Assert.assertEquals(s.length(), cursor.getPos());
125         Assert.assertTrue(cursor.atEnd());
126 
127         s = "test;";
128         buffer = new CharArrayBuffer(16);
129         buffer.append(s);
130         cursor = new ParserCursor(0, s.length());
131 
132         param = parser.parseNameValuePair(buffer, cursor);
133         Assert.assertEquals("test", param.getName());
134         Assert.assertEquals(null, param.getValue());
135         Assert.assertEquals(s.length(), cursor.getPos());
136         Assert.assertTrue(cursor.atEnd());
137 
138         s = "test  ,12";
139         buffer = new CharArrayBuffer(16);
140         buffer.append(s);
141         cursor = new ParserCursor(0, s.length());
142 
143         param = parser.parseNameValuePair(buffer, cursor);
144         Assert.assertEquals("test", param.getName());
145         Assert.assertEquals(null, param.getValue());
146         Assert.assertEquals(s.length() - 2, cursor.getPos());
147         Assert.assertFalse(cursor.atEnd());
148 
149         s = "test=stuff";
150         buffer = new CharArrayBuffer(16);
151         buffer.append(s);
152         cursor = new ParserCursor(0, s.length());
153 
154         param = parser.parseNameValuePair(buffer, cursor);
155         Assert.assertEquals("test", param.getName());
156         Assert.assertEquals("stuff", param.getValue());
157         Assert.assertEquals(s.length(), cursor.getPos());
158         Assert.assertTrue(cursor.atEnd());
159 
160         s = "   test  =   stuff ";
161         buffer = new CharArrayBuffer(16);
162         buffer.append(s);
163         cursor = new ParserCursor(0, s.length());
164 
165         param = parser.parseNameValuePair(buffer, cursor);
166         Assert.assertEquals("test", param.getName());
167         Assert.assertEquals("stuff", param.getValue());
168         Assert.assertEquals(s.length(), cursor.getPos());
169         Assert.assertTrue(cursor.atEnd());
170 
171         s = "   test  =   stuff ;1234";
172         buffer = new CharArrayBuffer(16);
173         buffer.append(s);
174         cursor = new ParserCursor(0, s.length());
175 
176         param = parser.parseNameValuePair(buffer, cursor);
177         Assert.assertEquals("test", param.getName());
178         Assert.assertEquals("stuff", param.getValue());
179         Assert.assertEquals(s.length() - 4, cursor.getPos());
180         Assert.assertFalse(cursor.atEnd());
181 
182         s = "test  = \"stuff\"";
183         buffer = new CharArrayBuffer(16);
184         buffer.append(s);
185         cursor = new ParserCursor(0, s.length());
186 
187         param = parser.parseNameValuePair(buffer, cursor);
188         Assert.assertEquals("test", param.getName());
189         Assert.assertEquals("stuff", param.getValue());
190 
191         s = "test  = \"  stuff\\\"\"";
192         buffer = new CharArrayBuffer(16);
193         buffer.append(s);
194         cursor = new ParserCursor(0, s.length());
195 
196         param = parser.parseNameValuePair(buffer, cursor);
197         Assert.assertEquals("test", param.getName());
198         Assert.assertEquals("  stuff\"", param.getValue());
199 
200         s = "  test";
201         buffer = new CharArrayBuffer(16);
202         buffer.append(s);
203         cursor = new ParserCursor(0, s.length());
204 
205         param = parser.parseNameValuePair(buffer, cursor);
206         Assert.assertEquals("test", param.getName());
207         Assert.assertEquals(null, param.getValue());
208 
209         s = "  ";
210         buffer = new CharArrayBuffer(16);
211         buffer.append(s);
212         cursor = new ParserCursor(0, s.length());
213 
214         param = parser.parseNameValuePair(buffer, cursor);
215         Assert.assertEquals("", param.getName());
216         Assert.assertEquals(null, param.getValue());
217 
218         s = " = stuff ";
219         buffer = new CharArrayBuffer(16);
220         buffer.append(s);
221         cursor = new ParserCursor(0, s.length());
222 
223         param = parser.parseNameValuePair(buffer, cursor);
224         Assert.assertEquals("", param.getName());
225         Assert.assertEquals("stuff", param.getValue());
226     }
227 
228     @Test
229     public void testNVParse() {
230         String s = "test";
231         NameValuePair param =
232             BasicHeaderValueParser.parseNameValuePair(s, null);
233         Assert.assertEquals("test", param.getName());
234         Assert.assertEquals(null, param.getValue());
235 
236         s = "test=stuff";
237         param = BasicHeaderValueParser.parseNameValuePair(s, null);
238         Assert.assertEquals("test", param.getName());
239         Assert.assertEquals("stuff", param.getValue());
240 
241         s = "   test  =   stuff ";
242         param = BasicHeaderValueParser.parseNameValuePair(s, null);
243         Assert.assertEquals("test", param.getName());
244         Assert.assertEquals("stuff", param.getValue());
245 
246         s = "test  = \"stuff\"";
247         param = BasicHeaderValueParser.parseNameValuePair(s, null);
248         Assert.assertEquals("test", param.getName());
249         Assert.assertEquals("stuff", param.getValue());
250 
251         s = "test  = \"  stuff\\\"\"";
252         param = BasicHeaderValueParser.parseNameValuePair(s, null);
253         Assert.assertEquals("test", param.getName());
254         Assert.assertEquals("  stuff\"", param.getValue());
255 
256         s = "  test";
257         param = BasicHeaderValueParser.parseNameValuePair(s, null);
258         Assert.assertEquals("test", param.getName());
259         Assert.assertEquals(null, param.getValue());
260 
261         s = "  ";
262         param = BasicHeaderValueParser.parseNameValuePair(s, null);
263         Assert.assertEquals("", param.getName());
264         Assert.assertEquals(null, param.getValue());
265 
266         s = " = stuff ";
267         param = BasicHeaderValueParser.parseNameValuePair(s, null);
268         Assert.assertEquals("", param.getName());
269         Assert.assertEquals("stuff", param.getValue());
270     }
271 
272     @Test
273     public void testNVParseAllWithCursor() {
274         final HeaderValueParser parser = BasicHeaderValueParser.INSTANCE;
275 
276         String s =
277             "test; test1 =  stuff   ; test2 =  \"stuff; stuff\"; test3=\"stuff";
278         CharArrayBuffer buffer = new CharArrayBuffer(16);
279         buffer.append(s);
280         ParserCursor cursor = new ParserCursor(0, s.length());
281 
282         NameValuePair[] params = parser.parseParameters(buffer, cursor);
283         Assert.assertEquals("test", params[0].getName());
284         Assert.assertEquals(null, params[0].getValue());
285         Assert.assertEquals("test1", params[1].getName());
286         Assert.assertEquals("stuff", params[1].getValue());
287         Assert.assertEquals("test2", params[2].getName());
288         Assert.assertEquals("stuff; stuff", params[2].getValue());
289         Assert.assertEquals("test3", params[3].getName());
290         Assert.assertEquals("stuff", params[3].getValue());
291         Assert.assertEquals(s.length(), cursor.getPos());
292         Assert.assertTrue(cursor.atEnd());
293 
294         s =
295             "test; test1 =  stuff   ; test2 =  \"stuff; stuff\"; test3=\"stuff\",123";
296         buffer = new CharArrayBuffer(16);
297         buffer.append(s);
298         cursor = new ParserCursor(0, s.length());
299 
300         params = parser.parseParameters(buffer, cursor);
301         Assert.assertEquals("test", params[0].getName());
302         Assert.assertEquals(null, params[0].getValue());
303         Assert.assertEquals("test1", params[1].getName());
304         Assert.assertEquals("stuff", params[1].getValue());
305         Assert.assertEquals("test2", params[2].getName());
306         Assert.assertEquals("stuff; stuff", params[2].getValue());
307         Assert.assertEquals("test3", params[3].getName());
308         Assert.assertEquals("stuff", params[3].getValue());
309         Assert.assertEquals(s.length() - 3, cursor.getPos());
310         Assert.assertFalse(cursor.atEnd());
311 
312         s = "  ";
313         buffer = new CharArrayBuffer(16);
314         buffer.append(s);
315         cursor = new ParserCursor(0, s.length());
316         params = parser.parseParameters(buffer, cursor);
317         Assert.assertEquals(0, params.length);
318     }
319 
320     @Test
321     public void testNVParseAll() {
322         String s =
323           "test; test1 =  stuff   ; test2 =  \"stuff; stuff\"; test3=\"stuff";
324         NameValuePair[] params =
325             BasicHeaderValueParser.parseParameters(s, null);
326         Assert.assertEquals("test", params[0].getName());
327         Assert.assertEquals(null, params[0].getValue());
328         Assert.assertEquals("test1", params[1].getName());
329         Assert.assertEquals("stuff", params[1].getValue());
330         Assert.assertEquals("test2", params[2].getName());
331         Assert.assertEquals("stuff; stuff", params[2].getValue());
332         Assert.assertEquals("test3", params[3].getName());
333         Assert.assertEquals("stuff", params[3].getValue());
334 
335         s = "  ";
336         params = BasicHeaderValueParser.parseParameters(s, null);
337         Assert.assertEquals(0, params.length);
338     }
339 
340     @Test
341     public void testNVParseEscaped() {
342         final String s =
343           "test1 =  \"\\\"stuff\\\"\"; test2= \"\\\\\"; test3 = \"stuff; stuff\"";
344         final NameValuePair[] params =
345             BasicHeaderValueParser.parseParameters(s, null);
346         Assert.assertEquals(3, params.length);
347         Assert.assertEquals("test1", params[0].getName());
348         Assert.assertEquals("\"stuff\"", params[0].getValue());
349         Assert.assertEquals("test2", params[1].getName());
350         Assert.assertEquals("\\", params[1].getValue());
351         Assert.assertEquals("test3", params[2].getName());
352         Assert.assertEquals("stuff; stuff", params[2].getValue());
353     }
354 
355 }