The Tor Browser: netwerk/test/unit/test_chunked

     1 /*

     2  * Test Chunked-Encoded response parsing.

     3  */

     5 ////////////////////////////////////////////////////////////////////////////////

     6 // Test infrastructure

     8 Cu.import("resource://testing-common/httpd.js");

    10 XPCOMUtils.defineLazyGetter(this, "URL", function() {

    11   return "http://localhost:" + httpserver.identity.primaryPort;

    12 });

    14 var httpserver = new HttpServer();

    15 var index = 0;

    16 var test_flags = new Array();

    17 var testPathBase = "/chunked_hdrs";

    19 function run_test()

    20 {

    21   httpserver.start(-1);

    23   do_test_pending();

    24   run_test_number(1);

    25 }

    27 function run_test_number(num)

    28 {

    29   testPath = testPathBase + num;

    30   httpserver.registerPathHandler(testPath, eval("handler" + num));

    32   var channel = setupChannel(testPath);

    33   flags = test_flags[num];   // OK if flags undefined for test

    34   channel.asyncOpen(new ChannelListener(eval("completeTest" + num),

    35                                         channel, flags), null);

    36 }

    38 function setupChannel(url)

    39 {

    40   var ios = Components.classes["@mozilla.org/network/io-service;1"].

    41                        getService(Ci.nsIIOService);

    42   var chan = ios.newChannel(URL + url, "", null);

    43   var httpChan = chan.QueryInterface(Components.interfaces.nsIHttpChannel);

    44   return httpChan;

    45 }

    47 function endTests()

    48 {

    49   httpserver.stop(do_test_finished);

    50 }

    52 ////////////////////////////////////////////////////////////////////////////////

    53 // Test 1: FAIL because of overflowed chunked size. The parser uses long so

    54 //         the test case uses >64bit to fail on all platforms.

    55 test_flags[1] = CL_EXPECT_LATE_FAILURE|CL_ALLOW_UNKNOWN_CL;

    57 function handler1(metadata, response)

    58 {

    59   var body = "12345678123456789\r\ndata never reached";

    61   response.seizePower();

    62   response.write("HTTP/1.1 200 OK\r\n");

    63   response.write("Content-Type: text/plain\r\n");

    64   response.write("Transfer-Encoding: chunked\r\n");

    65   response.write("\r\n");

    66   response.write(body);

    67   response.finish();

    68 }

    70 function completeTest1(request, data, ctx)

    71 {

    72   do_check_eq(request.status, Components.results.NS_ERROR_UNEXPECTED);

    74   run_test_number(2);

    75 }

    77 ////////////////////////////////////////////////////////////////////////////////

    78 // Test 2: FAIL because of non-hex in chunked length

    80 test_flags[2] = CL_EXPECT_LATE_FAILURE|CL_ALLOW_UNKNOWN_CL;

    82 function handler2(metadata, response)

    83 {

    84   var body = "junkintheway 123\r\ndata never reached";

    86   response.seizePower();

    87   response.write("HTTP/1.1 200 OK\r\n");

    88   response.write("Content-Type: text/plain\r\n");

    89   response.write("Transfer-Encoding: chunked\r\n");

    90   response.write("\r\n");

    91   response.write(body);

    92   response.finish();

    93 }

    95 function completeTest2(request, data, ctx)

    96 {

    97   do_check_eq(request.status, Components.results.NS_ERROR_UNEXPECTED);

    98   run_test_number(3);

    99 }

   101 ////////////////////////////////////////////////////////////////////////////////

   102 // Test 3: OK in spite of non-hex digits after size in the length field

   104 test_flags[3] = CL_ALLOW_UNKNOWN_CL;

   106 function handler3(metadata, response)

   107 {

   108   var body = "c junkafter\r\ndata reached";

   110   response.seizePower();

   111   response.write("HTTP/1.1 200 OK\r\n");

   112   response.write("Content-Type: text/plain\r\n");

   113   response.write("Transfer-Encoding: chunked\r\n");

   114   response.write("\r\n");

   115   response.write(body);

   116   response.finish();

   117 }

   119 function completeTest3(request, data, ctx)

   120 {

   121   do_check_eq(request.status, 0);

   122   run_test_number(4);

   123 }

   125 ////////////////////////////////////////////////////////////////////////////////

   126 // Test 4: Verify a fully compliant chunked response.

   128 test_flags[4] = CL_ALLOW_UNKNOWN_CL;

   130 function handler4(metadata, response)

   131 {

   132   var body = "c\r\ndata reached\r\n\0\r\n\r\n";

   134   response.seizePower();

   135   response.write("HTTP/1.1 200 OK\r\n");

   136   response.write("Content-Type: text/plain\r\n");

   137   response.write("Transfer-Encoding: chunked\r\n");

   138   response.write("\r\n");

   139   response.write(body);

   140   response.finish();

   141 }

   143 function completeTest4(request, data, ctx)

   144 {

   145   do_check_eq(request.status, 0);

   146   run_test_number(5);

   147 }

   149 ////////////////////////////////////////////////////////////////////////////////

   150 // Test 5: A chunk size larger than 32 bit but smaller than 64bit also fails

   151 // This is probabaly subject to get improved at some point.

   153 test_flags[5] = CL_EXPECT_LATE_FAILURE|CL_ALLOW_UNKNOWN_CL;

   155 function handler5(metadata, response)

   156 {

   157   var body = "123456781\r\ndata never reached";

   159   response.seizePower();

   160   response.write("HTTP/1.1 200 OK\r\n");

   161   response.write("Content-Type: text/plain\r\n");

   162   response.write("Transfer-Encoding: chunked\r\n");

   163   response.write("\r\n");

   164   response.write(body);

   165   response.finish();

   166 }

   168 function completeTest5(request, data, ctx)

   169 {

   170   do_check_eq(request.status, Components.results.NS_ERROR_UNEXPECTED);

   171   endTests();

   172 //  run_test_number(6);

   173 }

The Tor Browser / file revision