1 files changed, 102 insertions, 0 deletions
diff --git a/js/src/jit-test/tests/ctypes/typedarrays.js b/js/src/jit-test/tests/ctypes/typedarrays.js
new file mode 100644
index 0000000000..4595e8fe1f
--- /dev/null
+++ b/js/src/jit-test/tests/ctypes/typedarrays.js
@@ -0,0 +1,102 @@
+load(libdir + 'asserts.js');
+
+function typedArrayMatchesString(ta, str, uptoStringLength = false) {
+  if (ta.length != str.length && !uptoStringLength)
+    return false;
+  for (let i = 0; i < str.length; i++) {
+    if (ta[i] != str.charCodeAt(i))
+      return false;
+  }
+  return true;
+}
+
+function test() {
+
+  // Check that {signed,unsigned} -> {Int*Array, Uint*Array} for string types.
+
+  const shortU8 = ctypes.unsigned_char.array(10)("abc\0\0\0\0\0\0\0").readTypedArray();
+  assertEq(shortU8 instanceof Uint8Array, true);
+  assertEq(typedArrayMatchesString(shortU8, "abc\0\0\0\0\0\0\0"), true);
+
+  const shortI8 = ctypes.signed_char.array(10)("abc\0\0\0\0\0\0\0").readTypedArray();
+  assertEq(shortI8 instanceof Int8Array, true);
+  assertEq(typedArrayMatchesString(shortI8, "abc\0\0\0\0\0\0\0"), true);
+
+  const shortU16 = ctypes.char16_t.array(10)("千").readTypedArray();
+  assertEq(shortU16 instanceof Uint16Array, true);
+  assertEq(typedArrayMatchesString(shortU16, "千", 'ignore zero-padding, please'), true);
+
+  // ...and for (other) numeric types.
+
+  const I16 = ctypes.int16_t.array(10)().readTypedArray();
+  assertEq(I16 instanceof Int16Array, true);
+
+  const U32 = ctypes.uint32_t.array(10)().readTypedArray();
+  assertEq(U32 instanceof Uint32Array, true);
+
+  const I32 = ctypes.int32_t.array(10)().readTypedArray();
+  assertEq(I32 instanceof Int32Array, true);
+
+  // Check that pointers without associated length get truncated to strlen().
+
+  const unsignedCharArray = ctypes.unsigned_char.array(10)("abc\0\0\0");
+  const shortU8cs = unsignedCharArray.addressOfElement(0).readTypedArray();
+  assertEq(shortU8cs instanceof Uint8Array, true);
+  assertEq(shortU8cs.length, 3);
+  assertEq(typedArrayMatchesString(shortU8cs, "abc", 'stop at NUL, please'), true);
+
+  const signedCharArray = ctypes.signed_char.array(10)("abc\0\0\0");
+  const shortI8cs = signedCharArray.addressOfElement(0).readTypedArray();
+  assertEq(shortI8cs instanceof Int8Array, true);
+  assertEq(shortI8cs.length, 3);
+  assertEq(typedArrayMatchesString(shortI8cs, "abc", 'stop at NUL, please'), true);
+
+  const char16Array = ctypes.char16_t.array(10)("千\0");
+  const shortU16cs = char16Array.addressOfElement(0).readTypedArray();
+  assertEq(shortU16cs instanceof Uint16Array, true);
+  assertEq(shortU16cs.length, 1);
+  assertEq(typedArrayMatchesString(shortU16cs, "千", 'ignore zero-padding, please'), true);
+
+  // Other types should just fail if the length is not known.
+
+  assertTypeErrorMessage(() => { ctypes.int32_t.array(3)().addressOfElement(0).readTypedArray(); },
+                         /base type .* is not an 8-bit or 16-bit integer or character type/);
+  assertTypeErrorMessage(() => { ctypes.float.array(3)().addressOfElement(0).readTypedArray(); },
+                         /base type .* is not an 8-bit or 16-bit integer or character type/);
+  assertTypeErrorMessage(() => { ctypes.double.array(3)().addressOfElement(0).readTypedArray(); },
+                         /base type .* is not an 8-bit or 16-bit integer or character type/);
+  // char16_t is unsigned, so this is not a string type.
+  assertTypeErrorMessage(() => { ctypes.int16_t.array(3)().addressOfElement(0).readTypedArray(); },
+                         /base type .* is not an 8-bit or 16-bit integer or character type/);
+
+  // Wide string -> bytes -> UTF-8 encoded string in typed array
+
+  const input2 = "千千千千千千千千千千千千千千千千千千千千千千千千千";
+  const encoded = ctypes.char.array(input2.length * 3)(input2).readTypedArray();
+  // Each 千 character is encoded as 3 bytes.
+  assertEq(encoded.length, input2.length * 3);
+
+  // Wide string -> char16_t -> 16-bit encoded string in typed array
+
+  const encoded16 = ctypes.char16_t.array(input2.length)(input2).readTypedArray();
+  assertEq(encoded16.length, input2.length);
+
+  // Floats
+
+  const floats = ctypes.float.array(3)([10, 20, 30]).readTypedArray();
+  assertEq(floats instanceof Float32Array, true);
+  assertEq(floats.toString(), "10,20,30");
+
+  const doubles = ctypes.double.array(3)([10, 20, 30]).readTypedArray();
+  assertEq(doubles instanceof Float64Array, true);
+  assertEq(doubles.toString(), "10,20,30");
+
+  // Invalid
+
+  assertTypeErrorMessage(() => { ctypes.int64_t.array(3)([10, 20, 30]).readTypedArray() },
+                         /base type ctypes.int64_t.array.*is not compatible with a typed array element type/);
+
+}
+
+if (typeof ctypes === "object")
+  test();