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.hc.core5.http.message;
28  
29  import org.apache.hc.core5.http.HeaderElement;
30  import org.apache.hc.core5.http.NameValuePair;
31  import org.apache.hc.core5.util.CharArrayBuffer;
32  import org.junit.Assert;
33  import org.junit.Before;
34  import org.junit.Test;
35  
36  /**
37   * Tests for header value parsing.
38   *
39   * @version $Id$
40   */
41  public class TestBasicHeaderValueParser {
42  
43      private BasicHeaderValueParser parser;
44  
45      @Before
46      public void setup() {
47          this.parser = BasicHeaderValueParser.INSTANCE;
48      }
49  
50      @Test
51      public void testParseHeaderElements() throws Exception {
52          final String headerValue = "name1 = value1; name2; name3=\"value3\" , name4=value4; " +
53              "name5=value5, name6= ; name7 = value7; name8 = \" value8\"";
54          final CharArrayBuffer buf = new CharArrayBuffer(64);
55          buf.append(headerValue);
56          final ParserCursor cursor = new ParserCursor(0, buf.length());
57          final HeaderElement[] elements = this.parser.parseElements(buf, cursor);
58          // there are 3 elements
59          Assert.assertEquals(3,elements.length);
60          // 1st element
61          Assert.assertEquals("name1",elements[0].getName());
62          Assert.assertEquals("value1",elements[0].getValue());
63          // 1st element has 2 getParameters()
64          Assert.assertEquals(2,elements[0].getParameters().length);
65          Assert.assertEquals("name2",elements[0].getParameters()[0].getName());
66          Assert.assertEquals(null, elements[0].getParameters()[0].getValue());
67          Assert.assertEquals("name3",elements[0].getParameters()[1].getName());
68          Assert.assertEquals("value3",elements[0].getParameters()[1].getValue());
69          // 2nd element
70          Assert.assertEquals("name4",elements[1].getName());
71          Assert.assertEquals("value4",elements[1].getValue());
72          // 2nd element has 1 parameter
73          Assert.assertEquals(1,elements[1].getParameters().length);
74          Assert.assertEquals("name5",elements[1].getParameters()[0].getName());
75          Assert.assertEquals("value5",elements[1].getParameters()[0].getValue());
76          // 3rd element
77          Assert.assertEquals("name6",elements[2].getName());
78          Assert.assertEquals("",elements[2].getValue());
79          // 3rd element has 2 getParameters()
80          Assert.assertEquals(2,elements[2].getParameters().length);
81          Assert.assertEquals("name7",elements[2].getParameters()[0].getName());
82          Assert.assertEquals("value7",elements[2].getParameters()[0].getValue());
83          Assert.assertEquals("name8",elements[2].getParameters()[1].getName());
84          Assert.assertEquals(" value8",elements[2].getParameters()[1].getValue());
85      }
86  
87      @Test
88      public void testParseHEEscaped() {
89          final String headerValue =
90            "test1 =  \"\\\"stuff\\\"\", test2= \"\\\\\", test3 = \"stuff, stuff\"";
91          final CharArrayBuffer buf = new CharArrayBuffer(64);
92          buf.append(headerValue);
93          final ParserCursor cursor = new ParserCursor(0, buf.length());
94          final HeaderElement[] elements = this.parser.parseElements(buf, cursor);
95          Assert.assertEquals(3, elements.length);
96          Assert.assertEquals("test1", elements[0].getName());
97          Assert.assertEquals("\"stuff\"", elements[0].getValue());
98          Assert.assertEquals("test2", elements[1].getName());
99          Assert.assertEquals("\\", elements[1].getValue());
100         Assert.assertEquals("test3", elements[2].getName());
101         Assert.assertEquals("stuff, stuff", elements[2].getValue());
102     }
103 
104     @Test
105     public void testHEFringeCase1() throws Exception {
106         final String headerValue = "name1 = value1,";
107         final CharArrayBuffer buf = new CharArrayBuffer(64);
108         buf.append(headerValue);
109         final ParserCursor cursor = new ParserCursor(0, buf.length());
110         final HeaderElement[] elements = this.parser.parseElements(buf, cursor);
111         Assert.assertEquals("Number of elements", 1, elements.length);
112     }
113 
114     @Test
115     public void testHEFringeCase2() throws Exception {
116         final String headerValue = "name1 = value1, ";
117         final CharArrayBuffer buf = new CharArrayBuffer(64);
118         buf.append(headerValue);
119         final ParserCursor cursor = new ParserCursor(0, buf.length());
120         final HeaderElement[] elements = this.parser.parseElements(buf, cursor);
121         Assert.assertEquals("Number of elements", 1, elements.length);
122     }
123 
124     @Test
125     public void testHEFringeCase3() throws Exception {
126         final String headerValue = ",, ,, ,";
127         final CharArrayBuffer buf = new CharArrayBuffer(64);
128         buf.append(headerValue);
129         final ParserCursor cursor = new ParserCursor(0, buf.length());
130         final HeaderElement[] elements = this.parser.parseElements(buf, cursor);
131         Assert.assertEquals("Number of elements", 0, elements.length);
132     }
133 
134     @Test
135     public void testNVParse() {
136 
137         String s = "test";
138         CharArrayBuffer buffer = new CharArrayBuffer(64);
139         buffer.append(s);
140         ParserCursor cursor = new ParserCursor(0, s.length());
141 
142         NameValuePair param = this.parser.parseNameValuePair(buffer, cursor);
143         Assert.assertEquals("test", param.getName());
144         Assert.assertEquals(null, param.getValue());
145         Assert.assertEquals(s.length(), cursor.getPos());
146         Assert.assertTrue(cursor.atEnd());
147 
148         s = "test;";
149         buffer = new CharArrayBuffer(16);
150         buffer.append(s);
151         cursor = new ParserCursor(0, s.length());
152 
153         param = this.parser.parseNameValuePair(buffer, cursor);
154         Assert.assertEquals("test", param.getName());
155         Assert.assertEquals(null, param.getValue());
156         Assert.assertEquals(s.length(), cursor.getPos());
157         Assert.assertTrue(cursor.atEnd());
158 
159         s = "test  ,12";
160         buffer = new CharArrayBuffer(16);
161         buffer.append(s);
162         cursor = new ParserCursor(0, s.length());
163 
164         param = this.parser.parseNameValuePair(buffer, cursor);
165         Assert.assertEquals("test", param.getName());
166         Assert.assertEquals(null, param.getValue());
167         Assert.assertEquals(s.length() - 2, cursor.getPos());
168         Assert.assertFalse(cursor.atEnd());
169 
170         s = "test=stuff";
171         buffer = new CharArrayBuffer(16);
172         buffer.append(s);
173         cursor = new ParserCursor(0, s.length());
174 
175         param = this.parser.parseNameValuePair(buffer, cursor);
176         Assert.assertEquals("test", param.getName());
177         Assert.assertEquals("stuff", param.getValue());
178         Assert.assertEquals(s.length(), cursor.getPos());
179         Assert.assertTrue(cursor.atEnd());
180 
181         s = "   test  =   stuff ";
182         buffer = new CharArrayBuffer(16);
183         buffer.append(s);
184         cursor = new ParserCursor(0, s.length());
185 
186         param = this.parser.parseNameValuePair(buffer, cursor);
187         Assert.assertEquals("test", param.getName());
188         Assert.assertEquals("stuff", param.getValue());
189         Assert.assertEquals(s.length(), cursor.getPos());
190         Assert.assertTrue(cursor.atEnd());
191 
192         s = "   test  =   stuff ;1234";
193         buffer = new CharArrayBuffer(16);
194         buffer.append(s);
195         cursor = new ParserCursor(0, s.length());
196 
197         param = this.parser.parseNameValuePair(buffer, cursor);
198         Assert.assertEquals("test", param.getName());
199         Assert.assertEquals("stuff", param.getValue());
200         Assert.assertEquals(s.length() - 4, cursor.getPos());
201         Assert.assertFalse(cursor.atEnd());
202 
203         s = "test  = \"stuff\"";
204         buffer = new CharArrayBuffer(16);
205         buffer.append(s);
206         cursor = new ParserCursor(0, s.length());
207 
208         param = this.parser.parseNameValuePair(buffer, cursor);
209         Assert.assertEquals("test", param.getName());
210         Assert.assertEquals("stuff", param.getValue());
211 
212         s = "test  = \"  stuff\\\"\"";
213         buffer = new CharArrayBuffer(16);
214         buffer.append(s);
215         cursor = new ParserCursor(0, s.length());
216 
217         param = this.parser.parseNameValuePair(buffer, cursor);
218         Assert.assertEquals("test", param.getName());
219         Assert.assertEquals("  stuff\"", param.getValue());
220 
221         s = "  test";
222         buffer = new CharArrayBuffer(16);
223         buffer.append(s);
224         cursor = new ParserCursor(0, s.length());
225 
226         param = this.parser.parseNameValuePair(buffer, cursor);
227         Assert.assertEquals("test", param.getName());
228         Assert.assertEquals(null, param.getValue());
229 
230         s = "  ";
231         buffer = new CharArrayBuffer(16);
232         buffer.append(s);
233         cursor = new ParserCursor(0, s.length());
234 
235         param = this.parser.parseNameValuePair(buffer, cursor);
236         Assert.assertEquals("", param.getName());
237         Assert.assertEquals(null, param.getValue());
238 
239         s = " = stuff ";
240         buffer = new CharArrayBuffer(16);
241         buffer.append(s);
242         cursor = new ParserCursor(0, s.length());
243 
244         param = this.parser.parseNameValuePair(buffer, cursor);
245         Assert.assertEquals("", param.getName());
246         Assert.assertEquals("stuff", param.getValue());
247     }
248 
249     @Test
250     public void testNVParseAll() {
251         String s =
252             "test; test1 =  stuff   ; test2 =  \"stuff; stuff\"; test3=\"stuff";
253         CharArrayBuffer buffer = new CharArrayBuffer(16);
254         buffer.append(s);
255         ParserCursor cursor = new ParserCursor(0, s.length());
256 
257         NameValuePair[] params = this.parser.parseParameters(buffer, cursor);
258         Assert.assertEquals("test", params[0].getName());
259         Assert.assertEquals(null, params[0].getValue());
260         Assert.assertEquals("test1", params[1].getName());
261         Assert.assertEquals("stuff", params[1].getValue());
262         Assert.assertEquals("test2", params[2].getName());
263         Assert.assertEquals("stuff; stuff", params[2].getValue());
264         Assert.assertEquals("test3", params[3].getName());
265         Assert.assertEquals("stuff", params[3].getValue());
266         Assert.assertEquals(s.length(), cursor.getPos());
267         Assert.assertTrue(cursor.atEnd());
268 
269         s =
270             "test; test1 =  stuff   ; test2 =  \"stuff; stuff\"; test3=\"stuff\",123";
271         buffer = new CharArrayBuffer(16);
272         buffer.append(s);
273         cursor = new ParserCursor(0, s.length());
274 
275         params = this.parser.parseParameters(buffer, cursor);
276         Assert.assertEquals("test", params[0].getName());
277         Assert.assertEquals(null, params[0].getValue());
278         Assert.assertEquals("test1", params[1].getName());
279         Assert.assertEquals("stuff", params[1].getValue());
280         Assert.assertEquals("test2", params[2].getName());
281         Assert.assertEquals("stuff; stuff", params[2].getValue());
282         Assert.assertEquals("test3", params[3].getName());
283         Assert.assertEquals("stuff", params[3].getValue());
284         Assert.assertEquals(s.length() - 3, cursor.getPos());
285         Assert.assertFalse(cursor.atEnd());
286 
287         s = "  ";
288         buffer = new CharArrayBuffer(16);
289         buffer.append(s);
290         cursor = new ParserCursor(0, s.length());
291         params = this.parser.parseParameters(buffer, cursor);
292         Assert.assertEquals(0, params.length);
293     }
294 
295     @Test
296     public void testNVParseEscaped() {
297         final String headerValue =
298           "test1 =  \"\\\"stuff\\\"\"; test2= \"\\\\\"; test3 = \"stuff; stuff\"";
299         final CharArrayBuffer buf = new CharArrayBuffer(64);
300         buf.append(headerValue);
301         final ParserCursor cursor = new ParserCursor(0, buf.length());
302         final NameValuePair[] params = this.parser.parseParameters(buf, cursor);
303         Assert.assertEquals(3, params.length);
304         Assert.assertEquals("test1", params[0].getName());
305         Assert.assertEquals("\"stuff\"", params[0].getValue());
306         Assert.assertEquals("test2", params[1].getName());
307         Assert.assertEquals("\\", params[1].getValue());
308         Assert.assertEquals("test3", params[2].getName());
309         Assert.assertEquals("stuff; stuff", params[2].getValue());
310     }
311 
312 }