001: /*
002: * Created on 9/01/2004
003: *
004: * To change the template for this generated file go to
005: * Window>Preferences>Java>Code Generation>Code and Comments
006: */
007: package org.mortbay.jetty;
008:
009: import java.util.Date;
010: import java.util.Enumeration;
011: import java.util.List;
012:
013: import junit.framework.TestCase;
014:
015: import org.mortbay.jetty.handler.ContextHandler;
016: import org.mortbay.jetty.handler.HandlerCollection;
017:
018: /**
019: * @author gregw
020: *
021: */
022: public class RFC2616Test extends TestCase {
023: Server server = new Server();
024: LocalConnector connector = new LocalConnector();
025:
026: /**
027: * Constructor for RFC2616Test.
028: *
029: * @param arg0
030: */
031: public RFC2616Test(String arg0) {
032: super (arg0);
033: server.setConnectors(new Connector[] { connector });
034:
035: ContextHandler vcontext = new ContextHandler();
036: vcontext.setContextPath("/");
037: vcontext.setVirtualHosts(new String[] { "VirtualHost" });
038: vcontext.setHandler(new DumpHandler("Virtual Dump"));
039:
040: ContextHandler context = new ContextHandler();
041: context.setContextPath("/");
042: context.setHandler(new DumpHandler());
043:
044: HandlerCollection collection = new HandlerCollection();
045: collection.setHandlers(new Handler[] { vcontext, context });
046:
047: server.setHandler(collection);
048: }
049:
050: /*
051: * @see TestCase#setUp()
052: */
053: protected void setUp() throws Exception {
054: super .setUp();
055:
056: server.start();
057: }
058:
059: /*
060: * @see TestCase#tearDown()
061: */
062: protected void tearDown() throws Exception {
063: super .tearDown();
064: server.stop();
065: }
066:
067: /* --------------------------------------------------------------- */
068: public void test3_3() {
069: try {
070: HttpFields fields = new HttpFields();
071:
072: fields.put("D1", "Sun, 6 Nov 1994 08:49:37 GMT");
073: fields.put("D2", "Sunday, 6-Nov-94 08:49:37 GMT");
074: fields.put("D3", "Sun Nov 6 08:49:37 1994");
075: Date d1 = new Date(fields.getDateField("D1"));
076: Date d2 = new Date(fields.getDateField("D2"));
077: Date d3 = new Date(fields.getDateField("D3"));
078:
079: assertEquals("3.3.1 RFC 822 RFC 850", d2, d1);
080: assertEquals("3.3.1 RFC 850 ANSI C", d3, d2);
081:
082: fields.putDateField("Date", d1.getTime());
083: assertEquals("3.3.1 RFC 822 preferred",
084: "Sun, 06 Nov 1994 08:49:37 GMT", fields
085: .getStringField("Date"));
086: } catch (Exception e) {
087: e.printStackTrace();
088: assertTrue(false);
089: }
090: }
091:
092: /* --------------------------------------------------------------- */
093: public void test3_6() {
094:
095: String response = null;
096: try {
097: int offset = 0;
098:
099: // Chunk last
100: offset = 0;
101: connector.reopen();
102: response = connector.getResponses("GET /R1 HTTP/1.1\n"
103: + "Host: localhost\n"
104: + "Transfer-Encoding: chunked,identity\n"
105: + "Content-Type: text/plain\n" + "\015\012"
106: + "5;\015\012" + "123\015\012\015\012"
107: + "0;\015\012\015\012");
108: checkContains(response, offset, "HTTP/1.1 400 Bad",
109: "Chunked last");
110:
111: // Chunked
112: offset = 0;
113: connector.reopen();
114: response = connector.getResponses("GET /R1 HTTP/1.1\n"
115: + "Host: localhost\n"
116: + "Transfer-Encoding: chunked\n"
117: + "Content-Type: text/plain\n" + "\n" + "2;\n"
118: + "12\n" + "3;\n" + "345\n" + "0;\n\n" +
119:
120: "GET /R2 HTTP/1.1\n" + "Host: localhost\n"
121: + "Transfer-Encoding: chunked\n"
122: + "Content-Type: text/plain\n" + "\n" + "4;\n"
123: + "6789\n" + "5;\n" + "abcde\n" + "0;\n\n" +
124:
125: "GET /R3 HTTP/1.1\n" + "Host: localhost\n"
126: + "Connection: close\n" + "\n");
127: offset = checkContains(response, offset, "HTTP/1.1 200",
128: "3.6.1 Chunking");
129: offset = checkContains(response, offset, "12345",
130: "3.6.1 Chunking");
131: offset = checkContains(response, offset, "HTTP/1.1 200",
132: "3.6.1 Chunking");
133: offset = checkContains(response, offset, "6789abcde",
134: "3.6.1 Chunking");
135: offset = checkContains(response, offset, "/R3",
136: "3.6.1 Chunking");
137:
138: // Chunked
139: offset = 0;
140: connector.reopen();
141: response = connector.getResponses("POST /R1 HTTP/1.1\n"
142: + "Host: localhost\n"
143: + "Transfer-Encoding: chunked\n"
144: + "Content-Type: text/plain\n" + "\n" + "3;\n"
145: + "fgh\n" + "3;\n" + "Ijk\n" + "0;\n\n" +
146:
147: "POST /R2 HTTP/1.1\n" + "Host: localhost\n"
148: + "Transfer-Encoding: chunked\n"
149: + "Content-Type: text/plain\n" + "\n" + "4;\n"
150: + "lmno\n" + "5;\n" + "Pqrst\n" + "0;\n\n" +
151:
152: "GET /R3 HTTP/1.1\n" + "Host: localhost\n"
153: + "Connection: close\n" + "\n");
154: checkNotContained(response, "HTTP/1.1 100",
155: "3.6.1 Chunking");
156: offset = checkContains(response, offset, "HTTP/1.1 200",
157: "3.6.1 Chunking");
158: offset = checkContains(response, offset, "fghIjk",
159: "3.6.1 Chunking");
160: offset = checkContains(response, offset, "HTTP/1.1 200",
161: "3.6.1 Chunking");
162: offset = checkContains(response, offset, "lmnoPqrst",
163: "3.6.1 Chunking");
164: offset = checkContains(response, offset, "/R3",
165: "3.6.1 Chunking");
166:
167: // Chunked and keep alive
168: offset = 0;
169: connector.reopen();
170: response = connector.getResponses("GET /R1 HTTP/1.1\n"
171: + "Host: localhost\n"
172: + "Transfer-Encoding: chunked\n"
173: + "Content-Type: text/plain\n"
174: + "Connection: keep-alive\n" + "\n" + "3;\n"
175: + "123\n" + "3;\n" + "456\n" + "0;\n\n" +
176:
177: "GET /R2 HTTP/1.1\n" + "Host: localhost\n"
178: + "Connection: close\n" + "\n");
179: offset = checkContains(response, offset, "HTTP/1.1 200",
180: "3.6.1 Chunking") + 10;
181: offset = checkContains(response, offset, "123456",
182: "3.6.1 Chunking");
183: offset = checkContains(response, offset, "/R2",
184: "3.6.1 Chunking") + 10;
185: } catch (Exception e) {
186: e.printStackTrace();
187: assertTrue(false);
188: if (response != null)
189: System.err.println(response);
190: }
191: }
192:
193: /* --------------------------------------------------------------- */
194: public void test3_9() {
195: try {
196: HttpFields fields = new HttpFields();
197:
198: fields
199: .put("Q",
200: "bbb;q=0.5,aaa,ccc;q=0.002,d;q=0,e;q=0.0001,ddd;q=0.001,aa2,abb;q=0.7");
201: Enumeration qualities = fields.getValues("Q", ", \t");
202: List list = HttpFields.qualityList(qualities);
203: assertEquals("Quality parameters", "aaa", HttpFields
204: .valueParameters(list.get(0).toString(), null));
205: assertEquals("Quality parameters", "aa2", HttpFields
206: .valueParameters(list.get(1).toString(), null));
207: assertEquals("Quality parameters", "abb", HttpFields
208: .valueParameters(list.get(2).toString(), null));
209: assertEquals("Quality parameters", "bbb", HttpFields
210: .valueParameters(list.get(3).toString(), null));
211: assertEquals("Quality parameters", "ccc", HttpFields
212: .valueParameters(list.get(4).toString(), null));
213: assertEquals("Quality parameters", "ddd", HttpFields
214: .valueParameters(list.get(5).toString(), null));
215: } catch (Exception e) {
216: e.printStackTrace();
217: assertTrue(false);
218: }
219: }
220:
221: /* --------------------------------------------------------------- */
222: public void test4_4() {
223: try {
224:
225: String response;
226: int offset = 0;
227: connector.reopen();
228:
229: // 2
230: // If _content length not used, second request will not be read.
231: offset = 0;
232: connector.reopen();
233: response = connector.getResponses("GET /R1 HTTP/1.1\n"
234: + "Host: localhost\n"
235: + "Transfer-Encoding: identity\n"
236: + "Content-Type: text/plain\n"
237: + "Content-Length: 5\n" + "\n" + "123\015\012" +
238:
239: "GET /R2 HTTP/1.1\n" + "Host: localhost\n"
240: + "Connection: close\n" + "\n");
241: offset = checkContains(response, offset, "HTTP/1.1 200 OK",
242: "2. identity") + 10;
243: offset = checkContains(response, offset, "/R1",
244: "2. identity") + 3;
245: offset = checkContains(response, offset, "HTTP/1.1 200 OK",
246: "2. identity") + 10;
247: offset = checkContains(response, offset, "/R2",
248: "2. identity") + 3;
249:
250: // 3
251: // _content length is ignored, as chunking is used. If it is
252: // not ignored, the second request wont be seen.
253: offset = 0;
254: connector.reopen();
255: response = connector.getResponses("GET /R1 HTTP/1.1\n"
256: + "Host: localhost\n"
257: + "Transfer-Encoding: chunked\n"
258: + "Content-Type: text/plain\n"
259: + "Content-Length: 100\n" + "\n" + "3;\n" + "123\n"
260: + "3;\n" + "456\n" + "0;\n" + "\n" +
261:
262: "GET /R2 HTTP/1.1\n" + "Host: localhost\n"
263: + "Connection: close\n"
264: + "Content-Type: text/plain\n"
265: + "Content-Length: 6\n" + "\n" + "123456");
266: offset = checkContains(response, offset, "HTTP/1.1 200 OK",
267: "3. ignore c-l") + 1;
268: offset = checkContains(response, offset, "/R1",
269: "3. ignore c-l") + 1;
270: offset = checkContains(response, offset, "123456",
271: "3. ignore c-l") + 1;
272: offset = checkContains(response, offset, "HTTP/1.1 200 OK",
273: "3. ignore c-l") + 1;
274: offset = checkContains(response, offset, "/R2",
275: "3. _content-length") + 1;
276: offset = checkContains(response, offset, "123456",
277: "3. _content-length") + 1;
278:
279: // No _content length
280: assertTrue("Skip 411 checks as IE breaks this rule", true);
281: // offset=0; connector.reopen();
282: // response=connector.getResponses("GET /R2 HTTP/1.1\n"+
283: // "Host: localhost\n"+
284: // "Content-Type: text/plain\n"+
285: // "Connection: close\n"+
286: // "\n"+
287: // "123456");
288: // offset=checkContains(response,offset,
289: // "HTTP/1.1 411 ","411 length required")+10;
290: // offset=0; connector.reopen();
291: // response=connector.getResponses("GET /R2 HTTP/1.0\n"+
292: // "Content-Type: text/plain\n"+
293: // "\n"+
294: // "123456");
295: // offset=checkContains(response,offset,
296: // "HTTP/1.0 411 ","411 length required")+10;
297:
298: } catch (Exception e) {
299: e.printStackTrace();
300: assertTrue(false);
301: }
302: }
303:
304: /* --------------------------------------------------------------- */
305: public void test5_2() throws Exception {
306: String response;
307: int offset = 0;
308: connector.reopen();
309:
310: // Default Host
311: offset = 0;
312: connector.reopen();
313: response = connector.getResponses("GET /path/R1 HTTP/1.1\n"
314: + "Host: localhost\n" + "\n");
315:
316: offset = checkContains(response, offset, "HTTP/1.1 200",
317: "Default host") + 1;
318: offset = checkContains(response, offset, "Dump HttpHandler",
319: "Default host") + 1;
320: offset = checkContains(response, offset, "pathInfo=/path/R1",
321: "Default host") + 1;
322:
323: // Virtual Host
324: offset = 0;
325: connector.reopen();
326: response = connector.getResponses("GET /path/R1 HTTP/1.1\n"
327: + "Host: VirtualHost\n" + "\n");
328: offset = checkContains(response, offset, "HTTP/1.1 200",
329: "2. virtual host field") + 1;
330: offset = checkContains(response, offset, "Virtual Dump",
331: "2. virtual host field") + 1;
332: offset = checkContains(response, offset, "pathInfo=/path/R1",
333: "2. virtual host field") + 1;
334:
335: // Virtual Host case insensitive
336: offset = 0;
337: connector.reopen();
338: response = connector.getResponses("GET /path/R1 HTTP/1.1\n"
339: + "Host: ViRtUalhOst\n" + "\n");
340: offset = checkContains(response, offset, "HTTP/1.1 200",
341: "2. virtual host field") + 1;
342: offset = checkContains(response, offset, "Virtual Dump",
343: "2. virtual host field") + 1;
344: offset = checkContains(response, offset, "pathInfo=/path/R1",
345: "2. virtual host field") + 1;
346:
347: // Virtual Host
348: offset = 0;
349: connector.reopen();
350: response = connector.getResponses("GET /path/R1 HTTP/1.1\n"
351: + "\n");
352: offset = checkContains(response, offset, "HTTP/1.1 400",
353: "3. no host") + 1;
354:
355: }
356:
357: /* --------------------------------------------------------------- */
358: public void test8_1() {
359: try {
360: String response;
361: int offset = 0;
362: connector.reopen();
363:
364: offset = 0;
365: connector.reopen();
366: response = connector.getResponses("GET /R1 HTTP/1.1\n"
367: + "Host: localhost\n" + "\n");
368: offset = checkContains(response, offset,
369: "HTTP/1.1 200 OK\015\012", "8.1.2 default") + 10;
370: checkContains(response, offset, "Content-Length: ",
371: "8.1.2 default");
372:
373: offset = 0;
374: connector.reopen();
375: response = connector.getResponses("GET /R1 HTTP/1.1\n"
376: + "Host: localhost\n" + "\n" +
377:
378: "GET /R2 HTTP/1.1\n" + "Host: localhost\n"
379: + "Connection: close\n" + "\n" +
380:
381: "GET /R3 HTTP/1.1\n" + "Host: localhost\n"
382: + "Connection: close\n" + "\n");
383: offset = checkContains(response, offset,
384: "HTTP/1.1 200 OK\015\012", "8.1.2 default") + 1;
385: offset = checkContains(response, offset, "/R1",
386: "8.1.2 default") + 1;
387:
388: assertEquals("8.1.2.1 close", -1, response.indexOf("/R3"));
389:
390: offset = checkContains(response, offset,
391: "HTTP/1.1 200 OK\015\012", "8.1.2.2 pipeline") + 11;
392: offset = checkContains(response, offset,
393: "Connection: close", "8.1.2.2 pipeline") + 1;
394: offset = checkContains(response, offset, "/R2",
395: "8.1.2.1 close") + 3;
396: } catch (Exception e) {
397: e.printStackTrace();
398: assertTrue(false);
399: }
400: }
401:
402: /* --------------------------------------------------------------- */
403: public void test8_2() {
404: try {
405:
406: String response;
407: int offset = 0;
408: connector.reopen();
409:
410: // Expect Failure
411: offset = 0;
412: connector.reopen();
413: response = connector.getResponses("GET /R1 HTTP/1.1\n"
414: + "Host: localhost\n" + "Expect: unknown\n"
415: + "Content-Type: text/plain\n"
416: + "Content-Length: 8\n" + "\n");
417: offset = checkContains(response, offset, "HTTP/1.1 417",
418: "8.2.3 expect failure") + 1;
419:
420: // TODO
421: /*
422: * // No Expect offset=0; connector.reopen();
423: * response=connector.getResponses("GET /R1 HTTP/1.1\n"+ "Host:
424: * localhost\n"+ "Content-Type: text/plain\n"+ "Content-Length:
425: * 8\n"+ "\n"); assertEquals("8.2.3 no expect no
426: * 100",-1,response.indexOf("HTTP/1.1 100"));
427: * offset=checkContains(response,offset, "HTTP/1.1 200","8.2.3 no
428: * expect no 100")+1;
429: *
430: */
431:
432: // Expect with body
433: offset = 0;
434: connector.reopen();
435: response = connector.getResponses("GET /R1 HTTP/1.1\n"
436: + "Host: localhost\n" + "Expect: 100-continue\n"
437: + "Content-Type: text/plain\n"
438: + "Content-Length: 8\n" + "Connection: close\n"
439: + "\n" + "123456\015\012");
440: checkNotContained(response, offset, "HTTP/1.1 100 ",
441: "8.2.3 expect 100");
442: offset = checkContains(response, offset, "HTTP/1.1 200 OK",
443: "8.2.3 expect with body") + 1;
444:
445: // Expect 100
446: offset = 0;
447: connector.reopen();
448: response = connector.getResponses("GET /R1 HTTP/1.1\n"
449: + "Host: localhost\n" + "Expect: 100-continue\n"
450: + "Content-Type: text/plain\n"
451: + "Content-Length: 8\n" + "\n", true);
452: offset = checkContains(response, offset, "HTTP/1.1 100 ",
453: "8.2.3 expect 100") + 1;
454: checkNotContained(response, offset, "HTTP/1.1 200",
455: "8.2.3 expect 100");
456: response = connector.getResponses("123456\015\012");
457: offset = checkContains(response, offset, "HTTP/1.1 200",
458: "8.2.3 expect 100") + 1;
459:
460: } catch (Exception e) {
461: e.printStackTrace();
462: assertTrue(false);
463: } finally {
464: }
465: }
466:
467: /* --------------------------------------------------------------- */
468: public void test9_2() {
469: // TODO
470: /*
471: * try { TestListener listener = new TestListener(); String response;
472: * int offset=0; connector.reopen();
473: * // Default Host offset=0; connector.reopen();
474: * response=connector.getResponses("OPTIONS * HTTP/1.1\n"+ "Connection:
475: * close\n"+ "Host: localhost\n"+ "\n");
476: * offset=checkContains(response,offset, "HTTP/1.1 200","200")+1;
477: * offset=checkContains(response,offset, "Allow: GET, HEAD, POST, PUT,
478: * DELETE, MOVE, OPTIONS, TRACE","Allow")+1;
479: * } catch(Exception e) { e.printStackTrace(); assertTrue(false); }
480: */
481: }
482:
483: /* --------------------------------------------------------------- */
484: public void test9_4() {
485: try {
486:
487: String get = connector.getResponses("GET /R1 HTTP/1.0\n"
488: + "Host: localhost\n" + "\n");
489:
490: checkContains(get, 0, "HTTP/1.1 200", "GET");
491: checkContains(get, 0, "Content-Type: text/html",
492: "GET _content");
493: checkContains(get, 0, "<html>", "GET body");
494:
495: connector.reopen();
496: String head = connector.getResponses("HEAD /R1 HTTP/1.0\n"
497: + "Host: localhost\n" + "\n");
498: checkContains(head, 0, "HTTP/1.1 200", "HEAD");
499: checkContains(head, 0, "Content-Type: text/html",
500: "HEAD _content");
501: assertEquals("HEAD no body", -1, head.indexOf("<html>"));
502: } catch (Exception e) {
503: e.printStackTrace();
504: assertTrue(false);
505: }
506: }
507:
508: /* --------------------------------------------------------------- */
509: public void test9_8() {
510: // TODO
511: /*
512: * try { TestListener listener = new TestListener(); String response;
513: * int offset=0; connector.reopen();
514: * // Default Host offset=0; connector.reopen();
515: * response=connector.getResponses("TRACE /path HTTP/1.1\n"+ "Host:
516: * localhost\n"+ "Connection: close\n"+ "\n");
517: * offset=checkContains(response,offset, "HTTP/1.1 200","200")+1;
518: * offset=checkContains(response,offset, "Content-Type: message/http",
519: * "message/http")+1; offset=checkContains(response,offset, "TRACE /path
520: * HTTP/1.1\r\n"+ "Host: localhost\r\n", "Request"); } catch(Exception
521: * e) { e.printStackTrace(); assertTrue(false); }
522: */
523: }
524:
525: /* --------------------------------------------------------------- */
526: public void test10_2_7() {
527: // TODO
528: /*
529: *
530: * try { TestListener listener = new TestListener(); String response;
531: * int offset=0; connector.reopen();
532: * // check to see if corresponging GET w/o range would return // a)
533: * ETag // b) Content-Location // these same headers will be required
534: * for corresponding // sub range requests
535: *
536: * response=connector.getResponses("GET /" +
537: * TestRFC2616.testFiles[0].name + " HTTP/1.1\n"+ "Host: localhost\n"+
538: * "Connection: close\n"+ "\n");
539: *
540: * boolean noRangeHasContentLocation =
541: * (response.indexOf("\r\nContent-Location: ") != -1);
542: *
543: * // now try again for the same resource but this time WITH range
544: * header
545: *
546: * response=connector.getResponses("GET /" +
547: * TestRFC2616.testFiles[0].name + " HTTP/1.1\n"+ "Host: localhost\n"+
548: * "Connection: close\n"+ "Range: bytes=1-3\n"+ "\n");
549: *
550: * offset=0; connector.reopen(); offset=checkContains(response,offset,
551: * "HTTP/1.1 206 Partial Content\r\n", "1. proper 206 status code");
552: * offset=checkContains(response,offset, "Content-Type: text/plain", "2.
553: * _content type") + 2; offset=checkContains(response,offset,
554: * "Last-Modified: " + TestRFC2616.testFiles[0].modDate + "\r\n", "3.
555: * correct resource mod date");
556: * // if GET w/o range had Content-Location, then the corresponding //
557: * response for the a GET w/ range must also have that same header
558: *
559: * offset=checkContains(response,offset, "Content-Range: bytes 1-3/26",
560: * "4. _content range") + 2;
561: *
562: * if (noRangeHasContentLocation) {
563: * offset=checkContains(response,offset, "Content-Location: ", "5.
564: * Content-Location header as with 200"); } else { // no need to check
565: * for Conten-Location header in 206 response // spec does not require
566: * existence or absence if these want any // header for the get w/o
567: * range }
568: *
569: * String expectedData = TestRFC2616.testFiles[0].data.substring(1,
570: * 3+1); offset=checkContains(response,offset, expectedData, "6.
571: * subrange data: \"" + expectedData + "\""); } catch(Exception e) {
572: * e.printStackTrace(); assertTrue(false); }
573: *
574: */
575: }
576:
577: /* --------------------------------------------------------------- */
578: public void test10_3() {
579: // TODO
580: /*
581: * try { TestListener listener = new TestListener(); String response;
582: * int offset=0; connector.reopen();
583: * // HTTP/1.0 offset=0; connector.reopen();
584: * response=connector.getResponses("GET /redirect HTTP/1.0\n"+
585: * "Connection: Keep-Alive\n"+ "\n" );
586: * offset=checkContains(response,offset, "HTTP/1.1 302","302")+1;
587: * checkContains(response,offset, "Location: /dump", "redirected");
588: * checkContains(response,offset, "Connection: close", "Connection:
589: * close");
590: *
591: * // HTTP/1.1 offset=0; connector.reopen();
592: * response=connector.getResponses("GET /redirect HTTP/1.1\n"+ "Host:
593: * localhost\n"+ "\n"+ "GET /redirect HTTP/1.1\n"+ "Host: localhost\n"+
594: * "Connection: close\n"+ "\n" ); offset=checkContains(response,offset,
595: * "HTTP/1.1 302","302")+1; checkContains(response,offset, "Location:
596: * /dump", "redirected"); checkContains(response,offset,
597: * "Transfer-Encoding: chunked", "Transfer-Encoding: chunked");
598: *
599: * offset=checkContains(response,offset, "HTTP/1.1 302","302")+1;
600: * checkContains(response,offset, "Location: /dump", "redirected");
601: * checkContains(response,offset, "Connection: close", "closed");
602: * // HTTP/1.0 _content offset=0; connector.reopen();
603: * response=connector.getResponses("GET /redirect/_content HTTP/1.0\n"+
604: * "Connection: Keep-Alive\n"+ "\n"+ "GET /redirect/_content
605: * HTTP/1.0\n"+ "\n" ); offset=checkContains(response,offset, "HTTP/1.1
606: * 302","302")+1; checkContains(response,offset, "Location: /dump",
607: * "redirected"); checkContains(response,offset, "Connection: close",
608: * "close no _content length");
609: * // HTTP/1.1 _content offset=0; connector.reopen();
610: * response=connector.getResponses("GET /redirect/_content HTTP/1.1\n"+
611: * "Host: localhost\n"+ "\n"+ "GET /redirect/_content HTTP/1.1\n"+
612: * "Host: localhost\n"+ "Connection: close\n"+ "\n" );
613: * offset=checkContains(response,offset, "HTTP/1.1 302","302")+1;
614: * checkContains(response,offset, "Location: /dump", "redirected");
615: * checkContains(response,offset, "Transfer-Encoding: chunked", "chunked
616: * _content length");
617: *
618: * offset=checkContains(response,offset, "HTTP/1.1 302","302")+1;
619: * checkContains(response,offset, "Location: /dump", "redirected");
620: * checkContains(response,offset, "Connection: close", "closed");
621: * } catch(Exception e) { e.printStackTrace(); assertTrue(false); }
622: *
623: */
624: }
625:
626: /* --------------------------------------------------------------- */
627: public void checkContentRange(LocalConnector listener,
628: String tname, String path, String reqRanges,
629: int expectedStatus, String expectedRange,
630: String expectedData) {
631: try {
632: String response;
633: int offset = 0;
634: connector.reopen();
635:
636: String byteRangeHeader = "";
637: if (reqRanges != null) {
638: byteRangeHeader = "Range: " + reqRanges + "\n";
639: }
640:
641: response = connector.getResponses("GET /" + path
642: + " HTTP/1.1\n" + "Host: localhost\n"
643: + byteRangeHeader + "Connection: close\n" + "\n");
644:
645: switch (expectedStatus) {
646: case 200: {
647: offset = checkContains(response, offset,
648: "HTTP/1.1 200 OK\r\n", tname
649: + ".1. proper 200 OK status code");
650: break;
651: }
652: case 206: {
653: offset = checkContains(
654: response,
655: offset,
656: "HTTP/1.1 206 Partial Content\r\n",
657: tname
658: + ".1. proper 206 Partial Content status code");
659: break;
660: }
661: case 416: {
662: offset = checkContains(
663: response,
664: offset,
665: "HTTP/1.1 416 Requested Range Not Satisfiable\r\n",
666: tname
667: + ".1. proper 416 Requested Range not Satisfiable status code");
668: break;
669: }
670: }
671:
672: if (expectedRange != null) {
673: String expectedContentRange = "Content-Range: bytes "
674: + expectedRange + "\r\n";
675: offset = checkContains(response, offset,
676: expectedContentRange, tname
677: + ".2. _content range " + expectedRange);
678: }
679:
680: if (expectedStatus == 200 || expectedStatus == 206) {
681: offset = checkContains(response, offset, expectedData,
682: tname + ".3. subrange data: \"" + expectedData
683: + "\"");
684: }
685: } catch (Exception e) {
686: e.printStackTrace();
687: assertTrue(false);
688: }
689: }
690:
691: public void test14_16() {
692: // TODO
693: /*
694: * try { TestListener listener = new TestListener();
695: *
696: * int id = 0;
697: *
698: * // // calibrate with normal request (no ranges); if this doesnt //
699: * work, dont expect ranges to work either //
700: * connector.checkContentRange( t, Integer.toString(id++),
701: * TestRFC2616.testFiles[0].name, null, 200, null,
702: * TestRFC2616.testFiles[0].data );
703: *
704: * // // server should ignore all range headers which include // at
705: * least one syntactically invalid range // String [] totallyBadRanges = {
706: * "bytes=a-b", "bytes=-1-2", "bytes=-1-2,2-3", "bytes=-", "bytes=-1-",
707: * "bytes=a-b,-1-1-1", "doublehalfwords=1-2", };
708: *
709: * for (int i = 0; i < totallyBadRanges.length; i++) {
710: * connector.checkContentRange( t, "BadRange"+i,
711: * TestRFC2616.testFiles[0].name, totallyBadRanges[i], 416, null,
712: * TestRFC2616.testFiles[0].data ); }
713: *
714: * // // should test for combinations of good and syntactically //
715: * invalid ranges here, but I am not certain what the right // behavior
716: * is abymore // // a) Range: bytes=a-b,5-8 // // b) Range:
717: * bytes=a-b,bytes=5-8 // // c) Range: bytes=a-b // Range: bytes=5-8 //
718: *
719: * // // return data for valid ranges while ignoring unsatisfiable //
720: * ranges //
721: *
722: * connector.checkContentRange( t, "bytes=5-8",
723: * TestRFC2616.testFiles[0].name, "bytes=5-8", 206, "5-8/26",
724: * TestRFC2616.testFiles[0].data.substring(5,8+1) );
725: * // // server should not return a 416 if at least syntactically valid
726: * ranges // are is satisfiable // connector.checkContentRange( t,
727: * "bytes=5-8,50-60", TestRFC2616.testFiles[0].name, "bytes=5-8,50-60",
728: * 206, "5-8/26", TestRFC2616.testFiles[0].data.substring(5,8+1) );
729: * connector.checkContentRange( t, "bytes=50-60,5-8",
730: * TestRFC2616.testFiles[0].name, "bytes=50-60,5-8", 206, "5-8/26",
731: * TestRFC2616.testFiles[0].data.substring(5,8+1) );
732: * // 416 as none are satisfiable connector.checkContentRange( t,
733: * "bytes=50-60", TestRFC2616.testFiles[0].name, "bytes=50-60", 416,
734: * "*REMOVE_THIS/26", null );
735: *
736: * }
737: *
738: * catch(Exception e) { e.printStackTrace(); assertTrue(false); }
739: */
740: }
741:
742: /* --------------------------------------------------------------- */
743: public void test14_23() {
744: try {
745:
746: String response;
747: int offset = 0;
748: connector.reopen();
749:
750: // HTTP/1.0 OK with no host
751: offset = 0;
752: connector.reopen();
753: response = connector.getResponses("GET /R1 HTTP/1.0\n"
754: + "\n");
755: offset = checkContains(response, offset, "HTTP/1.1 200",
756: "200") + 1;
757:
758: offset = 0;
759: connector.reopen();
760: response = connector.getResponses("GET /R1 HTTP/1.1\n"
761: + "\n");
762: offset = checkContains(response, offset, "HTTP/1.1 400",
763: "400") + 1;
764:
765: offset = 0;
766: connector.reopen();
767: response = connector.getResponses("GET /R1 HTTP/1.1\n"
768: + "Host: localhost\n" + "\n");
769: offset = checkContains(response, offset, "HTTP/1.1 200",
770: "200") + 1;
771:
772: offset = 0;
773: connector.reopen();
774: response = connector.getResponses("GET /R1 HTTP/1.1\n"
775: + "Host:\n" + "\n");
776: offset = checkContains(response, offset, "HTTP/1.1 200",
777: "200") + 1;
778:
779: } catch (Exception e) {
780: e.printStackTrace();
781: assertTrue(false);
782: }
783: }
784:
785: /* --------------------------------------------------------------- */
786: public void test14_35() {
787: // TODO
788: /*
789: * try { TestListener listener = new TestListener();
790: * // // test various valid range specs that have not been // tested
791: * yet //
792: *
793: * connector.checkContentRange( t, "bytes=0-2",
794: * TestRFC2616.testFiles[0].name, "bytes=0-2", 206, "0-2/26",
795: * TestRFC2616.testFiles[0].data.substring(0,2+1) );
796: *
797: * connector.checkContentRange( t, "bytes=23-",
798: * TestRFC2616.testFiles[0].name, "bytes=23-", 206, "23-25/26",
799: * TestRFC2616.testFiles[0].data.substring(23,25+1) );
800: *
801: * connector.checkContentRange( t, "bytes=23-42",
802: * TestRFC2616.testFiles[0].name, "bytes=23-42", 206, "23-25/26",
803: * TestRFC2616.testFiles[0].data.substring(23,25+1) );
804: *
805: * connector.checkContentRange( t, "bytes=-3",
806: * TestRFC2616.testFiles[0].name, "bytes=-3", 206, "23-25/26",
807: * TestRFC2616.testFiles[0].data.substring(23,25+1) );
808: *
809: * connector.checkContentRange( t, "bytes=23-23,-2",
810: * TestRFC2616.testFiles[0].name, "bytes=23-23,-2", 206, "23-23/26",
811: * TestRFC2616.testFiles[0].data.substring(23,23+1) );
812: *
813: * connector.checkContentRange( t, "bytes=-1,-2,-3",
814: * TestRFC2616.testFiles[0].name, "bytes=-1,-2,-3", 206, "25-25/26",
815: * TestRFC2616.testFiles[0].data.substring(25,25+1) );
816: * }
817: *
818: * catch(Exception e) { e.printStackTrace(); assertTrue(false); }
819: */}
820:
821: /* --------------------------------------------------------------- */
822: public void test14_39() {
823: // TODO
824: /*
825: * try { TestListener listener = new TestListener(); String response;
826: * int offset=0; connector.reopen();
827: * // Gzip accepted offset=0; connector.reopen();
828: * response=connector.getResponses("GET /R1?gzip HTTP/1.1\n"+ "Host:
829: * localhost\n"+ "TE: gzip;q=0.5\n"+ "Connection: close\n"+ "\n");
830: * offset=checkContains(response,offset, "HTTP/1.1 200","TE: coding")+1;
831: * offset=checkContains(response,offset, "Transfer-Encoding: gzip","TE:
832: * coding")+1;
833: * // Gzip not accepted offset=0; connector.reopen();
834: * response=connector.getResponses("GET /R1?gzip HTTP/1.1\n"+ "Host:
835: * localhost\n"+ "TE: deflate\n"+ "Connection: close\n"+ "\n");
836: * offset=checkContains(response,offset, "HTTP/1.1 501","TE: coding not
837: * accepted")+1;
838: * } catch(Exception e) { e.printStackTrace(); assertTrue(false); }
839: */
840: }
841:
842: /* --------------------------------------------------------------- */
843: public void test19_6() {
844: try {
845:
846: String response;
847: int offset = 0;
848: connector.reopen();
849:
850: offset = 0;
851: connector.reopen();
852: response = connector.getResponses("GET /R1 HTTP/1.0\n"
853: + "\n");
854: offset = checkContains(response, offset,
855: "HTTP/1.1 200 OK\015\012", "19.6.2 default close") + 10;
856: checkNotContained(response, offset, "Connection: close",
857: "19.6.2 not assumed");
858:
859: offset = 0;
860: connector.reopen();
861: response = connector.getResponses("GET /R1 HTTP/1.0\n"
862: + "Host: localhost\n" + "Connection: keep-alive\n"
863: + "\n" +
864:
865: "GET /R2 HTTP/1.0\n" + "Host: localhost\n"
866: + "Connection: close\n" + "\n" +
867:
868: "GET /R3 HTTP/1.0\n" + "Host: localhost\n"
869: + "Connection: close\n" + "\n");
870: offset = checkContains(response, offset,
871: "HTTP/1.1 200 OK\015\012", "19.6.2 Keep-alive 1") + 1;
872: offset = checkContains(response, offset,
873: "Connection: keep-alive", "19.6.2 Keep-alive 1") + 1;
874:
875: offset = checkContains(response, offset, "<html>",
876: "19.6.2 Keep-alive 1") + 1;
877:
878: offset = checkContains(response, offset, "/R1",
879: "19.6.2 Keep-alive 1") + 1;
880:
881: offset = checkContains(response, offset,
882: "HTTP/1.1 200 OK\015\012", "19.6.2 Keep-alive 2") + 11;
883: offset = checkContains(response, offset,
884: "Connection: close", "19.6.2 Keep-alive close") + 1;
885: offset = checkContains(response, offset, "/R2",
886: "19.6.2 Keep-alive close") + 3;
887:
888: assertEquals("19.6.2 closed", -1, response.indexOf("/R3"));
889:
890: offset = 0;
891: connector.reopen();
892: response = connector.getResponses("GET /R1 HTTP/1.0\n"
893: + "Host: localhost\n" + "Connection: keep-alive\n"
894: + "Content-Length: 10\n" + "\n" + "1234567890\n" +
895:
896: "GET /RA HTTP/1.0\n" + "Host: localhost\n"
897: + "Connection: keep-alive\n"
898: + "Content-Length: 10\n" + "\n" + "ABCDEFGHIJ\n" +
899:
900: "GET /R2 HTTP/1.0\n" + "Host: localhost\n"
901: + "Connection: close\n" + "\n" +
902:
903: "GET /R3 HTTP/1.0\n" + "Host: localhost\n"
904: + "Connection: close\n" + "\n");
905: offset = checkContains(response, offset,
906: "HTTP/1.1 200 OK\015\012", "19.6.2 Keep-alive 1") + 1;
907: offset = checkContains(response, offset,
908: "Connection: keep-alive", "19.6.2 Keep-alive 1") + 1;
909: offset = checkContains(response, offset, "<html>",
910: "19.6.2 Keep-alive 1") + 1;
911: offset = checkContains(response, offset, "1234567890",
912: "19.6.2 Keep-alive 1") + 1;
913:
914: offset = checkContains(response, offset,
915: "HTTP/1.1 200 OK\015\012", "19.6.2 Keep-alive 1") + 1;
916: offset = checkContains(response, offset,
917: "Connection: keep-alive", "19.6.2 Keep-alive 1") + 1;
918: offset = checkContains(response, offset, "<html>",
919: "19.6.2 Keep-alive 1") + 1;
920: offset = checkContains(response, offset, "ABCDEFGHIJ",
921: "19.6.2 Keep-alive 1") + 1;
922:
923: offset = checkContains(response, offset,
924: "HTTP/1.1 200 OK\015\012", "19.6.2 Keep-alive 2") + 11;
925: offset = checkContains(response, offset,
926: "Connection: close", "19.6.2 Keep-alive close") + 1;
927: offset = checkContains(response, offset, "/R2",
928: "19.6.2 Keep-alive close") + 3;
929:
930: assertEquals("19.6.2 closed", -1, response.indexOf("/R3"));
931:
932: } catch (Exception e) {
933: e.printStackTrace();
934: assertTrue(false);
935: }
936: }
937:
938: private int checkContains(String s, int offset, String c,
939: String test) {
940: int o = s.indexOf(c, offset);
941: if (o < offset) {
942: System.err.println("FAILED: " + test);
943: System.err.println("'" + c + "' not in:");
944: System.err.println(s.substring(offset));
945: System.err.flush();
946: System.out.println("--\n" + s);
947: System.out.flush();
948: assertTrue(test, false);
949: }
950: return o;
951: }
952:
953: private void checkNotContained(String s, int offset, String c,
954: String test) {
955: int o = s.indexOf(c, offset);
956: assertTrue(test, o < offset);
957: }
958:
959: private void checkNotContained(String s, String c, String test) {
960: checkNotContained(s, 0, c, test);
961: }
962:
963: }
|