1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 package org.apache.http.message;
29
30 import org.apache.http.HttpVersion;
31 import org.apache.http.ParseException;
32 import org.apache.http.RequestLine;
33 import org.apache.http.StatusLine;
34 import org.apache.http.util.CharArrayBuffer;
35 import org.junit.Assert;
36 import org.junit.Test;
37
38
39
40
41
42 public class TestBasicLineParser {
43
44 @Test
45 public void testRLParseSuccess() throws Exception {
46
47 RequestLine requestline = BasicLineParser.parseRequestLine
48 ("GET /stuff HTTP/1.1", null);
49 Assert.assertEquals("GET /stuff HTTP/1.1", requestline.toString());
50 Assert.assertEquals("GET", requestline.getMethod());
51 Assert.assertEquals("/stuff", requestline.getUri());
52 Assert.assertEquals(HttpVersion.HTTP_1_1, requestline.getProtocolVersion());
53
54
55 requestline = BasicLineParser.parseRequestLine
56 (" GET /stuff HTTP/1.1 ", null);
57 Assert.assertEquals("GET /stuff HTTP/1.1", requestline.toString());
58 Assert.assertEquals("GET", requestline.getMethod());
59 Assert.assertEquals("/stuff", requestline.getUri());
60 Assert.assertEquals(HttpVersion.HTTP_1_1, requestline.getProtocolVersion());
61
62
63 requestline = BasicLineParser.parseRequestLine
64 ("\rGET /stuff HTTP/1.1", null);
65 Assert.assertEquals("GET", requestline.getMethod());
66 Assert.assertEquals("/stuff", requestline.getUri());
67 Assert.assertEquals(HttpVersion.HTTP_1_1, requestline.getProtocolVersion());
68 }
69
70 @Test
71 public void testRLParseFailure() throws Exception {
72 try {
73 BasicLineParser.parseRequestLine(" ", null);
74 Assert.fail();
75 } catch (final ParseException e) {
76
77 }
78
79 try {
80 BasicLineParser.parseRequestLine(" GET", null);
81 Assert.fail();
82 } catch (final ParseException e) {
83
84 }
85
86 try {
87 BasicLineParser.parseRequestLine("GET /stuff", null);
88 Assert.fail();
89 } catch (final ParseException e) {
90
91 }
92
93 try {
94 BasicLineParser.parseRequestLine("GET/stuff HTTP/1.1", null);
95 Assert.fail();
96 } catch (final ParseException e) {
97
98 }
99
100 try {
101 BasicLineParser.parseRequestLine("GET /stuff HTTP/1.1 Oooooooooooppsie", null);
102 Assert.fail();
103 } catch (final ParseException e) {
104
105 }
106 }
107
108 @Test
109 public void testSLParseSuccess() throws Exception {
110
111 StatusLine statusLine = BasicLineParser.parseStatusLine
112 ("HTTP/1.1 200 OK", null);
113 Assert.assertEquals("HTTP/1.1 200 OK", statusLine.toString());
114 Assert.assertEquals(HttpVersion.HTTP_1_1, statusLine.getProtocolVersion());
115 Assert.assertEquals(200, statusLine.getStatusCode());
116 Assert.assertEquals("OK", statusLine.getReasonPhrase());
117
118
119 statusLine = BasicLineParser.parseStatusLine
120 ("HTTP/1.1 404 Not Found", null);
121 Assert.assertEquals(404, statusLine.getStatusCode());
122 Assert.assertEquals("Not Found", statusLine.getReasonPhrase());
123
124
125 statusLine = BasicLineParser.parseStatusLine
126 ("HTTP/1.1 404 Non Trouve", null);
127 Assert.assertEquals("Non Trouve", statusLine.getReasonPhrase());
128
129
130 statusLine = BasicLineParser.parseStatusLine
131 ("HTTP/1.1 404 Not Found\r\n", null);
132 Assert.assertEquals("Not Found", statusLine.getReasonPhrase());
133
134
135 statusLine = BasicLineParser.parseStatusLine
136 ("HTTP/1.1 200 ", null);
137 Assert.assertEquals(200, statusLine.getStatusCode());
138 Assert.assertEquals("", statusLine.getReasonPhrase());
139
140
141 statusLine = BasicLineParser.parseStatusLine
142 ("HTTP/1.1 200", null);
143 Assert.assertEquals(200, statusLine.getStatusCode());
144 Assert.assertEquals("", statusLine.getReasonPhrase());
145
146
147 statusLine = BasicLineParser.parseStatusLine
148 ("HTTP/1.1 200 OK", null);
149 Assert.assertEquals(200, statusLine.getStatusCode());
150 Assert.assertEquals("OK", statusLine.getReasonPhrase());
151
152
153 statusLine = BasicLineParser.parseStatusLine
154 ("\rHTTP/1.1 200 OK", null);
155 Assert.assertEquals(200, statusLine.getStatusCode());
156 Assert.assertEquals("OK", statusLine.getReasonPhrase());
157 Assert.assertEquals(HttpVersion.HTTP_1_1, statusLine.getProtocolVersion());
158
159
160 statusLine = BasicLineParser.parseStatusLine
161 (" HTTP/1.1 200 OK", null);
162 Assert.assertEquals(200, statusLine.getStatusCode());
163 Assert.assertEquals("OK", statusLine.getReasonPhrase());
164 Assert.assertEquals(HttpVersion.HTTP_1_1, statusLine.getProtocolVersion());
165 }
166
167 @Test
168 public void testSLParseFailure() throws Exception {
169 try {
170 BasicLineParser.parseStatusLine("xxx 200 OK", null);
171 Assert.fail();
172 } catch (final ParseException e) {
173
174 }
175
176 try {
177 BasicLineParser.parseStatusLine("HTTP/1.1 xxx OK", null);
178 Assert.fail();
179 } catch (final ParseException e) {
180
181 }
182
183 try {
184 BasicLineParser.parseStatusLine("HTTP/1.1 ", null);
185 Assert.fail();
186 } catch (final ParseException e) {
187
188 }
189
190 try {
191 BasicLineParser.parseStatusLine("HTTP/1.1", null);
192 Assert.fail();
193 } catch (final ParseException e) {
194
195 }
196
197 try {
198 BasicLineParser.parseStatusLine("HTTP/1.1 -200 OK", null);
199 Assert.fail();
200 } catch (final ParseException e) {
201
202 }
203 }
204
205 @Test
206 public void testHttpVersionParsing() throws Exception {
207
208 String s = "HTTP/1.1";
209 HttpVersion version = (HttpVersion)
210 BasicLineParser.parseProtocolVersion(s, null);
211 Assert.assertEquals("HTTP protocol name", "HTTP", version.getProtocol());
212 Assert.assertEquals("HTTP major version number", 1, version.getMajor());
213 Assert.assertEquals("HTTP minor version number", 1, version.getMinor());
214 Assert.assertEquals("HTTP version number", s, version.toString());
215
216 s = "HTTP/123.4567";
217 version = (HttpVersion)
218 BasicLineParser.parseProtocolVersion(s, null);
219 Assert.assertEquals("HTTP protocol name", "HTTP", version.getProtocol());
220 Assert.assertEquals("HTTP major version number", 123, version.getMajor());
221 Assert.assertEquals("HTTP minor version number", 4567, version.getMinor());
222 Assert.assertEquals("HTTP version number", s, version.toString());
223 }
224
225 @Test
226 public void testHttpVersionParsingUsingCursor() throws Exception {
227
228 String s = "HTTP/1.1";
229 CharArrayBuffer buffer = new CharArrayBuffer(16);
230 buffer.append(s);
231 ParserCursor cursor = new ParserCursor(0, s.length());
232
233 final LineParser parser = BasicLineParser.INSTANCE;
234
235 HttpVersion version = (HttpVersion) parser.parseProtocolVersion(buffer, cursor);
236 Assert.assertEquals("HTTP protocol name", "HTTP", version.getProtocol());
237 Assert.assertEquals("HTTP major version number", 1, version.getMajor());
238 Assert.assertEquals("HTTP minor version number", 1, version.getMinor());
239 Assert.assertEquals("HTTP version number", "HTTP/1.1", version.toString());
240 Assert.assertEquals(s.length(), cursor.getPos());
241 Assert.assertTrue(cursor.atEnd());
242
243 s = "HTTP/1.123 123";
244 buffer = new CharArrayBuffer(16);
245 buffer.append(s);
246 cursor = new ParserCursor(0, s.length());
247
248 version = (HttpVersion) parser.parseProtocolVersion(buffer, cursor);
249 Assert.assertEquals("HTTP protocol name", "HTTP", version.getProtocol());
250 Assert.assertEquals("HTTP major version number", 1, version.getMajor());
251 Assert.assertEquals("HTTP minor version number", 123, version.getMinor());
252 Assert.assertEquals("HTTP version number", "HTTP/1.123", version.toString());
253 Assert.assertEquals(' ', buffer.charAt(cursor.getPos()));
254 Assert.assertEquals(s.length() - 4, cursor.getPos());
255 Assert.assertFalse(cursor.atEnd());
256 }
257
258 @Test
259 public void testInvalidHttpVersionParsing() throws Exception {
260 try {
261 BasicLineParser.parseProtocolVersion((String)null, null);
262 Assert.fail("IllegalArgumentException should have been thrown");
263 } catch (final IllegalArgumentException e) {
264
265 }
266 try {
267 BasicLineParser.parseProtocolVersion
268 (" ", null);
269 Assert.fail("ParseException should have been thrown");
270 } catch (final ParseException e) {
271
272 }
273 try {
274 BasicLineParser.parseProtocolVersion
275 ("HTT", null);
276 Assert.fail("ParseException should have been thrown");
277 } catch (final ParseException e) {
278
279 }
280 try {
281 BasicLineParser.parseProtocolVersion
282 ("crap", null);
283 Assert.fail("ParseException should have been thrown");
284 } catch (final ParseException e) {
285
286 }
287 try {
288 BasicLineParser.parseProtocolVersion
289 ("HTTP/crap", null);
290 Assert.fail("ParseException should have been thrown");
291 } catch (final ParseException e) {
292
293 }
294 try {
295 BasicLineParser.parseProtocolVersion
296 ("HTTP/1", null);
297 Assert.fail("ParseException should have been thrown");
298 } catch (final ParseException e) {
299
300 }
301 try {
302 BasicLineParser.parseProtocolVersion
303 ("HTTP/1234 ", null);
304 Assert.fail("ParseException should have been thrown");
305 } catch (final ParseException e) {
306
307 }
308 try {
309 BasicLineParser.parseProtocolVersion
310 ("HTTP/1.", null);
311 Assert.fail("ParseException should have been thrown");
312 } catch (final ParseException e) {
313
314 }
315 try {
316 BasicLineParser.parseProtocolVersion
317 ("HTTP/whatever.whatever whatever", null);
318 Assert.fail("ParseException should have been thrown");
319 } catch (final ParseException e) {
320
321 }
322 try {
323 BasicLineParser.parseProtocolVersion
324 ("HTTP/1.whatever whatever", null);
325 Assert.fail("ParseException should have been thrown");
326 } catch (final ParseException e) {
327
328 }
329 }
330
331 }