js/xpconnect/tests/unit/test_params.js

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 function TestParams() {
   6 }
   7
   8 /* For once I'm happy that JS is weakly typed. */
   9 function f(a, b) {
  10     var rv = b.value;
  11     b.value = a;
  12     return rv;
  13 };
  14
  15 /* Implementation for size_is and iid_is methods. */
  16 function f_is(aIs, a, bIs, b, rvIs) {
  17
  18     // Set up the return value and its 'is' parameter.
  19     var rv = b.value;
  20     rvIs.value = bIs.value;
  21
  22     // Set up b and its 'is' parameter.
  23     b.value = a;
  24     bIs.value = aIs;
  25
  26     return rv;
  27 }
  28
  29 function f_size_and_iid(aSize, aIID, a, bSize, bIID, b, rvSize, rvIID) {
  30
  31     // Copy the iids.
  32     rvIID.value = bIID.value;
  33     bIID.value = aIID;
  34
  35     // Now that we've reduced the problem to one dependent variable, use f_is.
  36     return f_is(aSize, a, bSize, b, rvSize);
  37 }
  38
  39 TestParams.prototype = {
  40   QueryInterface: ChromeUtils.generateQI(["nsIXPCTestParams"]),
  41
  42   /* nsIXPCTestParams */
  43   testBoolean: f,
  44   testOctet: f,
  45   testShort: f,
  46   testLong: f,
  47   testLongLong: f,
  48   testUnsignedShort: f,
  49   testUnsignedLong: f,
  50   testUnsignedLongLong: f,
  51   testFloat: f,
  52   testDouble: f,
  53   testChar: f,
  54   testString: f,
  55   testWchar: f,
  56   testWstring: f,
  57   testAString: f,
  58   testAUTF8String: f,
  59   testACString: f,
  60   testJsval: f,
  61   testShortSequence: f,
  62   testDoubleSequence: f,
  63   testAStringSequence: f,
  64   testACStringSequence: f,
  65   testInterfaceSequence: f,
  66   testJsvalSequence: f,
  67   testInterfaceIsSequence: f_is,
  68   testOptionalSequence: function (arr) { return arr; },
  69   testShortArray: f_is,
  70   testDoubleArray: f_is,
  71   testStringArray: f_is,
  72   testByteArrayOptionalLength(arr) { return arr.length; },
  73   testWstringArray: f_is,
  74   testInterfaceArray: f_is,
  75   testJsvalArray: f_is,
  76   testSizedString: f_is,
  77   testSizedWstring: f_is,
  78   testInterfaceIs: f_is,
  79   testInterfaceIsArray: f_size_and_iid,
  80   testOutAString: function(o) { o.value = "out"; },
  81   testStringArrayOptionalSize: function(arr, size) {
  82     if (arr.length != size) { throw "bad size passed to test method"; }
  83     var rv = "";
  84     arr.forEach((x) => rv += x);
  85     return rv;
  86   },
  87   testOmittedOptionalOut(jsObj, o) {
  88     if (typeof o != "object" || o.value !== undefined) {
  89       throw new Components.Exception(
  90         "unexpected value",
  91         Cr.NS_ERROR_ILLEGAL_VALUE
  92       );
  93     }
  94     o.value = Cc["@mozilla.org/network/io-service;1"]
  95       .getService(Ci.nsIIOService)
  96       .newURI("http://example.com/");
  97   },
  98   testNaN: NaN,
  99 };
 100
 101 function TestInterfaceA() {}
 102 TestInterfaceA.prototype = {
 103   QueryInterface: ChromeUtils.generateQI(["nsIXPCTestInterfaceA"]),
 104
 105   /* nsIXPCTestInterfaceA */
 106   name: "TestInterfaceADefaultName"
 107 };
 108
 109 function TestInterfaceB() {}
 110 TestInterfaceB.prototype = {
 111   QueryInterface: ChromeUtils.generateQI(["nsIXPCTestInterfaceB"]),
 112
 113   /* nsIXPCTestInterfaceA */
 114   name: "TestInterfaceADefaultName"
 115 };
 116
 117 function run_test() {
 118
 119   // Load the component manifests.
 120   registerXPCTestComponents();
 121
 122   // Test for each component.
 123   test_component(Cc["@mozilla.org/js/xpc/test/native/Params;1"].createInstance());
 124   test_component(xpcWrap(new TestParams()));
 125 }
 126
 127 function test_component(obj) {
 128   var o = obj.QueryInterface(Ci.nsIXPCTestParams);
 129
 130   // Possible comparator functions.
 131   var standardComparator = function(a,b) {return a == b;};
 132   var dotEqualsComparator = function(a,b) {return a.equals(b); }
 133   var fuzzComparator = function(a,b) {return Math.abs(a - b) < 0.1;};
 134   var interfaceComparator = function(a,b) {return a.name == b.name; }
 135   var arrayComparator = function(innerComparator) {
 136     return function(a,b) {
 137       if (a.length != b.length)
 138         return false;
 139       for (var i = 0; i < a.length; ++i)
 140         if (!innerComparator(a[i], b[i]))
 141           return false;
 142       return true;
 143     };
 144   };
 145
 146   // Helper test function - takes the name of test method and two values of
 147   // the given type.
 148   //
 149   // The optional comparator argument can be used for alternative notions of
 150   // equality. The comparator should return true on equality.
 151   function doTest(name, val1, val2, comparator) {
 152     if (!comparator)
 153       comparator = standardComparator;
 154     var a = val1;
 155     var b = {value: val2};
 156     var rv = o[name].call(o, a, b);
 157     Assert.ok(comparator(rv, val2));
 158     Assert.ok(comparator(val1, b.value));
 159   };
 160
 161   function doIsTest(name, val1, val1Is, val2, val2Is, valComparator, isComparator) {
 162     if (!isComparator)
 163       isComparator = standardComparator;
 164     var a = val1;
 165     var aIs = val1Is;
 166     var b = {value: val2};
 167     var bIs = {value: val2Is};
 168     var rvIs = {};
 169     var rv = o[name].call(o, aIs, a, bIs, b, rvIs);
 170     Assert.ok(valComparator(rv, val2));
 171     Assert.ok(isComparator(rvIs.value, val2Is));
 172     Assert.ok(valComparator(val1, b.value));
 173     Assert.ok(isComparator(val1Is, bIs.value));
 174   }
 175
 176   // Special-purpose function for testing arrays of iid_is interfaces, where we
 177   // have 2 distinct sets of dependent parameters.
 178   function doIs2Test(name, val1, val1Size, val1IID, val2, val2Size, val2IID) {
 179     var a = val1;
 180     var aSize = val1Size;
 181     var aIID = val1IID;
 182     var b = {value: val2};
 183     var bSize = {value: val2Size};
 184     var bIID = {value: val2IID};
 185     var rvSize = {};
 186     var rvIID = {};
 187     var rv = o[name].call(o, aSize, aIID, a, bSize, bIID, b, rvSize, rvIID);
 188     Assert.ok(arrayComparator(interfaceComparator)(rv, val2));
 189     Assert.ok(standardComparator(rvSize.value, val2Size));
 190     Assert.ok(dotEqualsComparator(rvIID.value, val2IID));
 191     Assert.ok(arrayComparator(interfaceComparator)(val1, b.value));
 192     Assert.ok(standardComparator(val1Size, bSize.value));
 193     Assert.ok(dotEqualsComparator(val1IID, bIID.value));
 194   }
 195
 196   // Check that the given call (type mismatch) results in an exception being thrown.
 197   function doTypedArrayMismatchTest(name, val1, val1Size, val2, val2Size) {
 198     var comparator = arrayComparator(standardComparator);
 199     var error = false;
 200     try {
 201       doIsTest(name, val1, val1Size, val2, val2Size, comparator);
 202
 203       // An exception was not thrown as would have been expected.
 204       Assert.ok(false);
 205     }
 206     catch (e) {
 207       // An exception was thrown as expected.
 208       Assert.ok(true);
 209     }
 210   }
 211
 212   // Workaround for bug 687612 (inout parameters broken for dipper types).
 213   // We do a simple test of copying a into b, and ignore the rv.
 214   function doTestWorkaround(name, val1) {
 215     var a = val1;
 216     var b = {value: ""};
 217     o[name].call(o, a, b);
 218     Assert.equal(val1, b.value);
 219   }
 220
 221   // Test all the different types
 222   doTest("testBoolean", true, false);
 223   doTest("testOctet", 4, 156);
 224   doTest("testShort", -456, 1299);
 225   doTest("testLong", 50060, -12121212);
 226   doTest("testLongLong", 12345, -10000000000);
 227   doTest("testUnsignedShort", 1532, 65000);
 228   doTest("testUnsignedLong", 0, 4000000000);
 229   doTest("testUnsignedLongLong", 215435, 3453492580348535809);
 230   doTest("testFloat", 4.9, -11.2, fuzzComparator);
 231   doTest("testDouble", -80.5, 15000.2, fuzzComparator);
 232   doTest("testChar", "a", "2");
 233   doTest("testString", "someString", "another string");
 234   doTest("testWstring", "Why wasnt this", "turned on before? ಠ_ಠ");
 235   doTest("testWchar", "z", "ア");
 236   doTestWorkaround("testAString", "Frosty the ☃ ;-)");
 237   doTestWorkaround("testAUTF8String", "We deliver 〠!");
 238   doTestWorkaround("testACString", "Just a regular C string.");
 239   doTest("testJsval", {aprop: 12, bprop: "str"}, 4.22);
 240
 241   // Test out dipper parameters, since they're special and we can't really test
 242   // inouts.
 243   let outAString = {};
 244   o.testOutAString(outAString);
 245   Assert.equal(outAString.value, "out");
 246   try { o.testOutAString(undefined); } catch (e) {} // Don't crash
 247   try { o.testOutAString(null); } catch (e) {} // Don't crash
 248   try { o.testOutAString("string"); } catch (e) {} // Don't crash
 249
 250   // Helpers to instantiate various test XPCOM objects.
 251   var numAsMade = 0;
 252   function makeA() {
 253     var a = xpcWrap(new TestInterfaceA(), Ci.nsIXPCTestInterfaceA);
 254     a.name = 'testA' + numAsMade++;
 255     return a;
 256   };
 257   var numBsMade = 0;
 258   function makeB() {
 259     var b = xpcWrap(new TestInterfaceB(), Ci.nsIXPCTestInterfaceB);
 260     b.name = 'testB' + numBsMade++;
 261     return b;
 262   };
 263
 264   // Test arrays.
 265   doIsTest("testShortArray", [2, 4, 6], 3, [1, 3, 5, 7], 4, arrayComparator(standardComparator));
 266   doIsTest("testDoubleArray", [-10, -0.5], 2, [1, 3, 1e11, -8e-5 ], 4, arrayComparator(fuzzComparator));
 267
 268   doIsTest("testStringArray", ["mary", "hat", "hey", "lid", "tell", "lam"], 6,
 269                               ["ids", "fleas", "woes", "wide", "has", "know", "!"], 7, arrayComparator(standardComparator));
 270   doIsTest("testWstringArray", ["沒有語言", "的偉大嗎?]"], 2,
 271                                ["we", "are", "being", "sooo", "international", "right", "now"], 7, arrayComparator(standardComparator));
 272   doIsTest("testInterfaceArray", [makeA(), makeA()], 2,
 273                                  [makeA(), makeA(), makeA(), makeA(), makeA(), makeA()], 6, arrayComparator(interfaceComparator));
 274   doIsTest("testJsvalArray", [{ cheese: 'whiz', apple: 8 }, [1, 5, '3'], /regex/], 3,
 275                              ['apple', 2.2e10, 3.3e30, { only: "wheedle", except: {} }], 4, arrayComparator(standardComparator));
 276
 277   // Test typed arrays and ArrayBuffer aliasing.
 278   var arrayBuffer = new ArrayBuffer(16);
 279   var int16Array = new Int16Array(arrayBuffer, 2, 3);
 280   int16Array.set([-32768, 0, 32767]);
 281   doIsTest("testShortArray", int16Array, 3, new Int16Array([1773, -32768, 32767, 7]), 4, arrayComparator(standardComparator));
 282   doIsTest("testDoubleArray", new Float64Array([-10, -0.5]), 2, new Float64Array([0, 3.2, 1.0e10, -8.33 ]), 4, arrayComparator(fuzzComparator));
 283
 284   // Test sized strings.
 285   var ssTests = ["Tis not possible, I muttered", "give me back my free hardcore!", "quoth the server:", "4〠4"];
 286   doIsTest("testSizedString", ssTests[0], ssTests[0].length, ssTests[1], ssTests[1].length, standardComparator);
 287   doIsTest("testSizedWstring", ssTests[2], ssTests[2].length, ssTests[3], ssTests[3].length, standardComparator);
 288
 289   // Test iid_is.
 290   doIsTest("testInterfaceIs", makeA(), Ci['nsIXPCTestInterfaceA'],
 291                               makeB(), Ci['nsIXPCTestInterfaceB'],
 292                               interfaceComparator, dotEqualsComparator);
 293
 294   // Test arrays of iids.
 295   doIs2Test("testInterfaceIsArray", [makeA(), makeA(), makeA(), makeA(), makeA()], 5, Ci['nsIXPCTestInterfaceA'],
 296                                     [makeB(), makeB(), makeB()], 3, Ci['nsIXPCTestInterfaceB']);
 297
 298   // Test optional array size.
 299   Assert.equal(o.testStringArrayOptionalSize(["some", "string", "array"]), "somestringarray");
 300
 301   // Test incorrect (too big) array size parameter; this should throw NOT_ENOUGH_ELEMENTS.
 302   doTypedArrayMismatchTest("testShortArray", new Int16Array([-3, 7, 4]), 4,
 303                                              new Int16Array([1, -32, 6]), 3);
 304
 305   // Test type mismatch (int16 <-> uint16); this should throw BAD_CONVERT_JS.
 306   doTypedArrayMismatchTest("testShortArray", new Uint16Array([0, 7, 4, 3]), 4,
 307                                              new Uint16Array([1, 5, 6]), 3);
 308
 309   // Test Sequence<T> types.
 310   doTest("testShortSequence", [2, 4, 6], [1, 3, 5, 7], arrayComparator(standardComparator));
 311   doTest("testDoubleSequence", [-10, -0.5], [1, 3, 1e11, -8e-5 ], arrayComparator(fuzzComparator));
 312   doTest("testACStringSequence", ["mary", "hat", "hey", "lid", "tell", "lam"],
 313                                  ["ids", "fleas", "woes", "wide", "has", "know", "!"],
 314                                  arrayComparator(standardComparator));
 315   doTest("testAStringSequence", ["沒有語言", "的偉大嗎?]"],
 316                                 ["we", "are", "being", "sooo", "international", "right", "now"],
 317                                 arrayComparator(standardComparator));
 318
 319   doTest("testInterfaceSequence", [makeA(), makeA()],
 320                                   [makeA(), makeA(), makeA(), makeA(), makeA(), makeA()], arrayComparator(interfaceComparator));
 321
 322   doTest("testJsvalSequence", [{ cheese: 'whiz', apple: 8 }, [1, 5, '3'], /regex/],
 323                               ['apple', 2.2e10, 3.3e30, { only: "wheedle", except: {} }], arrayComparator(standardComparator));
 324
 325   doIsTest("testInterfaceIsSequence", [makeA(), makeA(), makeA(), makeA(), makeA()], Ci['nsIXPCTestInterfaceA'],
 326                                       [makeB(), makeB(), makeB()], Ci['nsIXPCTestInterfaceB'],
 327                                       arrayComparator(interfaceComparator), dotEqualsComparator);
 328
 329   var ret = o.testOptionalSequence();
 330   Assert.ok(Array.isArray(ret));
 331   Assert.equal(ret.length, 0);
 332
 333   ret = o.testOptionalSequence([]);
 334   Assert.ok(Array.isArray(ret));
 335   Assert.equal(ret.length, 0);
 336
 337   ret = o.testOptionalSequence([1, 2, 3]);
 338   Assert.ok(Array.isArray(ret));
 339   Assert.equal(ret.length, 3);
 340
 341   let jsObj = new TestParams();
 342   o.testOmittedOptionalOut(jsObj);
 343   ret = {};
 344   o.testOmittedOptionalOut(jsObj, ret);
 345   Assert.equal(ret.value.spec, "http://example.com/")
 346
 347   // Tests for large ArrayBuffers.
 348   var ab = null;
 349   try {
 350     ab = new ArrayBuffer(4.5 * 1024 * 1024 * 1024); // 4.5 GB.
 351   } catch (e) {
 352     // Large ArrayBuffers not available (32-bit or disabled).
 353   }
 354   if (ab) {
 355     var uint8 = new Uint8Array(ab);
 356
 357     // Test length check in JSArray2Native.
 358     var ex = null;
 359     try {
 360       o.testOptionalSequence(uint8);
 361     } catch (e) {
 362       ex = e;
 363     }
 364     Assert.ok(ex.message.includes("Could not convert JavaScript argument arg 0"));
 365
 366     // Test length check for optional length argument in GetArraySizeFromParam.
 367     ex = null;
 368     try {
 369       o.testByteArrayOptionalLength(uint8);
 370     } catch (e) {
 371       ex = e;
 372     }
 373     Assert.ok(ex.message.includes("Cannot convert JavaScript object into an array"));
 374
 375     // Smaller array views on the buffer are fine.
 376     uint8 = new Uint8Array(ab, ab.byteLength - 3);
 377     uint8[0] = 123;
 378     Assert.equal(uint8.byteLength, 3);
 379     Assert.equal(o.testOptionalSequence(uint8).toString(), "123,0,0");
 380     Assert.equal(o.testByteArrayOptionalLength(uint8), 3);
 381   }
 382
 383   Assert.ok(isNaN(o.testNaN), "Should handle returning NaNs");
 384 }