1 files changed, 98 insertions, 0 deletions
diff --git a/js/src/jit-test/tests/ctypes/conversion-to-number.js b/js/src/jit-test/tests/ctypes/conversion-to-number.js
new file mode 100644
index 0000000000..6a334ecf3a
--- /dev/null
+++ b/js/src/jit-test/tests/ctypes/conversion-to-number.js
@@ -0,0 +1,98 @@
+// Type conversion to number should use ECMA-style semantics.
+
+load(libdir + 'asserts.js');
+
+function test() {
+  function checkValue(type, provided, expected) {
+    assertEq(ctypes[type](provided).value, expected,
+             `ctypes.${type}(${provided}) contains unexpected value`);
+  }
+
+  function checkCantConvert(type, value) {
+    var ctor = ctypes[type];
+    assertTypeErrorMessage(() => ctor(value),
+                           /can't convert the number/);
+  }
+
+  let testInt8 = checkValue.bind(undefined, "int8_t");
+  let testInt8Throws = checkCantConvert.bind(undefined, "int8_t");
+  testInt8(1e100, 0);
+  testInt8Throws(-129);
+  testInt8(-128, -128);
+  testInt8(-1, -1);
+  testInt8(0, 0);
+  testInt8(1, 1);
+  testInt8(127, 127);
+  testInt8Throws(128);
+
+  let testUint8 = checkValue.bind(undefined, "uint8_t");
+  let testUint8Throws = checkCantConvert.bind(undefined, "uint8_t");
+  testUint8(1e100, 0);
+  testUint8Throws(-1);
+  testUint8(0, 0);
+  testUint8(1, 1);
+  testUint8(127, 127);
+  testUint8(128, 128);
+  testUint8(255, 255);
+  testUint8Throws(256);
+
+  let testInt16 = checkValue.bind(undefined, "int16_t");
+  let testInt16Throws = checkCantConvert.bind(undefined, "int16_t");
+  testInt16(1e100, 0);
+  testInt16Throws(-32769);
+  testInt16(-32768, -32768);
+  testInt16(-1, -1);
+  testInt16(0, 0);
+  testInt16(1, 1);
+  testInt16(32767, 32767);
+  testInt16Throws(32768);
+
+  let testUint16 = checkValue.bind(undefined, "uint16_t");
+  let testUint16Throws = checkCantConvert.bind(undefined, "uint16_t");
+  testUint16(1e100, 0);
+  testUint16Throws(-1);
+  testUint16(0, 0);
+  testUint16(1, 1);
+  testUint16(32767, 32767);
+  testUint16(32768, 32768);
+  testUint16(65535, 65535);
+  testUint16Throws(65536);
+
+  let testInt32 = checkValue.bind(undefined, "int32_t");
+  let testInt32Throws = checkCantConvert.bind(undefined, "int32_t");
+  testInt32(1e100, 0);
+  // This probably should pass, but right now doubles fall into a different
+  // code path where no error occurs.  ctypes is probably/hopefully declining in
+  // use now, so just don't bother with this test.
+  //testInt32Throws(-2147483649);
+  testInt32(-2147483648, -2147483648);
+  testInt32(-1, -1);
+  testInt32(0, 0);
+  testInt32(1, 1);
+  testInt32(2147483647, 2147483647);
+  // This probably should pass, but right now doubles fall into a different
+  // code path where no error occurs.  ctypes is probably/hopefully declining in
+  // use now, so just don't bother with this test.
+  //testInt32Throws(2147483648);
+
+  let testUint32 = checkValue.bind(undefined, "uint32_t");
+  let testUint32Throws = checkCantConvert.bind(undefined, "uint32_t");
+  testUint32(1e100, 0);
+  testUint32Throws(-1);
+  // This probably should pass, but right now doubles fall into a different
+  // code path where no error occurs.  ctypes is probably/hopefully declining in
+  // use now, so just don't bother with this test.
+  //testUint32Throws(-1 * Math.cos(Math.PI)); // -1.0 encoded as a double
+  testUint32(0, 0);
+  testUint32(1, 1);
+  testUint32(2147483647, 2147483647);
+  testUint32(2147483648, 2147483648);
+  testUint32(4294967295, 4294967295);
+  // This probably should pass, but right now doubles fall into a different
+  // code path where no error occurs.  ctypes is probably/hopefully declining in
+  // use now, so just don't bother with this test.
+  //testUint32Throws(4294967296);
+}
+
+if (typeof ctypes === "object")
+  test();