1 files changed, 217 insertions, 0 deletions
diff --git a/dom/system/gonk/tests/header_helpers.js b/dom/system/gonk/tests/header_helpers.js
new file mode 100644
index 000000000..8d1144f75
--- /dev/null
+++ b/dom/system/gonk/tests/header_helpers.js
@@ -0,0 +1,217 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+
+
+var subscriptLoader = Cc["@mozilla.org/moz/jssubscript-loader;1"]
+                        .getService(Ci.mozIJSSubScriptLoader);
+
+/**
+ * Start a new RIL worker.
+ *
+ * @param custom_ns
+ *        Namespace with symbols to be injected into the new worker
+ *        namespace.
+ *
+ * @return an object that represents the worker's namespace.
+ *
+ * @note that this does not start an actual worker thread. The worker
+ * is executed on the main thread, within a separate namespace object.
+ */
+function newWorker(custom_ns) {
+  let worker_ns = {
+    importScripts: function() {
+      Array.slice(arguments).forEach(function(script) {
+        if (!script.startsWith("resource:")) {
+          script = "resource://gre/modules/" + script;
+        }
+        subscriptLoader.loadSubScript(script, this);
+      }, this);
+    },
+
+    postRILMessage: function(message) {
+    },
+
+    postMessage: function(message) {
+    },
+
+    // Define these variables inside the worker scope so ES5 strict mode
+    // doesn't flip out.
+    onmessage: undefined,
+    onerror: undefined,
+
+    DEBUG: true
+  };
+  // The 'self' variable in a worker points to the worker's own namespace.
+  worker_ns.self = worker_ns;
+
+  // Copy the custom definitions over.
+  for (let key in custom_ns) {
+    worker_ns[key] = custom_ns[key];
+  }
+
+  // fake require() for toolkit/components/workerloader/require.js
+  let require = (function() {
+    return function require(script) {
+      worker_ns.module = {};
+      worker_ns.importScripts(script);
+      return worker_ns;
+    }
+  })();
+
+  Object.freeze(require);
+  Object.defineProperty(worker_ns, "require", {
+    value: require,
+    enumerable: true,
+    configurable: false
+  });
+
+  // Load the RIL worker itself.
+  worker_ns.importScripts("ril_worker.js");
+
+  // Register at least one client.
+  worker_ns.ContextPool.registerClient({ clientId: 0 });
+
+  return worker_ns;
+}
+
+/**
+ * Create a buffered RIL worker.
+ *
+ * @return A worker object that stores sending octets in a internal buffer.
+ */
+function newUint8Worker() {
+  let worker = newWorker();
+  let index = 0; // index for read
+  let buf = [];
+
+  let context = worker.ContextPool._contexts[0];
+  context.Buf.writeUint8 = function(value) {
+    buf.push(value);
+  };
+
+  context.Buf.readUint8 = function() {
+    return buf[index++];
+  };
+
+  context.Buf.seekIncoming = function(offset) {
+    index += offset;
+  };
+
+  context.Buf.getReadAvailable = function() {
+    return buf.length - index;
+  };
+
+  worker.debug = do_print;
+
+  return worker;
+}
+
+/**
+ * Create a worker that keeps posted chrome message.
+ */
+function newInterceptWorker() {
+  let postedMessage;
+  let worker = newWorker({
+    postRILMessage: function(data) {
+    },
+    postMessage: function(message) {
+      postedMessage = message;
+    }
+  });
+  return {
+    get postedMessage() {
+      return postedMessage;
+    },
+    get worker() {
+      return worker;
+    }
+  };
+}
+
+/**
+ * Create a parcel suitable for postRILMessage().
+ *
+ * @param fakeParcelSize
+ *        Value to be written to parcel size field for testing
+ *        incorrect/incomplete parcel reading. Replaced with correct
+ *        one determined length of data if negative.
+ * @param response
+ *        Response code of the incoming parcel.
+ * @param request
+ *        Request code of the incoming parcel.
+ * @param data
+ *        Extra data to be appended.
+ *
+ * @return an Uint8Array carrying all parcel data.
+ */
+function newIncomingParcel(fakeParcelSize, response, request, data) {
+  const UINT32_SIZE = 4;
+  const PARCEL_SIZE_SIZE = 4;
+
+  let realParcelSize = data.length + 2 * UINT32_SIZE;
+  let buffer = new ArrayBuffer(realParcelSize + PARCEL_SIZE_SIZE);
+  let bytes = new Uint8Array(buffer);
+
+  let writeIndex = 0;
+  function writeUint8(value) {
+    bytes[writeIndex] = value;
+    ++writeIndex;
+  }
+
+  function writeInt32(value) {
+    writeUint8(value & 0xff);
+    writeUint8((value >> 8) & 0xff);
+    writeUint8((value >> 16) & 0xff);
+    writeUint8((value >> 24) & 0xff);
+  }
+
+  function writeParcelSize(value) {
+    writeUint8((value >> 24) & 0xff);
+    writeUint8((value >> 16) & 0xff);
+    writeUint8((value >> 8) & 0xff);
+    writeUint8(value & 0xff);
+  }
+
+  if (fakeParcelSize < 0) {
+    fakeParcelSize = realParcelSize;
+  }
+  writeParcelSize(fakeParcelSize);
+
+  writeInt32(response);
+  writeInt32(request);
+
+  // write parcel data
+  for (let ii = 0; ii < data.length; ++ii) {
+    writeUint8(data[ii]);
+  }
+
+  return bytes;
+}
+
+/**
+ * Create a parcel buffer which represents the hex string.
+ *
+ * @param hexString
+ *        The HEX string to be converted.
+ *
+ * @return an Uint8Array carrying all parcel data.
+ */
+function hexStringToParcelByteArrayData(hexString) {
+  let length = Math.ceil((hexString.length / 2));
+  let bytes = new Uint8Array(4 + length);
+
+  bytes[0] = length & 0xFF;
+  bytes[1] = (length >>  8) & 0xFF;
+  bytes[2] = (length >> 16) & 0xFF;
+  bytes[3] = (length >> 24) & 0xFF;
+
+  for (let i = 0; i < length; i ++) {
+    bytes[i + 4] = Number.parseInt(hexString.substr(i * 2, 2), 16);
+  }
+
+  return bytes;
+}