The Tor Browser: dom/network/tests/unit/test_tcpsocket.js@b8a032363ba2 (annotated)

dom/network/tests/unit/test_tcpsocket.js@b8a032363ba2 (annotated)

dom/network/tests/unit/test_tcpsocket.js

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /**
  * Test TCPSocket.js by creating an XPCOM-style server socket, then sending
  * data in both directions and making sure each side receives their data
  * correctly and with the proper events.
  *
  * This test is derived from netwerk/test/unit/test_socks.js, except we don't
  * involve a subprocess.
  *
  * Future work:
  * - SSL.  see https://bugzilla.mozilla.org/show_bug.cgi?id=466524
  *             https://bugzilla.mozilla.org/show_bug.cgi?id=662180
  *   Alternatively, mochitests could be used.
  * - Testing overflow logic.
  *
  **/
 const Cc = Components.classes;
 const Ci = Components.interfaces;
 const Cr = Components.results;
 const Cu = Components.utils;
 const CC = Components.Constructor;
 /**
  *
  * Constants
  *
  */
 // Some binary data to send.
 const DATA_ARRAY = [0, 255, 254, 0, 1, 2, 3, 0, 255, 255, 254, 0],
       DATA_ARRAY_BUFFER = new ArrayBuffer(DATA_ARRAY.length),
       TYPED_DATA_ARRAY = new Uint8Array(DATA_ARRAY_BUFFER),
       HELLO_WORLD = "hlo wrld. ",
       BIG_ARRAY = new Array(65539),
       BIG_ARRAY_2 = new Array(65539);
 TYPED_DATA_ARRAY.set(DATA_ARRAY, 0);
 for (var i_big = 0; i_big < BIG_ARRAY.length; i_big++) {
   BIG_ARRAY[i_big] = Math.floor(Math.random() * 256);
   BIG_ARRAY_2[i_big] = Math.floor(Math.random() * 256);
 }
 const BIG_ARRAY_BUFFER = new ArrayBuffer(BIG_ARRAY.length),
       BIG_ARRAY_BUFFER_2 = new ArrayBuffer(BIG_ARRAY_2.length);
 const BIG_TYPED_ARRAY = new Uint8Array(BIG_ARRAY_BUFFER),
       BIG_TYPED_ARRAY_2 = new Uint8Array(BIG_ARRAY_BUFFER_2);
 BIG_TYPED_ARRAY.set(BIG_ARRAY);
 BIG_TYPED_ARRAY_2.set(BIG_ARRAY_2);
 const ServerSocket = CC("@mozilla.org/network/server-socket;1",
                         "nsIServerSocket",
                         "init"),
       InputStreamPump = CC("@mozilla.org/network/input-stream-pump;1",
                            "nsIInputStreamPump",
                            "init"),
       BinaryInputStream = CC("@mozilla.org/binaryinputstream;1",
                              "nsIBinaryInputStream",
                              "setInputStream"),
       BinaryOutputStream = CC("@mozilla.org/binaryoutputstream;1",
                               "nsIBinaryOutputStream",
                               "setOutputStream"),
       TCPSocket = new (CC("@mozilla.org/tcp-socket;1",
                      "nsIDOMTCPSocket"))();
 const gInChild = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULRuntime)
                   .processType != Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
 Cu.import("resource://gre/modules/Services.jsm");
 /**
  *
  * Helper functions
  *
  */
 function get_platform() {
   var xulRuntime = Components.classes["@mozilla.org/xre/app-info;1"]
                               .getService(Components.interfaces.nsIXULRuntime);
   return xulRuntime.OS;
 }
 function is_content() {
   return this._inChild = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULRuntime)
                             .processType != Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
 }
 /**
  * Spin up a listening socket and associate at most one live, accepted socket
  * with ourselves.
  */
 function TestServer() {
   this.listener = ServerSocket(-1, true, -1);
   do_print('server: listening on', this.listener.port);
   this.listener.asyncListen(this);
   this.binaryInput = null;
   this.input = null;
   this.binaryOutput = null;
   this.output = null;
   this.onconnect = null;
   this.ondata = null;
   this.onclose = null;
 }
 TestServer.prototype = {
   onSocketAccepted: function(socket, trans) {
     if (this.input)
       do_throw("More than one live connection!?");
     do_print('server: got client connection');
     this.input = trans.openInputStream(0, 0, 0);
     this.binaryInput = new BinaryInputStream(this.input);
     this.output = trans.openOutputStream(0, 0, 0);
     this.binaryOutput = new BinaryOutputStream(this.output);
     new InputStreamPump(this.input, -1, -1, 0, 0, false).asyncRead(this, null);
     if (this.onconnect)
       this.onconnect();
     else
       do_throw("Received unexpected connection!");
   },
   onStopListening: function(socket) {
   },
   onDataAvailable: function(request, context, inputStream, offset, count) {
     var readData = this.binaryInput.readByteArray(count);
     if (this.ondata) {
       try {
         this.ondata(readData);
       } catch(ex) {
         // re-throw if this is from do_throw
         if (ex === Cr.NS_ERROR_ABORT)
           throw ex;
         // log if there was a test problem
         do_print('Caught exception: ' + ex + '\n' + ex.stack);
         do_throw('test is broken; bad ondata handler; see above');
       }
     } else {
       do_throw('Received ' + count + ' bytes of unexpected data!');
     }
   },
   onStartRequest: function(request, context) {
   },
   onStopRequest: function(request, context, status) {
     if (this.onclose)
       this.onclose();
     else
       do_throw("Received unexpected close!");
   },
   close: function() {
     this.binaryInput.close();
     this.binaryOutput.close();
   },
   /**
    * Forget about the socket we knew about before.
    */
   reset: function() {
     this.binaryInput = null;
     this.input = null;
     this.binaryOutput = null;
     this.output = null;
   },
 };
 function makeSuccessCase(name) {
   return function() {
     do_print('got expected: ' + name);
     run_next_test();
   };
 }
 function makeJointSuccess(names) {
   let funcs = {}, successCount = 0;
   names.forEach(function(name) {
     funcs[name] = function() {
       do_print('got expected: ' + name);
       if (++successCount === names.length)
         run_next_test();
     };
   });
   return funcs;
 }
 function makeFailureCase(name) {
   return function() {
     let argstr;
     if (arguments.length) {
       argstr = '(args: ' +
         Array.map(arguments, function(x) { return x.data + ""; }).join(" ") + ')';
     }
     else {
       argstr = '(no arguments)';
     }
     do_throw('got unexpected: ' + name + ' ' + argstr);
   };
 }
 function makeExpectData(name, expectedData, fromEvent, callback) {
   let dataBuffer = fromEvent ? null : [], done = false;
   let dataBufferView = null;
   return function(receivedData) {
     if (receivedData.data) {
       receivedData = receivedData.data;
     }
     let recvLength = receivedData.byteLength !== undefined ?
         receivedData.byteLength : receivedData.length;
     if (fromEvent) {
       if (dataBuffer) {
         let newBuffer = new ArrayBuffer(dataBuffer.byteLength + recvLength);
         let newBufferView = new Uint8Array(newBuffer);
         newBufferView.set(dataBufferView, 0);
         newBufferView.set(receivedData, dataBuffer.byteLength);
         dataBuffer = newBuffer;
         dataBufferView = newBufferView;
       }
       else {
         dataBuffer = receivedData;
         dataBufferView = new Uint8Array(dataBuffer);
       }
     }
     else {
       dataBuffer = dataBuffer.concat(receivedData);
     }
     do_print(name + ' received ' + recvLength + ' bytes');
     if (done)
       do_throw(name + ' Received data event when already done!');
     let dataView = dataBuffer.byteLength !== undefined ? new Uint8Array(dataBuffer) : dataBuffer;
     if (dataView.length >= expectedData.length) {
       // check the bytes are equivalent
       for (let i = 0; i < expectedData.length; i++) {
         if (dataView[i] !== expectedData[i]) {
           do_throw(name + ' Received mismatched character at position ' + i);
         }
       }
       if (dataView.length > expectedData.length)
         do_throw(name + ' Received ' + dataView.length + ' bytes but only expected ' +
                  expectedData.length + ' bytes.');
       done = true;
       if (callback) {
         callback();
       } else {
         run_next_test();
       }
     }
   };
 }
 var server = null, sock = null, failure_drain = null;
 /**
  *
  * Test functions
  *
  */
 /**
  * Connect the socket to the server. This test is added as the first
  * test, and is also added after every test which results in the socket
  * being closed.
  */
 function connectSock() {
   server.reset();
   var yayFuncs = makeJointSuccess(['serveropen', 'clientopen']);
   sock = TCPSocket.open(
     '127.0.0.1', server.listener.port,
     { binaryType: 'arraybuffer' });
   sock.onopen = yayFuncs.clientopen;
   sock.ondrain = null;
   sock.ondata = makeFailureCase('data');
   sock.onerror = makeFailureCase('error');
   sock.onclose = makeFailureCase('close');
   server.onconnect = yayFuncs.serveropen;
   server.ondata = makeFailureCase('serverdata');
   server.onclose = makeFailureCase('serverclose');
 }
 /**
  * Test that sending a small amount of data works, and that buffering
  * does not take place for this small amount of data.
  */
 function sendData() {
   server.ondata = makeExpectData('serverdata', DATA_ARRAY);
   if (!sock.send(DATA_ARRAY_BUFFER)) {
     do_throw("send should not have buffered such a small amount of data");
   }
 }
 /**
  * Test that sending a large amount of data works, that buffering
  * takes place (send returns true), and that ondrain is called once
  * the data has been sent.
  */
 function sendBig() {
   var yays = makeJointSuccess(['serverdata', 'clientdrain']),
       amount = 0;
   server.ondata = function (data) {
     amount += data.length;
     if (amount === BIG_TYPED_ARRAY.length) {
       yays.serverdata();
     }
   };
   sock.ondrain = function(evt) {
     if (sock.bufferedAmount) {
       do_throw("sock.bufferedAmount was > 0 in ondrain");
     }
     yays.clientdrain(evt);
   }
   if (sock.send(BIG_ARRAY_BUFFER)) {
     do_throw("expected sock.send to return false on large buffer send");
   }
 }
 /**
  * Test that data sent from the server correctly fires the ondata
  * callback on the client side.
  */
 function receiveData() {
   server.ondata = makeFailureCase('serverdata');
   sock.ondata = makeExpectData('data', DATA_ARRAY, true);
   server.binaryOutput.writeByteArray(DATA_ARRAY, DATA_ARRAY.length);
 }
 /**
  * Test that when the server closes the connection, the onclose callback
  * is fired on the client side.
  */
 function serverCloses() {
   // we don't really care about the server's close event, but we do want to
   // make sure it happened for sequencing purposes.
   var yayFuncs = makeJointSuccess(['clientclose', 'serverclose']);
   sock.ondata = makeFailureCase('data');
   sock.onclose = yayFuncs.clientclose;
   server.onclose = yayFuncs.serverclose;
   server.close();
 }
 /**
  * Test that when the client closes the connection, the onclose callback
  * is fired on the server side.
  */
 function clientCloses() {
   // we want to make sure the server heard the close and also that the client's
   // onclose event fired for consistency.
   var yayFuncs = makeJointSuccess(['clientclose', 'serverclose']);
   server.onclose = yayFuncs.serverclose;
   sock.onclose = yayFuncs.clientclose;
   sock.close();
 }
 /**
  * Send a large amount of data and immediately call close
  */
 function bufferedClose() {
   var yays = makeJointSuccess(['serverdata', 'clientclose', 'serverclose']);
   server.ondata = makeExpectData(
     "ondata", BIG_TYPED_ARRAY, false, yays.serverdata);
   server.onclose = yays.serverclose;
   sock.onclose = yays.clientclose;
   sock.send(BIG_ARRAY_BUFFER);
   sock.close();
 }
 /**
  * Connect to a port we know is not listening so an error is assured,
  * and make sure that onerror and onclose are fired on the client side.
  */
 function badConnect() {
   // There's probably nothing listening on tcp port 2.
   sock = TCPSocket.open('127.0.0.1', 2);
   sock.onopen = makeFailureCase('open');
   sock.ondata = makeFailureCase('data');
   let success = makeSuccessCase('error');
   let gotError = false;
   sock.onerror = function(event) {
     do_check_eq(event.data.name, 'ConnectionRefusedError');
     gotError = true;
   };
   sock.onclose = function() {
     if (!gotError)
       do_throw('got close without error!');
     else
       success();
   };
 }
 /**
  * Test that calling send with enough data to buffer causes ondrain to
  * be invoked once the data has been sent, and then test that calling send
  * and buffering again causes ondrain to be fired again.
  */
 function drainTwice() {
   let yays = makeJointSuccess(
     ['ondrain', 'ondrain2',
     'ondata', 'ondata2',
     'serverclose', 'clientclose']);
   let ondrainCalled = false,
       ondataCalled = false;
   function maybeSendNextData() {
     if (!ondrainCalled || !ondataCalled) {
       // make sure server got data and client got ondrain.
       return;
     }
     server.ondata = makeExpectData(
       "ondata2", BIG_TYPED_ARRAY_2, false, yays.ondata2);
     sock.ondrain = yays.ondrain2;
     if (sock.send(BIG_ARRAY_BUFFER_2)) {
       do_throw("sock.send(BIG_TYPED_ARRAY_2) did not return false to indicate buffering");
     }
     sock.close();
   }
   function clientOndrain() {
     yays.ondrain();
     ondrainCalled = true;
     maybeSendNextData();
   }
   function serverSideCallback() {
     yays.ondata();
     ondataCalled = true;
     maybeSendNextData();
   }
   server.onclose = yays.serverclose;
   server.ondata = makeExpectData(
     "ondata", BIG_TYPED_ARRAY, false, serverSideCallback);
   sock.onclose = yays.clientclose;
   sock.ondrain = clientOndrain;
   if (sock.send(BIG_ARRAY_BUFFER)) {
     throw new Error("sock.send(BIG_TYPED_ARRAY) did not return false to indicate buffering");
   }
 }
 function cleanup() {
   do_print("Cleaning up");
   sock.close();
   if (!gInChild)
     Services.prefs.clearUserPref('dom.mozTCPSocket.enabled');
   run_next_test();
 }
 /**
  * Test that calling send with enough data to buffer twice in a row without
  * waiting for ondrain still results in ondrain being invoked at least once.
  */
 function bufferTwice() {
   let yays = makeJointSuccess(
     ['ondata', 'ondrain', 'serverclose', 'clientclose']);
   let double_array = new Uint8Array(BIG_ARRAY.concat(BIG_ARRAY_2));
   server.ondata = makeExpectData(
     "ondata", double_array, false, yays.ondata);
   server.onclose = yays.serverclose;
   sock.onclose = yays.clientclose;
   sock.ondrain = function () {
     sock.close();
     yays.ondrain();
   }
   if (sock.send(BIG_ARRAY_BUFFER)) {
     throw new Error("sock.send(BIG_TYPED_ARRAY) did not return false to indicate buffering");
   }
   if (sock.send(BIG_ARRAY_BUFFER_2)) {
     throw new Error("sock.send(BIG_TYPED_ARRAY_2) did not return false to indicate buffering on second synchronous call to send");
   }
 }
 // Test child behavior when child thinks it's buffering but parent doesn't
 // buffer.
 // 1. set bufferedAmount of content socket to a value that will make next
 //    send() call return false.
 // 2. send a small data to make send() return false, but it won't make
 //    parent buffer.
 // 3. we should get a ondrain.
 function childbuffered() {
   let yays = makeJointSuccess(['ondrain', 'serverdata',
                                'clientclose', 'serverclose']);
   sock.ondrain = function() {
     yays.ondrain();
     sock.close();
   };
   server.ondata = makeExpectData(
     'ondata', DATA_ARRAY, false, yays.serverdata);
   let internalSocket = sock.QueryInterface(Ci.nsITCPSocketInternal);
   internalSocket.updateBufferedAmount(65535, // almost reach buffering threshold
 );
   if (sock.send(DATA_ARRAY_BUFFER)) {
     do_throw("expected sock.send to return false.");
   }
   sock.onclose = yays.clientclose;
   server.onclose = yays.serverclose;
 }
 // Test child's behavior when send() of child return true but parent buffers
 // data.
 // 1. send BIG_ARRAY to make parent buffer. This would make child wait for
 //    drain as well.
 // 2. set child's bufferedAmount to zero, so child will no longer wait for
 //    drain but parent will dispatch a drain event.
 // 3. wait for 1 second, to make sure there's no ondrain event dispatched in
 //    child.
 function childnotbuffered() {
   let yays = makeJointSuccess(['serverdata', 'clientclose', 'serverclose']);
   server.ondata = makeExpectData('ondata', BIG_ARRAY, false, yays.serverdata);
   if (sock.send(BIG_ARRAY_BUFFER)) {
     do_throw("sock.send(BIG_TYPED_ARRAY) did not return false to indicate buffering");
   }
   let internalSocket = sock.QueryInterface(Ci.nsITCPSocketInternal);
   internalSocket.updateBufferedAmount(0, // setting zero will clear waitForDrain in sock.
 );
   // shouldn't get ondrain, even after parent have cleared its buffer.
   sock.ondrain = makeFailureCase('drain');
   sock.onclose = yays.clientclose;
   server.onclose = yays.serverclose;
   do_timeout(1000, function() {
     sock.close();
   });
 };
 // - connect, data and events work both ways
 add_test(connectSock);
 add_test(sendData);
 add_test(sendBig);
 add_test(receiveData);
 // - server closes on us
 add_test(serverCloses);
 // - connect, we close on the server
 add_test(connectSock);
 add_test(clientCloses);
 // - connect, buffer, close
 add_test(connectSock);
 add_test(bufferedClose);
 if (get_platform() !== "Darwin") {
   // This test intermittently fails way too often on OS X, for unknown reasons.
   // Please, diagnose and fix it if you can.
   // - get an error on an attempt to connect to a non-listening port
   add_test(badConnect);
 }
 // send a buffer, get a drain, send a buffer, get a drain
 add_test(connectSock);
 add_test(drainTwice);
 // send a buffer, get a drain, send a buffer, get a drain
 add_test(connectSock);
 add_test(bufferTwice);
 if (is_content()) {
   add_test(connectSock);
   add_test(childnotbuffered);
   add_test(connectSock);
   add_test(childbuffered);
 }
 // clean up
 add_test(cleanup);
 function run_test() {
   if (!gInChild)
     Services.prefs.setBoolPref('dom.mozTCPSocket.enabled', true);
   server = new TestServer();
   run_next_test();
 }