diff options
Diffstat (limited to 'toolkit/components/ctypes/tests/unit/test_jsctypes.js')
| -rw-r--r-- | toolkit/components/ctypes/tests/unit/test_jsctypes.js | 2808 |
1 files changed, 0 insertions, 2808 deletions
diff --git a/toolkit/components/ctypes/tests/unit/test_jsctypes.js b/toolkit/components/ctypes/tests/unit/test_jsctypes.js deleted file mode 100644 index ec35ee18e..000000000 --- a/toolkit/components/ctypes/tests/unit/test_jsctypes.js +++ /dev/null @@ -1,2808 +0,0 @@ -/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ -/* This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ - -try { - // We might be running without privileges, in which case it's up to the - // harness to give us the 'ctypes' object. - Components.utils.import("resource://gre/modules/ctypes.jsm"); -} catch (e) { -} - -CTYPES_TEST_LIB = ctypes.libraryName("jsctypes-test"); -CTYPES_UNICODE_LIB = ctypes.libraryName("jsctyp\u00E8s-t\u00EB\u00DFt"); - -function do_check_throws(f, type, stack) -{ - if (!stack) { - try { - // We might not have a 'Components' object. - stack = Components.stack.caller; - } catch (e) { - } - } - - try { - f(); - } catch (exc) { - if (exc.constructor.name === type.name) { - do_check_true(true); - return; - } - do_throw("expected " + type.name + " exception, caught " + exc, stack); - } - do_throw("expected " + type.name + " exception, none thrown", stack); -} - -function run_test() -{ - // Test ctypes.CType and ctypes.CData are set up correctly. - run_abstract_class_tests(); - - // open the library - let libfile = do_get_file(CTYPES_TEST_LIB); - let library = ctypes.open(libfile.path); - - // Make sure we can call a function in the library. - run_void_tests(library); - - // Test Int64 and UInt64. - run_Int64_tests(); - run_UInt64_tests(); - - // Test the basic bool, integer, and float types. - run_bool_tests(library); - - run_integer_tests(library, ctypes.int8_t, "int8_t", 1, true, [-0x80, 0x7f]); - run_integer_tests(library, ctypes.int16_t, "int16_t", 2, true, [-0x8000, 0x7fff]); - run_integer_tests(library, ctypes.int32_t, "int32_t", 4, true, [-0x80000000, 0x7fffffff]); - run_integer_tests(library, ctypes.uint8_t, "uint8_t", 1, false, [0, 0xff]); - run_integer_tests(library, ctypes.uint16_t, "uint16_t", 2, false, [0, 0xffff]); - run_integer_tests(library, ctypes.uint32_t, "uint32_t", 4, false, [0, 0xffffffff]); - run_integer_tests(library, ctypes.short, "short", 2, true, [-0x8000, 0x7fff]); - run_integer_tests(library, ctypes.unsigned_short, "unsigned_short", 2, false, [0, 0xffff]); - run_integer_tests(library, ctypes.int, "int", 4, true, [-0x80000000, 0x7fffffff]); - run_integer_tests(library, ctypes.unsigned_int, "unsigned_int", 4, false, [0, 0xffffffff]); - run_integer_tests(library, ctypes.unsigned, "unsigned_int", 4, false, [0, 0xffffffff]); - - run_float_tests(library, ctypes.float32_t, "float32_t", 4); - run_float_tests(library, ctypes.float64_t, "float64_t", 8); - run_float_tests(library, ctypes.float, "float", 4); - run_float_tests(library, ctypes.double, "double", 8); - - // Test the wrapped integer types. - s64limits = ["-9223372036854775808", "9223372036854775807", - "-9223372036854775809", "9223372036854775808"]; - u64limits = ["0", "18446744073709551615", "-1", "18446744073709551616"]; - - run_wrapped_integer_tests(library, ctypes.int64_t, "int64_t", 8, true, - ctypes.Int64, "ctypes.Int64", s64limits); - run_wrapped_integer_tests(library, ctypes.uint64_t, "uint64_t", 8, false, - ctypes.UInt64, "ctypes.UInt64", u64limits); - run_wrapped_integer_tests(library, ctypes.long_long, "long_long", 8, true, - ctypes.Int64, "ctypes.Int64", s64limits); - run_wrapped_integer_tests(library, ctypes.unsigned_long_long, "unsigned_long_long", 8, false, - ctypes.UInt64, "ctypes.UInt64", u64limits); - - s32limits = [-0x80000000, 0x7fffffff, -0x80000001, 0x80000000]; - u32limits = [0, 0xffffffff, -1, 0x100000000]; - - let slimits, ulimits; - if (ctypes.long.size == 8) { - slimits = s64limits; - ulimits = u64limits; - } else if (ctypes.long.size == 4) { - slimits = s32limits; - ulimits = u32limits; - } else { - do_throw("ctypes.long is not 4 or 8 bytes"); - } - - run_wrapped_integer_tests(library, ctypes.long, "long", ctypes.long.size, true, - ctypes.Int64, "ctypes.Int64", slimits); - run_wrapped_integer_tests(library, ctypes.unsigned_long, "unsigned_long", ctypes.long.size, false, - ctypes.UInt64, "ctypes.UInt64", ulimits); - - if (ctypes.size_t.size == 8) { - slimits = s64limits; - ulimits = u64limits; - } else if (ctypes.size_t.size == 4) { - slimits = s32limits; - ulimits = u32limits; - } else { - do_throw("ctypes.size_t is not 4 or 8 bytes"); - } - - run_wrapped_integer_tests(library, ctypes.size_t, "size_t", ctypes.size_t.size, false, - ctypes.UInt64, "ctypes.UInt64", ulimits); - run_wrapped_integer_tests(library, ctypes.ssize_t, "ssize_t", ctypes.size_t.size, true, - ctypes.Int64, "ctypes.Int64", slimits); - run_wrapped_integer_tests(library, ctypes.uintptr_t, "uintptr_t", ctypes.size_t.size, false, - ctypes.UInt64, "ctypes.UInt64", ulimits); - run_wrapped_integer_tests(library, ctypes.intptr_t, "intptr_t", ctypes.size_t.size, true, - ctypes.Int64, "ctypes.Int64", slimits); - - if (ctypes.off_t.size == 8) { - slimits = s64limits; - ulimits = u64limits; - } else if (ctypes.off_t.size == 4) { - slimits = s32limits; - ulimits = u32limits; - } else { - do_throw("ctypes.off_t is not 4 or 8 bytes"); - } - run_wrapped_integer_tests(library, ctypes.off_t, "off_t", ctypes.off_t.size, true, - ctypes.Int64, "ctypes.Int64", slimits); - - // Test the character types. - run_char_tests(library, ctypes.char, "char", 1, true, [-0x80, 0x7f]); - run_char_tests(library, ctypes.signed_char, "signed_char", 1, true, [-0x80, 0x7f]); - run_char_tests(library, ctypes.unsigned_char, "unsigned_char", 1, false, [0, 0xff]); - run_char16_tests(library, ctypes.char16_t, "char16_t", [0, 0xffff]); - - // Test the special types. - run_StructType_tests(); - run_PointerType_tests(); - run_FunctionType_tests(); - run_ArrayType_tests(); - - // Check that types print properly. - run_type_toString_tests(); - - // Test the 'name' and 'toSource' of a long typename. - let ptrTo_ptrTo_arrayOf4_ptrTo_int32s = - new ctypes.PointerType( - new ctypes.PointerType( - new ctypes.ArrayType( - new ctypes.PointerType(ctypes.int32_t), 4))); - do_check_eq(ptrTo_ptrTo_arrayOf4_ptrTo_int32s.name, "int32_t*(**)[4]"); - - let source_t = new ctypes.StructType("source", - [{ a: ptrTo_ptrTo_arrayOf4_ptrTo_int32s }, { b: ctypes.int64_t }]); - do_check_eq(source_t.toSource(), - 'ctypes.StructType("source", [{ "a": ctypes.int32_t.ptr.array(4).ptr.ptr }, ' + - '{ "b": ctypes.int64_t }])'); - - // Test ctypes.cast. - run_cast_tests(); - - run_string_tests(library); - run_readstring_tests(library); - run_struct_tests(library); - run_function_tests(library); - run_closure_tests(library); - run_variadic_tests(library); - run_static_data_tests(library); - run_cpp_class_tests(library); - - // test library.close - let test_void_t = library.declare("test_void_t_cdecl", ctypes.default_abi, ctypes.void_t); - library.close(); - do_check_throws(function() { test_void_t(); }, Error); - do_check_throws(function() { - library.declare("test_void_t_cdecl", ctypes.default_abi, ctypes.void_t); - }, Error); - - // test that library functions throw when bound to other objects - library = ctypes.open(libfile.path); - let obj = {}; - obj.declare = library.declare; - do_check_throws(function () { run_void_tests(obj); }, Error); - obj.close = library.close; - do_check_throws(function () { obj.close(); }, Error); - - // test that functions work as properties of other objects - let getter = library.declare("get_int8_t_cdecl", ctypes.default_abi, ctypes.int8_t); - do_check_eq(getter(), 109); - obj.t = getter; - do_check_eq(obj.t(), 109); - - // bug 521937 - do_check_throws(function () { let nolib = ctypes.open("notfoundlibrary.dll"); nolib.close(); }, Error); - - // bug 522360 - do_check_eq(run_load_system_library(), true); - - // Test loading a library with a unicode name (bug 589413). Note that nsIFile - // implementations are not available in some harnesses; if not, the harness - // should take care of the copy for us. - let unicodefile = do_get_file(CTYPES_UNICODE_LIB, true); - let copy = libfile.copyTo instanceof Function; - if (copy) - libfile.copyTo(null, unicodefile.leafName); - library = ctypes.open(unicodefile.path); - run_void_tests(library); - library.close(); - if (copy) - unicodefile.remove(false); -} - -function run_abstract_class_tests() -{ - // Test that ctypes.CType is an abstract constructor that throws. - do_check_throws(function() { ctypes.CType(); }, TypeError); - do_check_throws(function() { new ctypes.CType() }, TypeError); - - do_check_true(ctypes.CType.hasOwnProperty("prototype")); - do_check_throws(function() { ctypes.CType.prototype(); }, TypeError); - do_check_throws(function() { new ctypes.CType.prototype() }, TypeError); - - do_check_true(ctypes.CType.prototype.hasOwnProperty("constructor")); - do_check_true(ctypes.CType.prototype.constructor === ctypes.CType); - - // Check that ctypes.CType.prototype has the correct properties and functions. - do_check_true(ctypes.CType.prototype.hasOwnProperty("name")); - do_check_true(ctypes.CType.prototype.hasOwnProperty("size")); - do_check_true(ctypes.CType.prototype.hasOwnProperty("ptr")); - do_check_true(ctypes.CType.prototype.hasOwnProperty("array")); - do_check_true(ctypes.CType.prototype.hasOwnProperty("toString")); - do_check_true(ctypes.CType.prototype.hasOwnProperty("toSource")); - - // Make sure we can access 'prototype' on a CTypeProto. - do_check_true(ctypes.CType.prototype.prototype === ctypes.CData.prototype); - - // Check that the shared properties and functions on ctypes.CType.prototype throw. - do_check_throws(function() { ctypes.CType.prototype.name; }, TypeError); - do_check_throws(function() { ctypes.CType.prototype.size; }, TypeError); - do_check_throws(function() { ctypes.CType.prototype.ptr; }, TypeError); - do_check_throws(function() { ctypes.CType.prototype.array(); }, TypeError); - - - // toString and toSource are called by the web console during inspection, - // so we don't want them to throw. - do_check_eq(typeof ctypes.CType.prototype.toString(), 'string'); - do_check_eq(typeof ctypes.CType.prototype.toSource(), 'string'); - - // Test that ctypes.CData is an abstract constructor that throws. - do_check_throws(function() { ctypes.CData(); }, TypeError); - do_check_throws(function() { new ctypes.CData() }, TypeError); - - do_check_true(ctypes.CData.__proto__ === ctypes.CType.prototype); - do_check_true(ctypes.CData instanceof ctypes.CType); - - do_check_true(ctypes.CData.hasOwnProperty("prototype")); - do_check_true(ctypes.CData.prototype.hasOwnProperty("constructor")); - do_check_true(ctypes.CData.prototype.constructor === ctypes.CData); - - // Check that ctypes.CData.prototype has the correct properties and functions. - do_check_true(ctypes.CData.prototype.hasOwnProperty("value")); - do_check_true(ctypes.CData.prototype.hasOwnProperty("address")); - do_check_true(ctypes.CData.prototype.hasOwnProperty("readString")); - do_check_true(ctypes.CData.prototype.hasOwnProperty("toString")); - do_check_true(ctypes.CData.prototype.hasOwnProperty("toSource")); - - // Check that the shared properties and functions on ctypes.CData.prototype throw. - do_check_throws(function() { ctypes.CData.prototype.value; }, TypeError); - do_check_throws(function() { ctypes.CData.prototype.value = null; }, TypeError); - do_check_throws(function() { ctypes.CData.prototype.address(); }, TypeError); - do_check_throws(function() { ctypes.CData.prototype.readString(); }, TypeError); - - // toString and toSource are called by the web console during inspection, - // so we don't want them to throw. - do_check_eq(ctypes.CData.prototype.toString(), '[CData proto object]'); - do_check_eq(ctypes.CData.prototype.toSource(), '[CData proto object]'); -} - -function run_Int64_tests() { - do_check_throws(function() { ctypes.Int64(); }, TypeError); - - do_check_true(ctypes.Int64.hasOwnProperty("prototype")); - do_check_true(ctypes.Int64.prototype.hasOwnProperty("constructor")); - do_check_true(ctypes.Int64.prototype.constructor === ctypes.Int64); - - // Check that ctypes.Int64 and ctypes.Int64.prototype have the correct - // properties and functions. - do_check_true(ctypes.Int64.hasOwnProperty("compare")); - do_check_true(ctypes.Int64.hasOwnProperty("lo")); - do_check_true(ctypes.Int64.hasOwnProperty("hi")); - do_check_true(ctypes.Int64.hasOwnProperty("join")); - do_check_true(ctypes.Int64.prototype.hasOwnProperty("toString")); - do_check_true(ctypes.Int64.prototype.hasOwnProperty("toSource")); - - // Check that the shared functions on ctypes.Int64.prototype throw. - do_check_throws(function() { ctypes.Int64.prototype.toString(); }, TypeError); - do_check_throws(function() { ctypes.Int64.prototype.toSource(); }, TypeError); - - let int64 = ctypes.Int64(0); - do_check_true(int64.__proto__ === ctypes.Int64.prototype); - do_check_true(int64 instanceof ctypes.Int64); - - // Test Int64.toString([radix]). - do_check_eq(int64.toString(), "0"); - for (let radix = 2; radix <= 36; ++radix) - do_check_eq(int64.toString(radix), "0"); - do_check_throws(function() { int64.toString(0); }, RangeError); - do_check_throws(function() { int64.toString(1); }, RangeError); - do_check_throws(function() { int64.toString(37); }, RangeError); - do_check_throws(function() { int64.toString(10, 2); }, TypeError); - - // Test Int64.toSource(). - do_check_eq(int64.toSource(), "ctypes.Int64(\"0\")"); - do_check_throws(function() { int64.toSource(10); }, TypeError); - - int64 = ctypes.Int64("0x28590a1c921def71"); - do_check_eq(int64.toString(), int64.toString(10)); - do_check_eq(int64.toString(10), "2907366152271163249"); - do_check_eq(int64.toString(16), "28590a1c921def71"); - do_check_eq(int64.toString(2), "10100001011001000010100001110010010010000111011110111101110001"); - do_check_eq(int64.toSource(), "ctypes.Int64(\"" + int64.toString(10) + "\")"); - - int64 = ctypes.Int64("-0x28590a1c921def71"); - do_check_eq(int64.toString(), int64.toString(10)); - do_check_eq(int64.toString(10), "-2907366152271163249"); - do_check_eq(int64.toString(16), "-28590a1c921def71"); - do_check_eq(int64.toString(2), "-10100001011001000010100001110010010010000111011110111101110001"); - do_check_eq(int64.toSource(), "ctypes.Int64(\"" + int64.toString(10) + "\")"); - - int64 = ctypes.Int64("-0X28590A1c921DEf71"); - do_check_eq(int64.toString(), int64.toString(10)); - do_check_eq(int64.toString(10), "-2907366152271163249"); - do_check_eq(int64.toString(16), "-28590a1c921def71"); - do_check_eq(int64.toString(2), "-10100001011001000010100001110010010010000111011110111101110001"); - do_check_eq(int64.toSource(), "ctypes.Int64(\"" + int64.toString(10) + "\")"); - - // Test Int64(primitive double) constructor. - int64 = ctypes.Int64(-0); - do_check_eq(int64.toString(), "0"); - - int64 = ctypes.Int64(0x7ffffffffffff000); - do_check_eq(int64.toString(), int64.toString(10)); - do_check_eq(int64.toString(10), "9223372036854771712"); - do_check_eq(int64.toString(16), "7ffffffffffff000"); - do_check_eq(int64.toString(2), "111111111111111111111111111111111111111111111111111000000000000"); - - int64 = ctypes.Int64(-0x8000000000000000); - do_check_eq(int64.toString(), int64.toString(10)); - do_check_eq(int64.toString(10), "-9223372036854775808"); - do_check_eq(int64.toString(16), "-8000000000000000"); - do_check_eq(int64.toString(2), "-1000000000000000000000000000000000000000000000000000000000000000"); - - // Test Int64(string) constructor. - int64 = ctypes.Int64("0x7fffffffffffffff"); - do_check_eq(int64.toString(), int64.toString(10)); - do_check_eq(int64.toString(10), "9223372036854775807"); - do_check_eq(int64.toString(16), "7fffffffffffffff"); - do_check_eq(int64.toString(2), "111111111111111111111111111111111111111111111111111111111111111"); - - int64 = ctypes.Int64("-0x8000000000000000"); - do_check_eq(int64.toString(), int64.toString(10)); - do_check_eq(int64.toString(10), "-9223372036854775808"); - do_check_eq(int64.toString(16), "-8000000000000000"); - do_check_eq(int64.toString(2), "-1000000000000000000000000000000000000000000000000000000000000000"); - - int64 = ctypes.Int64("9223372036854775807"); - do_check_eq(int64.toString(), int64.toString(10)); - do_check_eq(int64.toString(10), "9223372036854775807"); - do_check_eq(int64.toString(16), "7fffffffffffffff"); - do_check_eq(int64.toString(2), "111111111111111111111111111111111111111111111111111111111111111"); - - int64 = ctypes.Int64("-9223372036854775808"); - do_check_eq(int64.toString(), int64.toString(10)); - do_check_eq(int64.toString(10), "-9223372036854775808"); - do_check_eq(int64.toString(16), "-8000000000000000"); - do_check_eq(int64.toString(2), "-1000000000000000000000000000000000000000000000000000000000000000"); - - // Test Int64(other Int64) constructor. - int64 = ctypes.Int64(ctypes.Int64(0)); - do_check_eq(int64.toString(), "0"); - - int64 = ctypes.Int64(ctypes.Int64("0x7fffffffffffffff")); - do_check_eq(int64.toString(), int64.toString(10)); - do_check_eq(int64.toString(10), "9223372036854775807"); - do_check_eq(int64.toString(16), "7fffffffffffffff"); - do_check_eq(int64.toString(2), "111111111111111111111111111111111111111111111111111111111111111"); - - int64 = ctypes.Int64(ctypes.Int64("-0x8000000000000000")); - do_check_eq(int64.toString(), int64.toString(10)); - do_check_eq(int64.toString(10), "-9223372036854775808"); - do_check_eq(int64.toString(16), "-8000000000000000"); - do_check_eq(int64.toString(2), "-1000000000000000000000000000000000000000000000000000000000000000"); - - // Test Int64(other UInt64) constructor. - int64 = ctypes.Int64(ctypes.UInt64(0)); - do_check_eq(int64.toString(), "0"); - - int64 = ctypes.Int64(ctypes.UInt64("0x7fffffffffffffff")); - do_check_eq(int64.toString(), int64.toString(10)); - do_check_eq(int64.toString(10), "9223372036854775807"); - do_check_eq(int64.toString(16), "7fffffffffffffff"); - do_check_eq(int64.toString(2), "111111111111111111111111111111111111111111111111111111111111111"); - - let vals = [-0x8000000000001000, 0x8000000000000000, - ctypes.UInt64("0x8000000000000000"), - Infinity, -Infinity, NaN, 0.1, - 5.68e21, null, undefined, "", {}, [], new Number(16), - {toString: function () { return 7; }}, - {valueOf: function () { return 7; }}]; - for (let i = 0; i < vals.length; i++) - do_check_throws(function () { ctypes.Int64(vals[i]); }, TypeError); - - vals = ["-0x8000000000000001", "0x8000000000000000"]; - for (let i = 0; i < vals.length; i++) - do_check_throws(function () { ctypes.Int64(vals[i]); }, RangeError); - - // Test ctypes.Int64.compare. - do_check_eq(ctypes.Int64.compare(ctypes.Int64(5), ctypes.Int64(5)), 0); - do_check_eq(ctypes.Int64.compare(ctypes.Int64(5), ctypes.Int64(4)), 1); - do_check_eq(ctypes.Int64.compare(ctypes.Int64(4), ctypes.Int64(5)), -1); - do_check_eq(ctypes.Int64.compare(ctypes.Int64(-5), ctypes.Int64(-5)), 0); - do_check_eq(ctypes.Int64.compare(ctypes.Int64(-5), ctypes.Int64(-4)), -1); - do_check_eq(ctypes.Int64.compare(ctypes.Int64(-4), ctypes.Int64(-5)), 1); - do_check_throws(function() { ctypes.Int64.compare(ctypes.Int64(4), ctypes.UInt64(4)); }, TypeError); - do_check_throws(function() { ctypes.Int64.compare(4, 5); }, TypeError); - - // Test ctypes.Int64.{lo,hi}. - do_check_eq(ctypes.Int64.lo(ctypes.Int64(0x28590a1c921de000)), 0x921de000); - do_check_eq(ctypes.Int64.hi(ctypes.Int64(0x28590a1c921de000)), 0x28590a1c); - do_check_eq(ctypes.Int64.lo(ctypes.Int64(-0x28590a1c921de000)), 0x6de22000); - do_check_eq(ctypes.Int64.hi(ctypes.Int64(-0x28590a1c921de000)), -0x28590a1d); - do_check_throws(function() { ctypes.Int64.lo(ctypes.UInt64(0)); }, TypeError); - do_check_throws(function() { ctypes.Int64.hi(ctypes.UInt64(0)); }, TypeError); - do_check_throws(function() { ctypes.Int64.lo(0); }, TypeError); - do_check_throws(function() { ctypes.Int64.hi(0); }, TypeError); - - // Test ctypes.Int64.join. - do_check_eq(ctypes.Int64.join(0, 0).toString(), "0"); - do_check_eq(ctypes.Int64.join(0x28590a1c, 0x921de000).toString(16), "28590a1c921de000"); - do_check_eq(ctypes.Int64.join(-0x28590a1d, 0x6de22000).toString(16), "-28590a1c921de000"); - do_check_eq(ctypes.Int64.join(0x7fffffff, 0xffffffff).toString(16), "7fffffffffffffff"); - do_check_eq(ctypes.Int64.join(-0x80000000, 0x00000000).toString(16), "-8000000000000000"); - do_check_throws(function() { ctypes.Int64.join(-0x80000001, 0); }, TypeError); - do_check_throws(function() { ctypes.Int64.join(0x80000000, 0); }, TypeError); - do_check_throws(function() { ctypes.Int64.join(0, -0x1); }, TypeError); - do_check_throws(function() { ctypes.Int64.join(0, 0x800000000); }, TypeError); -} - -function run_UInt64_tests() { - do_check_throws(function() { ctypes.UInt64(); }, TypeError); - - do_check_true(ctypes.UInt64.hasOwnProperty("prototype")); - do_check_true(ctypes.UInt64.prototype.hasOwnProperty("constructor")); - do_check_true(ctypes.UInt64.prototype.constructor === ctypes.UInt64); - - // Check that ctypes.UInt64 and ctypes.UInt64.prototype have the correct - // properties and functions. - do_check_true(ctypes.UInt64.hasOwnProperty("compare")); - do_check_true(ctypes.UInt64.hasOwnProperty("lo")); - do_check_true(ctypes.UInt64.hasOwnProperty("hi")); - do_check_true(ctypes.UInt64.hasOwnProperty("join")); - do_check_true(ctypes.UInt64.prototype.hasOwnProperty("toString")); - do_check_true(ctypes.UInt64.prototype.hasOwnProperty("toSource")); - - // Check that the shared functions on ctypes.UInt64.prototype throw. - do_check_throws(function() { ctypes.UInt64.prototype.toString(); }, TypeError); - do_check_throws(function() { ctypes.UInt64.prototype.toSource(); }, TypeError); - - let uint64 = ctypes.UInt64(0); - do_check_true(uint64.__proto__ === ctypes.UInt64.prototype); - do_check_true(uint64 instanceof ctypes.UInt64); - - // Test UInt64.toString([radix]). - do_check_eq(uint64.toString(), "0"); - for (let radix = 2; radix <= 36; ++radix) - do_check_eq(uint64.toString(radix), "0"); - do_check_throws(function() { uint64.toString(0); }, RangeError); - do_check_throws(function() { uint64.toString(1); }, RangeError); - do_check_throws(function() { uint64.toString(37); }, RangeError); - do_check_throws(function() { uint64.toString(10, 2); }, TypeError); - - // Test UInt64.toSource(). - do_check_eq(uint64.toSource(), "ctypes.UInt64(\"0\")"); - do_check_throws(function() { uint64.toSource(10); }, TypeError); - - uint64 = ctypes.UInt64("0x28590a1c921def71"); - do_check_eq(uint64.toString(), uint64.toString(10)); - do_check_eq(uint64.toString(10), "2907366152271163249"); - do_check_eq(uint64.toString(16), "28590a1c921def71"); - do_check_eq(uint64.toString(2), "10100001011001000010100001110010010010000111011110111101110001"); - do_check_eq(uint64.toSource(), "ctypes.UInt64(\"" + uint64.toString(10) + "\")"); - - uint64 = ctypes.UInt64("0X28590A1c921DEf71"); - do_check_eq(uint64.toString(), uint64.toString(10)); - do_check_eq(uint64.toString(10), "2907366152271163249"); - do_check_eq(uint64.toString(16), "28590a1c921def71"); - do_check_eq(uint64.toString(2), "10100001011001000010100001110010010010000111011110111101110001"); - do_check_eq(uint64.toSource(), "ctypes.UInt64(\"" + uint64.toString(10) + "\")"); - - // Test UInt64(primitive double) constructor. - uint64 = ctypes.UInt64(-0); - do_check_eq(uint64.toString(), "0"); - - uint64 = ctypes.UInt64(0xfffffffffffff000); - do_check_eq(uint64.toString(), uint64.toString(10)); - do_check_eq(uint64.toString(10), "18446744073709547520"); - do_check_eq(uint64.toString(16), "fffffffffffff000"); - do_check_eq(uint64.toString(2), "1111111111111111111111111111111111111111111111111111000000000000"); - - // Test UInt64(string) constructor. - uint64 = ctypes.UInt64("0xffffffffffffffff"); - do_check_eq(uint64.toString(), uint64.toString(10)); - do_check_eq(uint64.toString(10), "18446744073709551615"); - do_check_eq(uint64.toString(16), "ffffffffffffffff"); - do_check_eq(uint64.toString(2), "1111111111111111111111111111111111111111111111111111111111111111"); - - uint64 = ctypes.UInt64("0x0"); - do_check_eq(uint64.toString(), uint64.toString(10)); - do_check_eq(uint64.toString(10), "0"); - do_check_eq(uint64.toString(16), "0"); - do_check_eq(uint64.toString(2), "0"); - - uint64 = ctypes.UInt64("18446744073709551615"); - do_check_eq(uint64.toString(), uint64.toString(10)); - do_check_eq(uint64.toString(10), "18446744073709551615"); - do_check_eq(uint64.toString(16), "ffffffffffffffff"); - do_check_eq(uint64.toString(2), "1111111111111111111111111111111111111111111111111111111111111111"); - - uint64 = ctypes.UInt64("0"); - do_check_eq(uint64.toString(), "0"); - - // Test UInt64(other UInt64) constructor. - uint64 = ctypes.UInt64(ctypes.UInt64(0)); - do_check_eq(uint64.toString(), "0"); - - uint64 = ctypes.UInt64(ctypes.UInt64("0xffffffffffffffff")); - do_check_eq(uint64.toString(), uint64.toString(10)); - do_check_eq(uint64.toString(10), "18446744073709551615"); - do_check_eq(uint64.toString(16), "ffffffffffffffff"); - do_check_eq(uint64.toString(2), "1111111111111111111111111111111111111111111111111111111111111111"); - - uint64 = ctypes.UInt64(ctypes.UInt64("0x0")); - do_check_eq(uint64.toString(), "0"); - - // Test UInt64(other Int64) constructor. - uint64 = ctypes.UInt64(ctypes.Int64(0)); - do_check_eq(uint64.toString(), "0"); - - uint64 = ctypes.UInt64(ctypes.Int64("0x7fffffffffffffff")); - do_check_eq(uint64.toString(), uint64.toString(10)); - do_check_eq(uint64.toString(10), "9223372036854775807"); - do_check_eq(uint64.toString(16), "7fffffffffffffff"); - do_check_eq(uint64.toString(2), "111111111111111111111111111111111111111111111111111111111111111"); - - let vals = [-1, 0x10000000000000000, "-1", "-0x1", - ctypes.Int64("-1"), Infinity, -Infinity, NaN, 0.1, - 5.68e21, null, undefined, "", {}, [], new Number(16), - {toString: function () { return 7; }}, - {valueOf: function () { return 7; }}]; - for (let i = 0; i < vals.length; i++) - do_check_throws(function () { ctypes.UInt64(vals[i]); }, TypeError); - - vals = ["0x10000000000000000"]; - for (let i = 0; i < vals.length; i++) - do_check_throws(function () { ctypes.UInt64(vals[i]); }, RangeError); - - // Test ctypes.UInt64.compare. - do_check_eq(ctypes.UInt64.compare(ctypes.UInt64(5), ctypes.UInt64(5)), 0); - do_check_eq(ctypes.UInt64.compare(ctypes.UInt64(5), ctypes.UInt64(4)), 1); - do_check_eq(ctypes.UInt64.compare(ctypes.UInt64(4), ctypes.UInt64(5)), -1); - do_check_throws(function() { ctypes.UInt64.compare(ctypes.UInt64(4), ctypes.Int64(4)); }, TypeError); - do_check_throws(function() { ctypes.UInt64.compare(4, 5); }, TypeError); - - // Test ctypes.UInt64.{lo,hi}. - do_check_eq(ctypes.UInt64.lo(ctypes.UInt64(0x28590a1c921de000)), 0x921de000); - do_check_eq(ctypes.UInt64.hi(ctypes.UInt64(0x28590a1c921de000)), 0x28590a1c); - do_check_eq(ctypes.UInt64.lo(ctypes.UInt64(0xa8590a1c921de000)), 0x921de000); - do_check_eq(ctypes.UInt64.hi(ctypes.UInt64(0xa8590a1c921de000)), 0xa8590a1c); - do_check_throws(function() { ctypes.UInt64.lo(ctypes.Int64(0)); }, TypeError); - do_check_throws(function() { ctypes.UInt64.hi(ctypes.Int64(0)); }, TypeError); - do_check_throws(function() { ctypes.UInt64.lo(0); }, TypeError); - do_check_throws(function() { ctypes.UInt64.hi(0); }, TypeError); - - // Test ctypes.UInt64.join. - do_check_eq(ctypes.UInt64.join(0, 0).toString(), "0"); - do_check_eq(ctypes.UInt64.join(0x28590a1c, 0x921de000).toString(16), "28590a1c921de000"); - do_check_eq(ctypes.UInt64.join(0xa8590a1c, 0x921de000).toString(16), "a8590a1c921de000"); - do_check_eq(ctypes.UInt64.join(0xffffffff, 0xffffffff).toString(16), "ffffffffffffffff"); - do_check_eq(ctypes.UInt64.join(0, 0).toString(16), "0"); - do_check_throws(function() { ctypes.UInt64.join(-0x1, 0); }, TypeError); - do_check_throws(function() { ctypes.UInt64.join(0x100000000, 0); }, TypeError); - do_check_throws(function() { ctypes.UInt64.join(0, -0x1); }, TypeError); - do_check_throws(function() { ctypes.UInt64.join(0, 0x1000000000); }, TypeError); -} - -function run_basic_abi_tests(library, t, name, toprimitive, - get_test, set_tests, sum_tests, sum_many_tests) { - // Test the function call ABI for calls involving the type. - function declare_fn_cdecl(fn_t, prefix) { - return library.declare(prefix + name + "_cdecl", fn_t); - } - run_single_abi_tests(declare_fn_cdecl, ctypes.default_abi, t, - toprimitive, get_test, set_tests, sum_tests, sum_many_tests); - - if ("winLastError" in ctypes) { - function declare_fn_stdcall(fn_t, prefix) { - return library.declare(prefix + name + "_stdcall", fn_t); - } - run_single_abi_tests(declare_fn_stdcall, ctypes.stdcall_abi, t, - toprimitive, get_test, set_tests, sum_tests, sum_many_tests); - - // Check that declaring a WINAPI function gets the right symbol name. - let libuser32 = ctypes.open("user32.dll"); - let charupper = libuser32.declare("CharUpperA", - ctypes.winapi_abi, - ctypes.char.ptr, - ctypes.char.ptr); - let hello = ctypes.char.array()("hello!"); - do_check_eq(charupper(hello).readString(), "HELLO!"); - } - - // Check the alignment of the type, and its behavior in a struct, - // against what C says. - check_struct_stats(library, t); - - // Check the ToSource functions defined in the namespace ABI - do_check_eq(ctypes.default_abi.toSource(), "ctypes.default_abi"); - - let exn; - try { - ctypes.default_abi.toSource.call(null); - } catch (x) { - exn = x; - } - do_check_true(!!exn); // Check that some exception was raised -} - -function run_single_abi_tests(decl, abi, t, toprimitive, - get_test, set_tests, sum_tests, sum_many_tests) { - let getter_t = ctypes.FunctionType(abi, t).ptr; - let getter = decl(getter_t, "get_"); - do_check_eq(toprimitive(getter()), get_test); - - let setter_t = ctypes.FunctionType(abi, t, [t]).ptr; - let setter = decl(setter_t, "set_"); - for (let i of set_tests) - do_check_eq(toprimitive(setter(i)), i); - - let sum_t = ctypes.FunctionType(abi, t, [t, t]).ptr; - let sum = decl(sum_t, "sum_"); - for (let a of sum_tests) - do_check_eq(toprimitive(sum(a[0], a[1])), a[2]); - - let sum_alignb_t = ctypes.FunctionType(abi, t, - [ctypes.char, t, ctypes.char, t, ctypes.char]).ptr; - let sum_alignb = decl(sum_alignb_t, "sum_alignb_"); - let sum_alignf_t = ctypes.FunctionType(abi, t, - [ctypes.float, t, ctypes.float, t, ctypes.float]).ptr; - let sum_alignf = decl(sum_alignf_t, "sum_alignf_"); - for (let a of sum_tests) { - do_check_eq(toprimitive(sum_alignb(0, a[0], 0, a[1], 0)), a[2]); - do_check_eq(toprimitive(sum_alignb(1, a[0], 1, a[1], 1)), a[2]); - do_check_eq(toprimitive(sum_alignf(0, a[0], 0, a[1], 0)), a[2]); - do_check_eq(toprimitive(sum_alignf(1, a[0], 1, a[1], 1)), a[2]); - } - - let sum_many_t = ctypes.FunctionType(abi, t, - [t, t, t, t, t, t, t, t, t, t, t, t, t, t, t, t, t, t]).ptr; - let sum_many = decl(sum_many_t, "sum_many_"); - for (let a of sum_many_tests) - do_check_eq( - toprimitive(sum_many(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], - a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15], - a[16], a[17])), a[18]); -} - -function check_struct_stats(library, t) { - let s_t = ctypes.StructType("s_t", [{ x: ctypes.char }, { y: t }]); - let n_t = ctypes.StructType("n_t", [{ a: ctypes.char }, { b: s_t }, { c: ctypes.char }]); - let get_stats = library.declare("get_" + t.name + "_stats", - ctypes.default_abi, ctypes.void_t, - ctypes.size_t.ptr, ctypes.size_t.ptr, ctypes.size_t.ptr, ctypes.size_t.ptr, - ctypes.size_t.array()); - - let align = ctypes.size_t(); - let size = ctypes.size_t(); - let nalign = ctypes.size_t(); - let nsize = ctypes.size_t(); - let offsets = ctypes.size_t.array(3)(); - get_stats(align.address(), size.address(), nalign.address(), nsize.address(), - offsets); - - do_check_eq(size.value, s_t.size); - do_check_eq(align.value, s_t.size - t.size); - do_check_eq(align.value, offsetof(s_t, "y")); - do_check_eq(nsize.value, n_t.size); - do_check_eq(nalign.value, offsetof(n_t, "b")); - do_check_eq(offsets[0], offsetof(s_t, "y")); - do_check_eq(offsets[1], offsetof(n_t, "b")); - do_check_eq(offsets[2], offsetof(n_t, "c")); -} - -// Determine the offset, in bytes, of 'member' within 'struct'. -function offsetof(struct, member) { - let instance = struct(); - let memberptr = ptrValue(instance.addressOfField(member)); - let chararray = ctypes.cast(instance, ctypes.char.array(struct.size)); - let offset = 0; - while (memberptr != ptrValue(chararray.addressOfElement(offset))) - ++offset; - return offset; -} - -// Test the class and prototype hierarchy for a given basic type 't'. -function run_basic_class_tests(t) -{ - do_check_true(t.__proto__ === ctypes.CType.prototype); - do_check_true(t instanceof ctypes.CType); - - do_check_true(t.prototype.__proto__ === ctypes.CData.prototype); - do_check_true(t.prototype instanceof ctypes.CData); - do_check_true(t.prototype.constructor === t); - - // Check that the shared properties and functions on 't.prototype' throw. - do_check_throws(function() { t.prototype.value; }, TypeError); - do_check_throws(function() { t.prototype.value = null; }, TypeError); - do_check_throws(function() { t.prototype.address(); }, TypeError); - do_check_throws(function() { t.prototype.readString(); }, TypeError); - - // toString and toSource are called by the web console during inspection, - // so we don't want them to throw. - do_check_eq(t.prototype.toString(), '[CData proto object]'); - do_check_eq(t.prototype.toSource(), '[CData proto object]'); - - // Test that an instance 'd' of 't' is a CData. - let d = t(); - do_check_true(d.__proto__ === t.prototype); - do_check_true(d instanceof t); - do_check_true(d.constructor === t); -} - -function run_bool_tests(library) { - let t = ctypes.bool; - run_basic_class_tests(t); - - let name = "bool"; - do_check_eq(t.name, name); - do_check_true(t.size == 1 || t.size == 4); - - do_check_eq(t.toString(), "type " + name); - do_check_eq(t.toSource(), "ctypes." + name); - do_check_true(t.ptr === ctypes.PointerType(t)); - do_check_eq(t.array().name, name + "[]"); - do_check_eq(t.array(5).name, name + "[5]"); - - let d = t(); - do_check_eq(d.value, 0); - d.value = 1; - do_check_eq(d.value, 1); - d.value = -0; - do_check_eq(1/d.value, 1/0); - d.value = false; - do_check_eq(d.value, 0); - d.value = true; - do_check_eq(d.value, 1); - d = new t(1); - do_check_eq(d.value, 1); - - // don't convert anything else - let vals = [-1, 2, Infinity, -Infinity, NaN, 0.1, - ctypes.Int64(0), ctypes.UInt64(0), - null, undefined, "", "0", {}, [], new Number(16), - {toString: function () { return 7; }}, - {valueOf: function () { return 7; }}]; - for (let i = 0; i < vals.length; i++) - do_check_throws(function () { d.value = vals[i]; }, TypeError); - - do_check_true(d.address().constructor === t.ptr); - do_check_eq(d.address().contents, d.value); - do_check_eq(d.toSource(), "ctypes." + name + "(" + d.value + ")"); - do_check_eq(d.toSource(), d.toString()); - - // Test the function call ABI for calls involving the type, - // and check the alignment of the type against what C says. - function toprimitive(a) { return a; } - run_basic_abi_tests(library, t, name, toprimitive, - true, - [ false, true ], - [ [ false, false, false ], [ false, true, true ], - [ true, false, true ], [true, true, true ] ], - [ [ false, false, false, false, false, false, false, false, false, - false, false, false, false, false, false, false, false, false, - false ], - [ true, true, true, true, true, true, true, true, true, - true, true, true, true, true, true, true, true, true, - true ] ]); -} - -function run_integer_tests(library, t, name, size, signed, limits) { - run_basic_class_tests(t); - - do_check_eq(t.name, name); - do_check_eq(t.size, size); - - do_check_eq(t.toString(), "type " + name); - do_check_eq(t.toSource(), "ctypes." + name); - do_check_true(t.ptr === ctypes.PointerType(t)); - do_check_eq(t.array().name, name + "[]"); - do_check_eq(t.array(5).name, name + "[5]"); - - // Check the alignment of the type, and its behavior in a struct, - // against what C says. - check_struct_stats(library, t); - - let d = t(); - do_check_eq(d.value, 0); - d.value = 5; - do_check_eq(d.value, 5); - d = t(10); - do_check_eq(d.value, 10); - if (signed) { - d.value = -10; - do_check_eq(d.value, -10); - } - d = new t(20); - do_check_eq(d.value, 20); - - d.value = ctypes.Int64(5); - do_check_eq(d.value, 5); - if (signed) { - d.value = ctypes.Int64(-5); - do_check_eq(d.value, -5); - } - d.value = ctypes.UInt64(5); - do_check_eq(d.value, 5); - - d.value = limits[0]; - do_check_eq(d.value, limits[0]); - d.value = limits[1]; - do_check_eq(d.value, limits[1]); - d.value = 0; - do_check_eq(d.value, 0); - d.value = -0; - do_check_eq(1/d.value, 1/0); - d.value = false; - do_check_eq(d.value, 0); - d.value = true; - do_check_eq(d.value, 1); - - // don't convert anything else - let vals = [limits[0] - 1, limits[1] + 1, Infinity, -Infinity, NaN, 0.1, - null, undefined, "", "0", {}, [], new Number(16), - {toString: function () { return 7; }}, - {valueOf: function () { return 7; }}]; - for (let i = 0; i < vals.length; i++) - do_check_throws(function () { d.value = vals[i]; }, TypeError); - - do_check_true(d.address().constructor === t.ptr); - do_check_eq(d.address().contents, d.value); - do_check_eq(d.toSource(), "ctypes." + name + "(" + d.value + ")"); - do_check_eq(d.toSource(), d.toString()); - - // Test the function call ABI for calls involving the type, - // and check the alignment of the type against what C says. - function toprimitive(a) { return a; } - run_basic_abi_tests(library, t, name, toprimitive, - 109, - [ 0, limits[0], limits[1] ], - [ [ 0, 0, 0 ], [ 0, 1, 1 ], [ 1, 0, 1 ], [ 1, 1, 2 ], - [ limits[0], 1, limits[0] + 1 ], - [ limits[1], 1, limits[0] ] ], - [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0 ], - [ 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, - 18 ] ]); -} - -function run_float_tests(library, t, name, size) { - run_basic_class_tests(t); - - do_check_eq(t.name, name); - do_check_eq(t.size, size); - - do_check_eq(t.toString(), "type " + name); - do_check_eq(t.toSource(), "ctypes." + name); - do_check_true(t.ptr === ctypes.PointerType(t)); - do_check_eq(t.array().name, name + "[]"); - do_check_eq(t.array(5).name, name + "[5]"); - - let d = t(); - do_check_eq(d.value, 0); - d.value = 5; - do_check_eq(d.value, 5); - d.value = 5.25; - do_check_eq(d.value, 5.25); - d = t(10); - do_check_eq(d.value, 10); - d.value = -10; - do_check_eq(d.value, -10); - d = new t(20); - do_check_eq(d.value, 20); - - do_check_throws(function() { d.value = ctypes.Int64(5); }, TypeError); - do_check_throws(function() { d.value = ctypes.Int64(-5); }, TypeError); - do_check_throws(function() { d.value = ctypes.UInt64(5); }, TypeError); - - if (size == 4) { - d.value = 0x7fffff; - do_check_eq(d.value, 0x7fffff); - - // allow values that can't be represented precisely as a float - d.value = 0xffffffff; - let delta = 1 - d.value/0xffffffff; - do_check_true(delta != 0); - do_check_true(delta > -0.01 && delta < 0.01); - d.value = 1 + 1/0x80000000; - do_check_eq(d.value, 1); - } else { - d.value = 0xfffffffffffff000; - do_check_eq(d.value, 0xfffffffffffff000); - - do_check_throws(function() { d.value = ctypes.Int64("0x7fffffffffffffff"); }, TypeError); - } - - d.value = Infinity; - do_check_eq(d.value, Infinity); - d.value = -Infinity; - do_check_eq(d.value, -Infinity); - d.value = NaN; - do_check_true(isNaN(d.value)); - d.value = 0; - do_check_eq(d.value, 0); - d.value = -0; - do_check_eq(1/d.value, 1/-0); - - // don't convert anything else - let vals = [true, false, null, undefined, "", "0", {}, [], new Number(16), - {toString: function () { return 7; }}, - {valueOf: function () { return 7; }}]; - for (let i = 0; i < vals.length; i++) - do_check_throws(function () { d.value = vals[i]; }, TypeError); - - // Check that values roundtrip through toSource() correctly. - function test_roundtrip(tFn, val) - { - let f1 = tFn(val); - eval("var f2 = " + f1.toSource()); - do_check_eq(f1.value, f2.value); - } - vals = [Infinity, -Infinity, -0, 0, 1, -1, 1/3, -1/3, 1/4, -1/4, - 1e-14, -1e-14, 0xfffffffffffff000, -0xfffffffffffff000]; - for (let i = 0; i < vals.length; i++) - test_roundtrip(t, vals[i]); - do_check_eq(t(NaN).toSource(), t.toSource() + "(NaN)"); - - do_check_true(d.address().constructor === t.ptr); - do_check_eq(d.address().contents, d.value); - do_check_eq(d.toSource(), "ctypes." + name + "(" + d.value + ")"); - do_check_eq(d.toSource(), d.toString()); - - // Test the function call ABI for calls involving the type, - // and check the alignment of the type against what C says. - let operand = []; - if (size == 4) { - operand[0] = 503859.75; - operand[1] = 1012385.25; - operand[2] = 1516245; - } else { - operand[0] = 501823873859.75; - operand[1] = 171290577385.25; - operand[2] = 673114451245; - } - function toprimitive(a) { return a; } - run_basic_abi_tests(library, t, name, toprimitive, - 109.25, - [ 0, operand[0], operand[1] ], - [ [ 0, 0, 0 ], [ 0, 1, 1 ], [ 1, 0, 1 ], [ 1, 1, 2 ], - [ operand[0], operand[1], operand[2] ] ], - [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0 ], - [ 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, - 18 ] ]); -} - -function run_wrapped_integer_tests(library, t, name, size, signed, w, wname, limits) { - run_basic_class_tests(t); - - do_check_eq(t.name, name); - do_check_eq(t.size, size); - - do_check_eq(t.toString(), "type " + name); - do_check_eq(t.toSource(), "ctypes." + name); - do_check_true(t.ptr === ctypes.PointerType(t)); - do_check_eq(t.array().name, name + "[]"); - do_check_eq(t.array(5).name, name + "[5]"); - - let d = t(); - do_check_true(d.value instanceof w); - do_check_eq(d.value, 0); - d.value = 5; - do_check_eq(d.value, 5); - d = t(10); - do_check_eq(d.value, 10); - if (signed) { - d.value = -10; - do_check_eq(d.value, -10); - } - d = new t(20); - do_check_eq(d.value, 20); - - d.value = ctypes.Int64(5); - do_check_eq(d.value, 5); - if (signed) { - d.value = ctypes.Int64(-5); - do_check_eq(d.value, -5); - } - d.value = ctypes.UInt64(5); - do_check_eq(d.value, 5); - - d.value = w(limits[0]); - do_check_eq(d.value, limits[0]); - d.value = w(limits[1]); - do_check_eq(d.value, limits[1]); - d.value = 0; - do_check_eq(d.value, 0); - d.value = -0; - do_check_eq(1/d.value, 1/0); - d.value = false; - do_check_eq(d.value, 0); - d.value = true; - do_check_eq(d.value, 1); - - // don't convert anything else - let vals = [limits[2], limits[3], Infinity, -Infinity, NaN, 0.1, - null, undefined, "", "0", {}, [], new Number(16), - {toString: function () { return 7; }}, - {valueOf: function () { return 7; }}]; - for (let i = 0; i < vals.length; i++) - do_check_throws(function () { d.value = vals[i]; }, TypeError); - - do_check_true(d.address().constructor === t.ptr); - do_check_eq(d.address().contents.toString(), d.value.toString()); - do_check_eq(d.toSource(), "ctypes." + name + "(" + wname + "(\"" + d.value + "\"))"); - do_check_eq(d.toSource(), d.toString()); - - // Test the function call ABI for calls involving the type, - // and check the alignment of the type against what C says. - function toprimitive(a) { return a.toString(); } - run_basic_abi_tests(library, t, name, toprimitive, - 109, - [ 0, w(limits[0]), w(limits[1]) ], - [ [ 0, 0, 0 ], [ 0, 1, 1 ], [ 1, 0, 1 ], [ 1, 1, 2 ], - signed ? [ w(limits[0]), -1, w(limits[1]) ] - : [ w(limits[1]), 1, w(limits[0]) ] ], - [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0 ], - [ 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, - 18 ] ]); -} - -function run_char_tests(library, t, name, size, signed, limits) { - run_basic_class_tests(t); - - do_check_eq(t.name, name); - do_check_eq(t.size, size); - - do_check_eq(t.toString(), "type " + name); - do_check_eq(t.toSource(), "ctypes." + name); - do_check_true(t.ptr === ctypes.PointerType(t)); - do_check_eq(t.array().name, name + "[]"); - do_check_eq(t.array(5).name, name + "[5]"); - - let d = t(); - do_check_eq(d.value, 0); - d.value = 5; - do_check_eq(d.value, 5); - d = t(10); - do_check_eq(d.value, 10); - if (signed) { - d.value = -10; - do_check_eq(d.value, -10); - } else { - do_check_throws(function() { d.value = -10; }, TypeError); - } - d = new t(20); - do_check_eq(d.value, 20); - - function toprimitive(a) { return a; } - - d.value = ctypes.Int64(5); - do_check_eq(d.value, 5); - if (signed) { - d.value = ctypes.Int64(-10); - do_check_eq(d.value, -10); - } - d.value = ctypes.UInt64(5); - do_check_eq(d.value, 5); - - d.value = limits[0]; - do_check_eq(d.value, limits[0]); - d.value = limits[1]; - do_check_eq(d.value, limits[1]); - d.value = 0; - do_check_eq(d.value, 0); - d.value = -0; - do_check_eq(1/d.value, 1/0); - d.value = false; - do_check_eq(d.value, 0); - d.value = true; - do_check_eq(d.value, 1); - - do_check_throws(function() { d.value = "5"; }, TypeError); - - // don't convert anything else - let vals = [limits[0] - 1, limits[1] + 1, Infinity, -Infinity, NaN, 0.1, - null, undefined, "", "aa", {}, [], new Number(16), - {toString: function () { return 7; }}, - {valueOf: function () { return 7; }}]; - for (let i = 0; i < vals.length; i++) - do_check_throws(function () { d.value = vals[i]; }, TypeError); - - do_check_true(d.address().constructor === t.ptr); - do_check_eq(d.address().contents, 1); - do_check_eq(d.toSource(), "ctypes." + name + "(" + d.value + ")"); - do_check_eq(d.toSource(), d.toString()); - - // Test string autoconversion (and lack thereof). - let literal = "autoconverted"; - let s = t.array()(literal); - do_check_eq(s.readString(), literal); - do_check_eq(s.constructor.length, literal.length + 1); - s = t.array(50)(literal); - do_check_eq(s.readString(), literal); - do_check_throws(function() { t.array(3)(literal); }, TypeError); - - do_check_throws(function() { t.ptr(literal); }, TypeError); - let p = t.ptr(s); - do_check_eq(p.readString(), literal); - - // Test the function call ABI for calls involving the type, - // and check the alignment of the type against what C says. - run_basic_abi_tests(library, t, name, toprimitive, - 109, - [ 0, limits[0], limits[1] ], - [ [ 0, 0, 0 ], [ 0, 1, 1 ], [ 1, 0, 1 ], [ 1, 1, 2 ], - [ limits[0], 1, limits[0] + 1 ], - [ limits[1], 1, limits[0] ] ], - [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0 ], - [ 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, - 18 ] ]); -} - -function run_char16_tests(library, t, name, limits) { - run_basic_class_tests(t); - - do_check_eq(t.name, name); - do_check_eq(t.size, 2); - - do_check_eq(t.toString(), "type " + name); - do_check_eq(t.toSource(), "ctypes." + name); - do_check_true(t.ptr === ctypes.PointerType(t)); - do_check_eq(t.array().name, name + "[]"); - do_check_eq(t.array(5).name, name + "[5]"); - - function toprimitive(a) { return a.charCodeAt(0); } - - let d = t(); - do_check_eq(d.value.length, 1); - do_check_eq(toprimitive(d.value), 0); - d.value = 5; - do_check_eq(d.value.length, 1); - do_check_eq(toprimitive(d.value), 5); - d = t(10); - do_check_eq(toprimitive(d.value), 10); - do_check_throws(function() { d.value = -10; }, TypeError); - d = new t(20); - do_check_eq(toprimitive(d.value), 20); - - d.value = ctypes.Int64(5); - do_check_eq(d.value.charCodeAt(0), 5); - do_check_throws(function() { d.value = ctypes.Int64(-10); }, TypeError); - d.value = ctypes.UInt64(5); - do_check_eq(d.value.charCodeAt(0), 5); - - d.value = limits[0]; - do_check_eq(toprimitive(d.value), limits[0]); - d.value = limits[1]; - do_check_eq(toprimitive(d.value), limits[1]); - d.value = 0; - do_check_eq(toprimitive(d.value), 0); - d.value = -0; - do_check_eq(1/toprimitive(d.value), 1/0); - d.value = false; - do_check_eq(toprimitive(d.value), 0); - d.value = true; - do_check_eq(toprimitive(d.value), 1); - - d.value = "\0"; - do_check_eq(toprimitive(d.value), 0); - d.value = "a"; - do_check_eq(d.value, "a"); - - // don't convert anything else - let vals = [limits[0] - 1, limits[1] + 1, Infinity, -Infinity, NaN, 0.1, - null, undefined, "", "aa", {}, [], new Number(16), - {toString: function () { return 7; }}, - {valueOf: function () { return 7; }}]; - for (let i = 0; i < vals.length; i++) - do_check_throws(function () { d.value = vals[i]; }, TypeError); - - do_check_true(d.address().constructor === t.ptr); - do_check_eq(d.address().contents, "a"); - do_check_eq(d.toSource(), "ctypes." + name + "(\"" + d.value + "\")"); - do_check_eq(d.toSource(), d.toString()); - - // Test string autoconversion (and lack thereof). - let literal = "autoconverted"; - let s = t.array()(literal); - do_check_eq(s.readString(), literal); - do_check_eq(s.constructor.length, literal.length + 1); - s = t.array(50)(literal); - do_check_eq(s.readString(), literal); - do_check_throws(function() { t.array(3)(literal); }, TypeError); - - do_check_throws(function() { t.ptr(literal); }, TypeError); - let p = t.ptr(s); - do_check_eq(p.readString(), literal); - - // Test the function call ABI for calls involving the type, - // and check the alignment of the type against what C says. - run_basic_abi_tests(library, t, name, toprimitive, - 109, - [ 0, limits[0], limits[1] ], - [ [ 0, 0, 0 ], [ 0, 1, 1 ], [ 1, 0, 1 ], [ 1, 1, 2 ], - [ limits[0], 1, limits[0] + 1 ], - [ limits[1], 1, limits[0] ] ], - [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0 ], - [ 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, - 18 ] ]); -} - -// Test the class and prototype hierarchy for a given type constructor 'c'. -function run_type_ctor_class_tests(c, t, t2, props=[], fns=[], instanceProps=[], instanceFns=[], specialProps=[]) -{ - do_check_true(c.prototype.__proto__ === ctypes.CType.prototype); - do_check_true(c.prototype instanceof ctypes.CType); - do_check_true(c.prototype.constructor === c); - - // Check that 'c.prototype' has the correct properties and functions. - for (let p of props) - do_check_true(c.prototype.hasOwnProperty(p)); - for (let f of fns) - do_check_true(c.prototype.hasOwnProperty(f)); - - // Check that the shared properties and functions on 'c.prototype' throw. - for (let p of props) - do_check_throws(function() { c.prototype[p]; }, TypeError); - for (let f of fns) - do_check_throws(function() { c.prototype[f](); }, TypeError); - - do_check_true(t.__proto__ === c.prototype); - do_check_true(t instanceof c); - - // 't.prototype.__proto__' is the common ancestor of all types constructed - // from 'c'; while not available from 'c' directly, it should be identically - // equal to 't2.prototype.__proto__' where 't2' is a different CType - // constructed from 'c'. - do_check_true(t.prototype.__proto__ === t2.prototype.__proto__); - if (t instanceof ctypes.FunctionType) - do_check_true(t.prototype.__proto__.__proto__ === ctypes.PointerType.prototype.prototype); - else - do_check_true(t.prototype.__proto__.__proto__ === ctypes.CData.prototype); - do_check_true(t.prototype instanceof ctypes.CData); - do_check_true(t.prototype.constructor === t); - - // Check that 't.prototype.__proto__' has the correct properties and - // functions. - for (let p of instanceProps) - do_check_true(t.prototype.__proto__.hasOwnProperty(p)); - for (let f of instanceFns) - do_check_true(t.prototype.__proto__.hasOwnProperty(f)); - - // Check that the shared properties and functions on 't.prototype.__proto__' - // (and thus also 't.prototype') throw. - for (let p of instanceProps) { - do_check_throws(function() { t.prototype.__proto__[p]; }, TypeError); - do_check_throws(function() { t.prototype[p]; }, TypeError); - } - for (let f of instanceFns) { - do_check_throws(function() { t.prototype.__proto__[f]() }, TypeError); - do_check_throws(function() { t.prototype[f]() }, TypeError); - } - - // Check that 't.prototype' has the correct special properties. - for (let p of specialProps) - do_check_true(t.prototype.hasOwnProperty(p)); - - // Check that the shared special properties on 't.prototype' throw. - for (let p of specialProps) - do_check_throws(function() { t.prototype[p]; }, TypeError); - - // Make sure we can access 'prototype' on a CTypeProto. - if (t instanceof ctypes.FunctionType) - do_check_true(Object.getPrototypeOf(c.prototype.prototype) === ctypes.PointerType.prototype.prototype); - else - do_check_true(Object.getPrototypeOf(c.prototype.prototype) === ctypes.CType.prototype.prototype); - - // Test that an instance 'd' of 't' is a CData. - if (t.__proto__ != ctypes.FunctionType.prototype) { - let d = t(); - do_check_true(d.__proto__ === t.prototype); - do_check_true(d instanceof t); - do_check_true(d.constructor === t); - } -} - -function run_StructType_tests() { - run_type_ctor_class_tests(ctypes.StructType, - ctypes.StructType("s", [{"a": ctypes.int32_t}, {"b": ctypes.int64_t}]), - ctypes.StructType("t", [{"c": ctypes.int32_t}, {"d": ctypes.int64_t}]), - [ "fields" ], [ "define" ], [], [ "addressOfField" ], [ "a", "b" ]); - - do_check_throws(function() { ctypes.StructType(); }, TypeError); - do_check_throws(function() { ctypes.StructType("a", [], 5); }, TypeError); - do_check_throws(function() { ctypes.StructType(null, []); }, TypeError); - do_check_throws(function() { ctypes.StructType("a", null); }, TypeError); - - // Check that malformed descriptors are an error. - do_check_throws(function() { - ctypes.StructType("a", [{"x":ctypes.int32_t}, {"x":ctypes.int8_t}]); - }, TypeError); - do_check_throws(function() { - ctypes.StructType("a", [5]); - }, TypeError); - do_check_throws(function() { - ctypes.StructType("a", [{}]); - }, TypeError); - do_check_throws(function() { - ctypes.StructType("a", [{5:ctypes.int32_t}]); - }, TypeError); - do_check_throws(function() { - ctypes.StructType("a", [{"5":ctypes.int32_t}]); - }, TypeError); - do_check_throws(function() { - ctypes.StructType("a", [{"x":5}]); - }, TypeError); - do_check_throws(function() { - ctypes.StructType("a", [{"x":ctypes.int32_t()}]); - }, TypeError); - - // Check that opaque structs work. - let opaque_t = ctypes.StructType("a"); - do_check_eq(opaque_t.name, "a"); - do_check_eq(opaque_t.toString(), "type a"); - do_check_eq(opaque_t.toSource(), 'ctypes.StructType("a")'); - do_check_true(opaque_t.prototype === undefined); - do_check_true(opaque_t.fields === undefined); - do_check_true(opaque_t.size === undefined); - do_check_throws(function() { opaque_t(); }, Error); - let opaqueptr_t = opaque_t.ptr; - do_check_true(opaqueptr_t.targetType === opaque_t); - do_check_eq(opaqueptr_t.name, "a*"); - do_check_eq(opaqueptr_t.toString(), "type a*"); - do_check_eq(opaqueptr_t.toSource(), 'ctypes.StructType("a").ptr'); - - // Check that type checking works with opaque structs. - let opaqueptr = opaqueptr_t(); - opaqueptr.value = opaqueptr_t(1); - do_check_eq(ptrValue(opaqueptr), 1); - do_check_throws(function() { - opaqueptr.value = ctypes.StructType("a").ptr(); - }, TypeError); - - // Check that 'define' works. - do_check_throws(function() { opaque_t.define(); }, TypeError); - do_check_throws(function() { opaque_t.define([], 0); }, TypeError); - do_check_throws(function() { opaque_t.define([{}]); }, TypeError); - do_check_throws(function() { opaque_t.define([{ a: 0 }]); }, TypeError); - do_check_throws(function() { - opaque_t.define([{ a: ctypes.int32_t, b: ctypes.int64_t }]); - }, TypeError); - do_check_throws(function() { - opaque_t.define([{ a: ctypes.int32_t }, { b: 0 }]); - }, TypeError); - do_check_false(opaque_t.hasOwnProperty("prototype")); - - // Check that circular references work with opaque structs... - // but not crazy ones. - do_check_throws(function() { opaque_t.define([{ b: opaque_t }]); }, TypeError); - let circular_t = ctypes.StructType("circular", [{ a: opaqueptr_t }]); - opaque_t.define([{ b: circular_t }]); - let opaque = opaque_t(); - let circular = circular_t(opaque.address()); - opaque.b = circular; - do_check_eq(circular.a.toSource(), opaque.address().toSource()); - do_check_eq(opaque.b.toSource(), circular.toSource()); - - // Check that attempting to redefine a struct fails and if attempted, the - // original definition is preserved. - do_check_throws(function() { - opaque_t.define([{ c: ctypes.int32_t.array(8) }]); - }, Error); - do_check_eq(opaque_t.size, circular_t.size); - do_check_true(opaque_t.prototype.hasOwnProperty("b")); - do_check_false(opaque_t.prototype.hasOwnProperty("c")); - - // StructType size, alignment, and offset calculations have already been - // checked for each basic type. We do not need to check them again. - let name = "g_t"; - let g_t = ctypes.StructType(name, [{ a: ctypes.int32_t }, { b: ctypes.double }]); - do_check_eq(g_t.name, name); - - do_check_eq(g_t.toString(), "type " + name); - do_check_eq(g_t.toSource(), - "ctypes.StructType(\"g_t\", [{ \"a\": ctypes.int32_t }, { \"b\": ctypes.double }])"); - do_check_true(g_t.ptr === ctypes.PointerType(g_t)); - do_check_eq(g_t.array().name, name + "[]"); - do_check_eq(g_t.array(5).name, name + "[5]"); - - let s_t = new ctypes.StructType("s_t", [{ a: ctypes.int32_t }, { b: g_t }, { c: ctypes.int8_t }]); - - let fields = [{ a: ctypes.int32_t }, { b: ctypes.int8_t }, { c: g_t }, { d: ctypes.int8_t }]; - let t_t = new ctypes.StructType("t_t", fields); - do_check_eq(t_t.fields.length, 4); - do_check_true(t_t.fields[0].a === ctypes.int32_t); - do_check_true(t_t.fields[1].b === ctypes.int8_t); - do_check_true(t_t.fields[2].c === g_t); - do_check_true(t_t.fields[3].d === ctypes.int8_t); -/* disabled temporarily per bug 598225. - do_check_throws(function() { t_t.fields.z = 0; }, Error); - do_check_throws(function() { t_t.fields[4] = 0; }, Error); - do_check_throws(function() { t_t.fields[4].a = 0; }, Error); - do_check_throws(function() { t_t.fields[4].e = 0; }, Error); -*/ - - // Check that struct size bounds work, and that large, but not illegal, sizes - // are OK. - if (ctypes.size_t.size == 4) { - // Test 1: overflow struct size + field padding + field size. - let large_t = ctypes.StructType("large_t", - [{"a": ctypes.int8_t.array(0xffffffff)}]); - do_check_eq(large_t.size, 0xffffffff); - do_check_throws(function() { - ctypes.StructType("large_t", [{"a": large_t}, {"b": ctypes.int8_t}]); - }, RangeError); - - // Test 2: overflow struct size + struct tail padding. - // To do this, we use a struct with maximum size and alignment 2. - large_t = ctypes.StructType("large_t", - [{"a": ctypes.int16_t.array(0xfffffffe / 2)}]); - do_check_eq(large_t.size, 0xfffffffe); - do_check_throws(function() { - ctypes.StructType("large_t", [{"a": large_t}, {"b": ctypes.int8_t}]); - }, RangeError); - - } else { - // Test 1: overflow struct size when converting from size_t to jsdouble. - let large_t = ctypes.StructType("large_t", - [{"a": ctypes.int8_t.array(0xfffffffffffff800)}]); - do_check_eq(large_t.size, 0xfffffffffffff800); - do_check_throws(function() { - ctypes.StructType("large_t", [{"a": large_t}, {"b": ctypes.int8_t}]); - }, RangeError); - let small_t = ctypes.int8_t.array(0x400); - do_check_throws(function() { - ctypes.StructType("large_t", [{"a": large_t}, {"b": small_t}]); - }, RangeError); - - large_t = ctypes.StructType("large_t", - [{"a": ctypes.int8_t.array(0x1fffffffffffff)}]); - do_check_eq(large_t.size, 0x1fffffffffffff); - do_check_throws(function() { - ctypes.StructType("large_t", [{"a": large_t.array(2)}, {"b": ctypes.int8_t}]); - }, RangeError); - - // Test 2: overflow struct size + field padding + field size. - large_t = ctypes.int8_t.array(0xfffffffffffff800); - small_t = ctypes.int8_t.array(0x800); - do_check_throws(function() { - ctypes.StructType("large_t", [{"a": large_t}, {"b": small_t}]); - }, RangeError); - - // Test 3: overflow struct size + struct tail padding. - // To do this, we use a struct with maximum size and alignment 2. - large_t = ctypes.StructType("large_t", - [{"a": ctypes.int16_t.array(0xfffffffffffff000 / 2)}]); - do_check_eq(large_t.size, 0xfffffffffffff000); - small_t = ctypes.int8_t.array(0xfff); - do_check_throws(function() { - ctypes.StructType("large_t", [{"a": large_t}, {"b": small_t}]); - }, RangeError); - } - - let g = g_t(); - do_check_eq(g.a, 0); - do_check_eq(g.b, 0); - g = new g_t(1, 2); - do_check_eq(g.a, 1); - do_check_eq(g.b, 2); - do_check_throws(function() { g_t(1); }, TypeError); - do_check_throws(function() { g_t(1, 2, 3); }, TypeError); - - for (let field in g) - do_check_true(field == "a" || field == "b"); - - let g_a = g.address(); - do_check_true(g_a.constructor === g_t.ptr); - do_check_eq(g_a.contents.a, g.a); - - let s = new s_t(3, g, 10); - do_check_eq(s.a, 3); - s.a = 4; - do_check_eq(s.a, 4); - do_check_eq(s.b.a, 1); - do_check_eq(s.b.b, 2); - do_check_eq(s.c, 10); - let g2 = s.b; - do_check_eq(g2.a, 1); - g2.a = 7; - do_check_eq(g2.a, 7); - do_check_eq(s.b.a, 7); - - g_a = s.addressOfField("b"); - do_check_true(g_a.constructor === g_t.ptr); - do_check_eq(g_a.contents.a, s.b.a); - do_check_throws(function() { s.addressOfField(); }, TypeError); - do_check_throws(function() { s.addressOfField("d"); }, TypeError); - do_check_throws(function() { s.addressOfField("a", 2); }, TypeError); - - do_check_eq(s.toSource(), "s_t(4, {\"a\": 7, \"b\": 2}, 10)"); - do_check_eq(s.toSource(), s.toString()); - eval("var s2 = " + s.toSource()); - do_check_true(s2.constructor === s_t); - do_check_eq(s.b.b, s2.b.b); - - // Test that structs can be set from an object using 'value'. - do_check_throws(function() { s.value; }, TypeError); - let s_init = { "a": 2, "b": { "a": 9, "b": 5 }, "c": 13 }; - s.value = s_init; - do_check_eq(s.b.a, 9); - do_check_eq(s.c, 13); - do_check_throws(function() { s.value = 5; }, TypeError); - do_check_throws(function() { s.value = ctypes.int32_t(); }, TypeError); - do_check_throws(function() { s.value = {}; }, TypeError); - do_check_throws(function() { s.value = { "a": 2 }; }, TypeError); - do_check_throws(function() { s.value = { "a": 2, "b": 5, "c": 10 }; }, TypeError); - do_check_throws(function() { - s.value = { "5": 2, "b": { "a": 9, "b": 5 }, "c": 13 }; - }, TypeError); - do_check_throws(function() { - s.value = { "a": 2, "b": { "a": 9, "b": 5 }, "c": 13, "d": 17 }; - }, TypeError); - do_check_throws(function() { - s.value = { "a": 2, "b": { "a": 9, "b": 5, "e": 9 }, "c": 13 }; - }, TypeError); - - // Test that structs can be constructed similarly through ExplicitConvert, - // and that the single-field case is disambiguated correctly. - s = s_t(s_init); - do_check_eq(s.b.a, 9); - do_check_eq(s.c, 13); - let v_t = ctypes.StructType("v_t", [{ "x": ctypes.int32_t }]); - let v = v_t({ "x": 5 }); - do_check_eq(v.x, 5); - v = v_t(8); - do_check_eq(v.x, 8); - let w_t = ctypes.StructType("w_t", [{ "y": v_t }]); - do_check_throws(function() { w_t(9); }, TypeError); - let w = w_t({ "x": 3 }); - do_check_eq(w.y.x, 3); - w = w_t({ "y": { "x": 19 } }); - do_check_eq(w.y.x, 19); - let u_t = ctypes.StructType("u_t", [{ "z": ctypes.ArrayType(ctypes.int32_t, 3) }]); - let u = u_t([1, 2, 3]); - do_check_eq(u.z[1], 2); - u = u_t({ "z": [4, 5, 6] }); - do_check_eq(u.z[1], 5); - - // Check that the empty struct has size 1. - let z_t = ctypes.StructType("z_t", []); - do_check_eq(z_t.size, 1); - do_check_eq(z_t.fields.length, 0); - - // Check that structs containing arrays of undefined or zero length - // are illegal, but arrays of defined length work. - do_check_throws(function() { - ctypes.StructType("z_t", [{ a: ctypes.int32_t.array() }]); - }, TypeError); - do_check_throws(function() { - ctypes.StructType("z_t", [{ a: ctypes.int32_t.array(0) }]); - }, TypeError); - z_t = ctypes.StructType("z_t", [{ a: ctypes.int32_t.array(6) }]); - do_check_eq(z_t.size, ctypes.int32_t.size * 6); - let z = z_t([1, 2, 3, 4, 5, 6]); - do_check_eq(z.a[3], 4); -} - -function ptrValue(p) { - return ctypes.cast(p, ctypes.uintptr_t).value.toString(); -} - -function run_PointerType_tests() { - run_type_ctor_class_tests(ctypes.PointerType, - ctypes.PointerType(ctypes.int32_t), ctypes.PointerType(ctypes.int64_t), - [ "targetType" ], [], [ "contents" ], [ "isNull", "increment", "decrement" ], []); - - do_check_throws(function() { ctypes.PointerType(); }, TypeError); - do_check_throws(function() { ctypes.PointerType(ctypes.int32_t, 5); }, TypeError); - do_check_throws(function() { ctypes.PointerType(null); }, TypeError); - do_check_throws(function() { ctypes.PointerType(ctypes.int32_t()); }, TypeError); - do_check_throws(function() { ctypes.PointerType("void"); }, TypeError); - - let name = "g_t"; - let g_t = ctypes.StructType(name, [{ a: ctypes.int32_t }, { b: ctypes.double }]); - let g = g_t(1, 2); - - let p_t = ctypes.PointerType(g_t); - do_check_eq(p_t.name, name + "*"); - do_check_eq(p_t.size, ctypes.uintptr_t.size); - do_check_true(p_t.targetType === g_t); - do_check_true(p_t === g_t.ptr); - - do_check_eq(p_t.toString(), "type " + name + "*"); - do_check_eq(p_t.toSource(), - "ctypes.StructType(\"g_t\", [{ \"a\": ctypes.int32_t }, { \"b\": ctypes.double }]).ptr"); - do_check_true(p_t.ptr === ctypes.PointerType(p_t)); - do_check_eq(p_t.array().name, name + "*[]"); - do_check_eq(p_t.array(5).name, name + "*[5]"); - - // Test ExplicitConvert. - let p = p_t(); - do_check_throws(function() { p.value; }, TypeError); - do_check_eq(ptrValue(p), 0); - do_check_throws(function() { p.contents; }, TypeError); - do_check_throws(function() { p.contents = g; }, TypeError); - p = p_t(5); - do_check_eq(ptrValue(p), 5); - p = p_t(ctypes.UInt64(10)); - do_check_eq(ptrValue(p), 10); - - // Test ImplicitConvert. - p.value = null; - do_check_eq(ptrValue(p), 0); - do_check_throws(function() { p.value = 5; }, TypeError); - - // Test opaque pointers. - let f_t = ctypes.StructType("FILE").ptr; - do_check_eq(f_t.name, "FILE*"); - do_check_eq(f_t.toSource(), 'ctypes.StructType("FILE").ptr'); - let f = new f_t(); - do_check_throws(function() { f.contents; }, TypeError); - do_check_throws(function() { f.contents = 0; }, TypeError); - f = f_t(5); - do_check_throws(function() { f.contents = 0; }, TypeError); - do_check_eq(f.toSource(), 'FILE.ptr(ctypes.UInt64("0x5"))'); - - do_check_throws(function() { f_t(p); }, TypeError); - do_check_throws(function() { f.value = p; }, TypeError); - do_check_throws(function() { p.value = f; }, TypeError); - - // Test void pointers. - let v_t = ctypes.PointerType(ctypes.void_t); - do_check_true(v_t === ctypes.voidptr_t); - let v = v_t(p); - do_check_eq(ptrValue(v), ptrValue(p)); - - // Test 'contents'. - let int32_t = ctypes.int32_t(9); - p = int32_t.address(); - do_check_eq(p.contents, int32_t.value); - p.contents = ctypes.int32_t(12); - do_check_eq(int32_t.value, 12); - - // Test 'isNull'. - let n = f_t(0); - do_check_true(n.isNull() === true); - n = p.address(); - do_check_true(n.isNull() === false); - - // Test 'increment'/'decrement'. - g_t = ctypes.StructType("g_t", [{ a: ctypes.int32_t }, { b: ctypes.double }]); - let a_t = ctypes.ArrayType(g_t, 2); - let a = new a_t(); - a[0] = g_t(1, 2); - a[1] = g_t(2, 4); - let a_p = a.addressOfElement(0).increment(); - do_check_eq(a_p.contents.a, 2); - do_check_eq(a_p.contents.b, 4); - a_p = a_p.decrement(); - do_check_eq(a_p.contents.a, 1); - do_check_eq(a_p.contents.b, 2); - - // Check that pointers to arrays of undefined or zero length are legal, - // but that the former cannot be dereferenced. - let z_t = ctypes.int32_t.array().ptr; - do_check_eq(ptrValue(z_t()), 0); - do_check_throws(function() { z_t().contents }, TypeError); - z_t = ctypes.int32_t.array(0).ptr; - do_check_eq(ptrValue(z_t()), 0); - let z = ctypes.int32_t.array(0)().address(); - do_check_eq(z.contents.length, 0); - - // TODO: Somehow, somewhere we should check that: - // - // (a) ArrayBuffer and TypedArray can be passed by pointer to a C function - // (b) SharedArrayBuffer and TypedArray on SAB can NOT be passed in that - // way (at least not at the moment). - - // Set up conversion tests on AB, SAB, TA - let c_arraybuffer = new ArrayBuffer(256); - let typed_array_samples = - [ - [new Int8Array(c_arraybuffer), ctypes.int8_t], - [new Uint8Array(c_arraybuffer), ctypes.uint8_t], - [new Int16Array(c_arraybuffer), ctypes.int16_t], - [new Uint16Array(c_arraybuffer), ctypes.uint16_t], - [new Int32Array(c_arraybuffer), ctypes.int32_t], - [new Uint32Array(c_arraybuffer), ctypes.uint32_t], - [new Float32Array(c_arraybuffer), ctypes.float32_t], - [new Float64Array(c_arraybuffer), ctypes.float64_t] - ]; - - if (typeof SharedArrayBuffer !== "undefined") { - let c_shared_arraybuffer = new SharedArrayBuffer(256); - typed_array_samples.push([new Int8Array(c_shared_arraybuffer), ctypes.int8_t], - [new Uint8Array(c_shared_arraybuffer), ctypes.uint8_t], - [new Int16Array(c_shared_arraybuffer), ctypes.int16_t], - [new Uint16Array(c_shared_arraybuffer), ctypes.uint16_t], - [new Int32Array(c_shared_arraybuffer), ctypes.int32_t], - [new Uint32Array(c_shared_arraybuffer), ctypes.uint32_t], - [new Float32Array(c_shared_arraybuffer), ctypes.float32_t], - [new Float64Array(c_shared_arraybuffer), ctypes.float64_t]) - } - - // Check that you can convert (Shared)ArrayBuffer or typed array to a C array - for (let i = 0; i < typed_array_samples.length; ++i) { - for (let j = 0; j < typed_array_samples.length; ++j) { - let view = typed_array_samples[i][0]; - let item_type = typed_array_samples[j][1]; - let number_of_items = c_arraybuffer.byteLength / item_type.size; - let array_type = item_type.array(number_of_items); - - // Int8Array on unshared memory is interconvertible with Int8Array on - // shared memory, etc. - if (i % 8 != j % 8) { - do_print("Checking that typed array " + (view.constructor.name) + - " can NOT be converted to " + item_type + " array"); - do_check_throws(function() { array_type(view); }, TypeError); - } else { - do_print("Checking that typed array " + (view.constructor.name) + - " can be converted to " + item_type + " array"); - - // Convert ArrayBuffer to array of the right size and check contents - c_array = array_type(c_arraybuffer); - for (let k = 0; k < number_of_items; ++k) { - do_check_eq(c_array[k], view[k]); - } - - // Convert typed array to array of the right size and check contents - c_array = array_type(view); - for (let k = 0; k < number_of_items; ++k) { - do_check_eq(c_array[k], view[k]); - } - - // Convert typed array to array of wrong size, ensure that it fails - let array_type_too_large = item_type.array(number_of_items + 1); - let array_type_too_small = item_type.array(number_of_items - 1); - - do_check_throws(function() { array_type_too_large(c_arraybuffer); }, TypeError); - do_check_throws(function() { array_type_too_small(c_arraybuffer); }, TypeError); - do_check_throws(function() { array_type_too_large(view); }, TypeError); - do_check_throws(function() { array_type_too_small(view); }, TypeError); - - // Convert subarray of typed array to array of right size and check contents - c_array = array_type_too_small(view.subarray(1)); - for (let k = 1; k < number_of_items; ++k) { - do_check_eq(c_array[k - 1], view[k]); - } - } - } - } - - // Check that you can't use a (Shared)ArrayBuffer or a typed array as a pointer - for (let i = 0; i < typed_array_samples.length; ++i) { - for (let j = 0; j < typed_array_samples.length; ++j) { - let view = typed_array_samples[i][0]; - let item_type = typed_array_samples[j][1]; - - do_print("Checking that typed array " + (view.constructor.name) + - " can NOT be converted to " + item_type + " pointer/array"); - do_check_throws(function() { item_type.ptr(c_arraybuffer); }, TypeError); - do_check_throws(function() { item_type.ptr(view); }, TypeError); - do_check_throws(function() { ctypes.voidptr_t(c_arraybuffer); }, TypeError); - do_check_throws(function() { ctypes.voidptr_t(view); }, TypeError); - } - } -} - -function run_FunctionType_tests() { - run_type_ctor_class_tests(ctypes.FunctionType, - ctypes.FunctionType(ctypes.default_abi, ctypes.void_t), - ctypes.FunctionType(ctypes.default_abi, ctypes.void_t, [ ctypes.int32_t ]), - [ "abi", "returnType", "argTypes", "isVariadic" ], - undefined, undefined, undefined, undefined); - - do_check_throws(function() { ctypes.FunctionType(); }, TypeError); - do_check_throws(function() { - ctypes.FunctionType(ctypes.default_abi, ctypes.void_t, [ ctypes.void_t ]); - }, TypeError); - do_check_throws(function() { - ctypes.FunctionType(ctypes.default_abi, ctypes.void_t, [ ctypes.void_t ], 5); - }, TypeError); - do_check_throws(function() { - ctypes.FunctionType(ctypes.default_abi, ctypes.void_t, ctypes.void_t); - }, TypeError); - do_check_throws(function() { - ctypes.FunctionType(ctypes.default_abi, ctypes.void_t, null); - }, TypeError); - do_check_throws(function() { - ctypes.FunctionType(ctypes.default_abi, ctypes.int32_t()); - }, TypeError); - do_check_throws(function() { - ctypes.FunctionType(ctypes.void_t, ctypes.void_t); - }, Error); - - let g_t = ctypes.StructType("g_t", [{ a: ctypes.int32_t }, { b: ctypes.double }]); - - let f_t = ctypes.FunctionType(ctypes.default_abi, g_t); - let name = "g_t()"; - do_check_eq(f_t.name, name); - do_check_eq(f_t.size, undefined); - do_check_true(f_t.abi === ctypes.default_abi); - do_check_true(f_t.returnType === g_t); - do_check_true(f_t.argTypes.length == 0); - - do_check_eq(f_t.toString(), "type " + name); - do_check_eq(f_t.toSource(), - "ctypes.FunctionType(ctypes.default_abi, g_t)"); - - let fp_t = f_t.ptr; - name = "g_t(*)()"; - do_check_eq(fp_t.name, name); - do_check_eq(fp_t.size, ctypes.uintptr_t.size); - - do_check_eq(fp_t.toString(), "type " + name); - do_check_eq(fp_t.toSource(), - "ctypes.FunctionType(ctypes.default_abi, g_t).ptr"); - - // Check that constructing a FunctionType CData directly throws. - do_check_throws(function() { f_t(); }, TypeError); - - // Test ExplicitConvert. - let f = fp_t(); - do_check_throws(function() { f.value; }, TypeError); - do_check_eq(ptrValue(f), 0); - f = fp_t(5); - do_check_eq(ptrValue(f), 5); - f = fp_t(ctypes.UInt64(10)); - do_check_eq(ptrValue(f), 10); - - // Test ImplicitConvert. - f.value = null; - do_check_eq(ptrValue(f), 0); - do_check_throws(function() { f.value = 5; }, TypeError); - do_check_eq(f.toSource(), - 'ctypes.FunctionType(ctypes.default_abi, g_t).ptr(ctypes.UInt64("0x0"))'); - - // Test ImplicitConvert from a function pointer of different type. - let f2_t = ctypes.FunctionType(ctypes.default_abi, g_t, [ ctypes.int32_t ]); - let f2 = f2_t.ptr(); - do_check_throws(function() { f.value = f2; }, TypeError); - do_check_throws(function() { f2.value = f; }, TypeError); - - // Test that converting to a voidptr_t works. - let v = ctypes.voidptr_t(f2); - do_check_eq(v.toSource(), 'ctypes.voidptr_t(ctypes.UInt64("0x0"))'); - - // Test some more complex names. - do_check_eq(fp_t.array().name, "g_t(*[])()"); - do_check_eq(fp_t.array().ptr.name, "g_t(*(*)[])()"); - - let f3_t = ctypes.FunctionType(ctypes.default_abi, - ctypes.char.ptr.array().ptr).ptr.ptr.array(8).array(); - do_check_eq(f3_t.name, "char*(*(**[][8])())[]"); - - if ("winLastError" in ctypes) { - f3_t = ctypes.FunctionType(ctypes.stdcall_abi, - ctypes.char.ptr.array().ptr).ptr.ptr.array(8).array(); - do_check_eq(f3_t.name, "char*(*(__stdcall**[][8])())[]"); - f3_t = ctypes.FunctionType(ctypes.winapi_abi, - ctypes.char.ptr.array().ptr).ptr.ptr.array(8).array(); - do_check_eq(f3_t.name, "char*(*(WINAPI**[][8])())[]"); - } - - let f4_t = ctypes.FunctionType(ctypes.default_abi, - ctypes.char.ptr.array().ptr, [ ctypes.int32_t, fp_t ]); - do_check_true(f4_t.argTypes.length == 2); - do_check_true(f4_t.argTypes[0] === ctypes.int32_t); - do_check_true(f4_t.argTypes[1] === fp_t); -/* disabled temporarily per bug 598225. - do_check_throws(function() { f4_t.argTypes.z = 0; }, Error); - do_check_throws(function() { f4_t.argTypes[0] = 0; }, Error); -*/ - - let t4_t = f4_t.ptr.ptr.array(8).array(); - do_check_eq(t4_t.name, "char*(*(**[][8])(int32_t, g_t(*)()))[]"); - - // Not available in a Worker - if ("@mozilla.org/systemprincipal;1" in Components.classes) { - var sp = Components.classes["@mozilla.org/systemprincipal;1"]. - createInstance(Components.interfaces.nsIPrincipal); - var s = new Components.utils.Sandbox(sp); - s.ctypes = ctypes; - s.do_check_eq = do_check_eq; - s.do_check_true = do_check_true; - Components.utils.evalInSandbox("var f5_t = ctypes.FunctionType(ctypes.default_abi, ctypes.int, [ctypes.int]);", s); - Components.utils.evalInSandbox("do_check_eq(f5_t.toSource(), 'ctypes.FunctionType(ctypes.default_abi, ctypes.int, [ctypes.int])');", s); - Components.utils.evalInSandbox("do_check_eq(f5_t.name, 'int(int)');", s); - Components.utils.evalInSandbox("function f5(aArg) { return 5; };", s); - Components.utils.evalInSandbox("var f = f5_t.ptr(f5);", s); - Components.utils.evalInSandbox("do_check_true(f(6) == 5);", s); - } -} - -function run_ArrayType_tests() { - run_type_ctor_class_tests(ctypes.ArrayType, - ctypes.ArrayType(ctypes.int32_t, 10), ctypes.ArrayType(ctypes.int64_t), - [ "elementType", "length" ], [], [ "length" ], [ "addressOfElement" ]); - - do_check_throws(function() { ctypes.ArrayType(); }, TypeError); - do_check_throws(function() { ctypes.ArrayType(null); }, TypeError); - do_check_throws(function() { ctypes.ArrayType(ctypes.int32_t, 1, 5); }, TypeError); - do_check_throws(function() { ctypes.ArrayType(ctypes.int32_t, -1); }, TypeError); - - let name = "g_t"; - let g_t = ctypes.StructType(name, [{ a: ctypes.int32_t }, { b: ctypes.double }]); - let g = g_t(1, 2); - - let a_t = ctypes.ArrayType(g_t, 10); - do_check_eq(a_t.name, name + "[10]"); - do_check_eq(a_t.length, 10); - do_check_eq(a_t.size, g_t.size * 10); - do_check_true(a_t.elementType === g_t); - - do_check_eq(a_t.toString(), "type " + name + "[10]"); - do_check_eq(a_t.toSource(), - "ctypes.StructType(\"g_t\", [{ \"a\": ctypes.int32_t }, { \"b\": ctypes.double }]).array(10)"); - do_check_eq(a_t.array().name, name + "[][10]"); - do_check_eq(a_t.array(5).name, name + "[5][10]"); - do_check_throws(function() { ctypes.int32_t.array().array(); }, Error); - - let a = new a_t(); - do_check_eq(a[0].a, 0); - do_check_eq(a[0].b, 0); - a[0] = g; - do_check_eq(a[0].a, 1); - do_check_eq(a[0].b, 2); - do_check_throws(function() { a[-1]; }, TypeError); - do_check_eq(a[9].a, 0); - do_check_throws(function() { a[10]; }, RangeError); - - do_check_eq(a[ctypes.Int64(0)].a, 1); - do_check_eq(a[ctypes.UInt64(0)].b, 2); - - let a_p = a.addressOfElement(0); - do_check_true(a_p.constructor.targetType === g_t); - do_check_true(a_p.constructor === g_t.ptr); - do_check_eq(a_p.contents.a, a[0].a); - do_check_eq(a_p.contents.b, a[0].b); - a_p.contents.a = 5; - do_check_eq(a[0].a, 5); - - let a2_t = ctypes.ArrayType(g_t); - do_check_eq(a2_t.name, "g_t[]"); - do_check_eq(a2_t.length, undefined); - do_check_eq(a2_t.size, undefined); - let a2 = new a2_t(5); - do_check_eq(a2.constructor.length, 5); - do_check_eq(a2.length, 5); - do_check_eq(a2.constructor.size, g_t.size * 5); - do_check_throws(function() { new a2_t(); }, TypeError); - do_check_throws(function() { ctypes.ArrayType(ctypes.ArrayType(g_t)); }, Error); - do_check_throws(function() { ctypes.ArrayType(ctypes.ArrayType(g_t), 5); }, Error); - - let b_t = ctypes.int8_t.array(ctypes.UInt64(0xffff)); - do_check_eq(b_t.length, 0xffff); - b_t = ctypes.int8_t.array(ctypes.Int64(0xffff)); - do_check_eq(b_t.length, 0xffff); - - // Check that array size bounds work, and that large, but not illegal, sizes - // are OK. - if (ctypes.size_t.size == 4) { - do_check_throws(function() { - ctypes.ArrayType(ctypes.int8_t, 0x100000000); - }, TypeError); - do_check_throws(function() { - ctypes.ArrayType(ctypes.int16_t, 0x80000000); - }, RangeError); - - let large_t = ctypes.int8_t.array(0x80000000); - do_check_throws(function() { large_t.array(2); }, RangeError); - - } else { - do_check_throws(function() { - ctypes.ArrayType(ctypes.int8_t, ctypes.UInt64("0xffffffffffffffff")); - }, TypeError); - do_check_throws(function() { - ctypes.ArrayType(ctypes.int16_t, ctypes.UInt64("0x8000000000000000")); - }, RangeError); - - let large_t = ctypes.int8_t.array(0x8000000000000000); - do_check_throws(function() { large_t.array(2); }, RangeError); - } - - // Test that arrays ImplicitConvert to pointers. - let b = ctypes.int32_t.array(10)(); - let p = ctypes.int32_t.ptr(); - p.value = b; - do_check_eq(ptrValue(b.addressOfElement(0)), ptrValue(p)); - p = ctypes.voidptr_t(); - p.value = b; - do_check_eq(ptrValue(b.addressOfElement(0)), ptrValue(p)); - - // Test that arrays can be constructed through ImplicitConvert. - let c_t = ctypes.int32_t.array(6); - let c = c_t(); - c.value = [1, 2, 3, 4, 5, 6]; - do_check_eq(c.toSource(), "ctypes.int32_t.array(6)([1, 2, 3, 4, 5, 6])"); - do_check_eq(c.toSource(), c.toString()); - eval("var c2 = " + c.toSource()); - do_check_eq(c2.constructor.name, "int32_t[6]"); - do_check_eq(c2.length, 6); - do_check_eq(c2[3], c[3]); - - c.value = c; - do_check_eq(c[3], 4); - do_check_throws(function() { c.value; }, TypeError); - do_check_throws(function() { c.value = [1, 2, 3, 4, 5]; }, TypeError); - do_check_throws(function() { c.value = [1, 2, 3, 4, 5, 6, 7]; }, TypeError); - do_check_throws(function() { c.value = [1, 2, 7.4, 4, 5, 6]; }, TypeError); - do_check_throws(function() { c.value = []; }, TypeError); -} - -function run_type_toString_tests() { - var c = ctypes; - - // Figure out whether we can create functions with ctypes.stdcall_abi and ctypes.winapi_abi. - var haveStdCallABI; - try { - c.FunctionType(c.stdcall_abi, c.int); - haveStdCallABI = true; - } catch (x) { - haveStdCallABI = false; - } - - var haveWinAPIABI; - try { - c.FunctionType(c.winapi_abi, c.int); - haveWinAPIABI = true; - } catch (x) { - haveWinAPIABI = false; - } - - do_check_eq(c.char.toString(), "type char"); - do_check_eq(c.short.toString(), "type short"); - do_check_eq(c.int.toString(), "type int"); - do_check_eq(c.long.toString(), "type long"); - do_check_eq(c.long_long.toString(), "type long_long"); - do_check_eq(c.ssize_t.toString(), "type ssize_t"); - do_check_eq(c.int8_t.toString(), "type int8_t"); - do_check_eq(c.int16_t.toString(), "type int16_t"); - do_check_eq(c.int32_t.toString(), "type int32_t"); - do_check_eq(c.int64_t.toString(), "type int64_t"); - do_check_eq(c.intptr_t.toString(), "type intptr_t"); - - do_check_eq(c.unsigned_char.toString(), "type unsigned_char"); - do_check_eq(c.unsigned_short.toString(), "type unsigned_short"); - do_check_eq(c.unsigned_int.toString(), "type unsigned_int"); - do_check_eq(c.unsigned_long.toString(), "type unsigned_long"); - do_check_eq(c.unsigned_long_long.toString(), "type unsigned_long_long"); - do_check_eq(c.size_t.toString(), "type size_t"); - do_check_eq(c.uint8_t.toString(), "type uint8_t"); - do_check_eq(c.uint16_t.toString(), "type uint16_t"); - do_check_eq(c.uint32_t.toString(), "type uint32_t"); - do_check_eq(c.uint64_t.toString(), "type uint64_t"); - do_check_eq(c.uintptr_t.toString(), "type uintptr_t"); - - do_check_eq(c.float.toString(), "type float"); - do_check_eq(c.double.toString(), "type double"); - do_check_eq(c.bool.toString(), "type bool"); - do_check_eq(c.void_t.toString(), "type void"); - do_check_eq(c.voidptr_t.toString(), "type void*"); - do_check_eq(c.char16_t.toString(), "type char16_t"); - - var simplestruct = c.StructType("simplestruct", [{"smitty":c.voidptr_t}]); - do_check_eq(simplestruct.toString(), "type simplestruct"); - - // One type modifier, int base type. - do_check_eq(c.int.ptr.toString(), "type int*"); - do_check_eq(c.ArrayType(c.int).toString(), "type int[]"); - do_check_eq(c.ArrayType(c.int, 4).toString(), "type int[4]"); - do_check_eq(c.FunctionType(c.default_abi, c.int).toString(), "type int()"); - do_check_eq(c.FunctionType(c.default_abi, c.int, [c.bool]).toString(), "type int(bool)"); - do_check_eq(c.FunctionType(c.default_abi, c.int, [c.bool, c.short]).toString(), - "type int(bool, short)"); - if (haveStdCallABI) - do_check_eq(c.FunctionType(c.stdcall_abi, c.int).toString(), "type int __stdcall()"); - if (haveWinAPIABI) - do_check_eq(c.FunctionType(c.winapi_abi, c.int).toString(), "type int WINAPI()"); - - // One type modifier, struct base type. - do_check_eq(simplestruct.ptr.toString(), "type simplestruct*"); - do_check_eq(c.ArrayType(simplestruct).toString(), "type simplestruct[]"); - do_check_eq(c.ArrayType(simplestruct, 4).toString(), "type simplestruct[4]"); - do_check_eq(c.FunctionType(c.default_abi, simplestruct).toString(), "type simplestruct()"); - - // Two levels of type modifiers, int base type. - do_check_eq(c.int.ptr.ptr.toString(), "type int**"); - do_check_eq(c.ArrayType(c.int.ptr).toString(), "type int*[]"); - do_check_eq(c.FunctionType(c.default_abi, c.int.ptr).toString(), "type int*()"); - - do_check_eq(c.ArrayType(c.int).ptr.toString(), "type int(*)[]"); - do_check_eq(c.ArrayType(c.ArrayType(c.int, 4)).toString(), "type int[][4]"); - // Functions can't return arrays. - - do_check_eq(c.FunctionType(c.default_abi, c.int).ptr.toString(), "type int(*)()"); - // You can't have an array of functions. - // Functions can't return functions. - - // We don't try all the permissible three-deep combinations, but this is fun. - do_check_eq(c.FunctionType(c.default_abi, c.FunctionType(c.default_abi, c.int).ptr).toString(), - "type int(*())()"); -} - -function run_cast_tests() { - // Test casting between basic types. - let i = ctypes.int32_t(); - let j = ctypes.cast(i, ctypes.int16_t); - do_check_eq(ptrValue(i.address()), ptrValue(j.address())); - do_check_eq(i.value, j.value); - let k = ctypes.cast(i, ctypes.uint32_t); - do_check_eq(ptrValue(i.address()), ptrValue(k.address())); - do_check_eq(i.value, k.value); - - // Test casting to a type of undefined or larger size. - do_check_throws(function() { ctypes.cast(i, ctypes.void_t); }, TypeError); - do_check_throws(function() { ctypes.cast(i, ctypes.int32_t.array()); }, TypeError); - do_check_throws(function() { ctypes.cast(i, ctypes.int64_t); }, TypeError); - - // Test casting between special types. - let g_t = ctypes.StructType("g_t", [{ a: ctypes.int32_t }, { b: ctypes.double }]); - let a_t = ctypes.ArrayType(g_t, 4); - let f_t = ctypes.FunctionType(ctypes.default_abi, ctypes.void_t).ptr; - - let a = a_t(); - a[0] = { a: 5, b: 7.5 }; - let g = ctypes.cast(a, g_t); - do_check_eq(ptrValue(a.address()), ptrValue(g.address())); - do_check_eq(a[0].a, g.a); - - let a2 = ctypes.cast(g, g_t.array(1)); - do_check_eq(ptrValue(a2.address()), ptrValue(g.address())); - do_check_eq(a2[0].a, g.a); - - let p = g.address(); - let ip = ctypes.cast(p, ctypes.int32_t.ptr); - do_check_eq(ptrValue(ip), ptrValue(p)); - do_check_eq(ptrValue(ip.address()), ptrValue(p.address())); - do_check_eq(ip.contents, g.a); - - let f = f_t(0x5); - let f2 = ctypes.cast(f, ctypes.voidptr_t); - do_check_eq(ptrValue(f2), ptrValue(f)); - do_check_eq(ptrValue(f2.address()), ptrValue(f.address())); -} - -function run_void_tests(library) { - let test_void_t = library.declare("test_void_t_cdecl", ctypes.default_abi, ctypes.void_t); - do_check_eq(test_void_t(), undefined); - - // Test that library.declare throws with void function args. - do_check_throws(function() { - library.declare("test_void_t_cdecl", ctypes.default_abi, ctypes.void_t, ctypes.void_t); - }, TypeError); - - if ("winLastError" in ctypes) { - test_void_t = library.declare("test_void_t_stdcall", ctypes.stdcall_abi, ctypes.void_t); - do_check_eq(test_void_t(), undefined); - - // Check that WINAPI symbol lookup for a regular stdcall function fails on - // Win32 (it's all the same on Win64 though). - if (ctypes.voidptr_t.size == 4) { - do_check_throws(function() { - library.declare("test_void_t_stdcall", ctypes.winapi_abi, ctypes.void_t); - }, Error); - } - } -} - -function run_string_tests(library) { - let test_ansi_len = library.declare("test_ansi_len", ctypes.default_abi, ctypes.int32_t, ctypes.char.ptr); - do_check_eq(test_ansi_len(""), 0); - do_check_eq(test_ansi_len("hello world"), 11); - - // don't convert anything else to a string - let vals = [true, 0, 1/3, undefined, {}, {toString: function () { return "bad"; }}, []]; - for (let i = 0; i < vals.length; i++) - do_check_throws(function() { test_ansi_len(vals[i]); }, TypeError); - - let test_wide_len = library.declare("test_wide_len", ctypes.default_abi, ctypes.int32_t, ctypes.char16_t.ptr); - do_check_eq(test_wide_len("hello world"), 11); - - let test_ansi_ret = library.declare("test_ansi_ret", ctypes.default_abi, ctypes.char.ptr); - do_check_eq(test_ansi_ret().readString(), "success"); - - let test_wide_ret = library.declare("test_wide_ret", ctypes.default_abi, ctypes.char16_t.ptr); - do_check_eq(test_wide_ret().readString(), "success"); - - let test_ansi_echo = library.declare("test_ansi_echo", ctypes.default_abi, ctypes.char.ptr, ctypes.char.ptr); - // We cannot pass a string literal directly into test_ansi_echo, since the - // conversion to ctypes.char.ptr is only valid for the duration of the ffi - // call. The escaped pointer that's returned will point to freed memory. - let arg = ctypes.char.array()("anybody in there?"); - do_check_eq(test_ansi_echo(arg).readString(), "anybody in there?"); - do_check_eq(ptrValue(test_ansi_echo(null)), 0); -} - -function run_readstring_tests(library) { - // ASCII decode test, "hello world" - let ascii_string = ctypes.unsigned_char.array(12)(); - ascii_string[0] = 0x68; - ascii_string[1] = 0x65; - ascii_string[2] = 0x6C; - ascii_string[3] = 0x6C; - ascii_string[4] = 0x6F; - ascii_string[5] = 0x20; - ascii_string[6] = 0x77; - ascii_string[7] = 0x6F; - ascii_string[8] = 0x72; - ascii_string[9] = 0x6C; - ascii_string[10] = 0x64; - ascii_string[11] = 0; - do_check_eq("hello world", ascii_string.readStringReplaceMalformed()); - - // UTF-8 decode test, "U+AC00 U+B098 U+B2E4" - let utf8_string = ctypes.unsigned_char.array(10)(); - utf8_string[0] = 0xEA; - utf8_string[1] = 0xB0; - utf8_string[2] = 0x80; - utf8_string[3] = 0xEB; - utf8_string[4] = 0x82; - utf8_string[5] = 0x98; - utf8_string[6] = 0xEB; - utf8_string[7] = 0x8B; - utf8_string[8] = 0xA4; - utf8_string[9] = 0x00; - let utf8_result = utf8_string.readStringReplaceMalformed(); - do_check_eq(0xAC00, utf8_result.charCodeAt(0)); - do_check_eq(0xB098, utf8_result.charCodeAt(1)); - do_check_eq(0xB2E4, utf8_result.charCodeAt(2)); - - // KS5601 decode test, invalid encoded byte should be replaced with U+FFFD - let ks5601_string = ctypes.unsigned_char.array(7)(); - ks5601_string[0] = 0xB0; - ks5601_string[1] = 0xA1; - ks5601_string[2] = 0xB3; - ks5601_string[3] = 0xAA; - ks5601_string[4] = 0xB4; - ks5601_string[5] = 0xD9; - ks5601_string[6] = 0x00; - let ks5601_result = ks5601_string.readStringReplaceMalformed(); - do_check_eq(0xFFFD, ks5601_result.charCodeAt(0)); - do_check_eq(0xFFFD, ks5601_result.charCodeAt(1)); - do_check_eq(0xFFFD, ks5601_result.charCodeAt(2)); - do_check_eq(0xFFFD, ks5601_result.charCodeAt(3)); - do_check_eq(0xFFFD, ks5601_result.charCodeAt(4)); - do_check_eq(0xFFFD, ks5601_result.charCodeAt(5)); - - // Mixed decode test, "test" + "U+AC00 U+B098 U+B2E4" + "test" - // invalid encoded byte should be replaced with U+FFFD - let mixed_string = ctypes.unsigned_char.array(15)(); - mixed_string[0] = 0x74; - mixed_string[1] = 0x65; - mixed_string[2] = 0x73; - mixed_string[3] = 0x74; - mixed_string[4] = 0xB0; - mixed_string[5] = 0xA1; - mixed_string[6] = 0xB3; - mixed_string[7] = 0xAA; - mixed_string[8] = 0xB4; - mixed_string[9] = 0xD9; - mixed_string[10] = 0x74; - mixed_string[11] = 0x65; - mixed_string[12] = 0x73; - mixed_string[13] = 0x74; - mixed_string[14] = 0x00; - let mixed_result = mixed_string.readStringReplaceMalformed(); - do_check_eq(0x74, mixed_result.charCodeAt(0)); - do_check_eq(0x65, mixed_result.charCodeAt(1)); - do_check_eq(0x73, mixed_result.charCodeAt(2)); - do_check_eq(0x74, mixed_result.charCodeAt(3)); - do_check_eq(0xFFFD, mixed_result.charCodeAt(4)); - do_check_eq(0xFFFD, mixed_result.charCodeAt(5)); - do_check_eq(0xFFFD, mixed_result.charCodeAt(6)); - do_check_eq(0xFFFD, mixed_result.charCodeAt(7)); - do_check_eq(0xFFFD, mixed_result.charCodeAt(8)); - do_check_eq(0xFFFD, mixed_result.charCodeAt(9)); - do_check_eq(0x74, mixed_result.charCodeAt(10)); - do_check_eq(0x65, mixed_result.charCodeAt(11)); - do_check_eq(0x73, mixed_result.charCodeAt(12)); - do_check_eq(0x74, mixed_result.charCodeAt(13)); - - // Test of all posible invalid encoded sequence - let invalid_string = ctypes.unsigned_char.array(27)(); - invalid_string[0] = 0x80; // 10000000 - invalid_string[1] = 0xD0; // 11000000 01110100 - invalid_string[2] = 0x74; - invalid_string[3] = 0xE0; // 11100000 01110100 - invalid_string[4] = 0x74; - invalid_string[5] = 0xE0; // 11100000 10100000 01110100 - invalid_string[6] = 0xA0; - invalid_string[7] = 0x74; - invalid_string[8] = 0xE0; // 11100000 10000000 01110100 - invalid_string[9] = 0x80; - invalid_string[10] = 0x74; - invalid_string[11] = 0xF0; // 11110000 01110100 - invalid_string[12] = 0x74; - invalid_string[13] = 0xF0; // 11110000 10010000 01110100 - invalid_string[14] = 0x90; - invalid_string[15] = 0x74; - invalid_string[16] = 0xF0; // 11110000 10010000 10000000 01110100 - invalid_string[17] = 0x90; - invalid_string[18] = 0x80; - invalid_string[19] = 0x74; - invalid_string[20] = 0xF0; // 11110000 10000000 10000000 01110100 - invalid_string[21] = 0x80; - invalid_string[22] = 0x80; - invalid_string[23] = 0x74; - invalid_string[24] = 0xF0; // 11110000 01110100 - invalid_string[25] = 0x74; - invalid_string[26] = 0x00; - let invalid_result = invalid_string.readStringReplaceMalformed(); - do_check_eq(0xFFFD, invalid_result.charCodeAt(0)); // 10000000 - do_check_eq(0xFFFD, invalid_result.charCodeAt(1)); // 11000000 01110100 - do_check_eq(0x74, invalid_result.charCodeAt(2)); - do_check_eq(0xFFFD, invalid_result.charCodeAt(3)); // 11100000 01110100 - do_check_eq(0x74, invalid_result.charCodeAt(4)); - do_check_eq(0xFFFD, invalid_result.charCodeAt(5)); // 11100000 10100000 01110100 - do_check_eq(0x74, invalid_result.charCodeAt(6)); - do_check_eq(0xFFFD, invalid_result.charCodeAt(7)); // 11100000 10000000 01110100 - do_check_eq(0xFFFD, invalid_result.charCodeAt(8)); - do_check_eq(0x74, invalid_result.charCodeAt(9)); - do_check_eq(0xFFFD, invalid_result.charCodeAt(10)); // 11110000 01110100 - do_check_eq(0x74, invalid_result.charCodeAt(11)); - do_check_eq(0xFFFD, invalid_result.charCodeAt(12)); // 11110000 10010000 01110100 - do_check_eq(0x74, invalid_result.charCodeAt(13)); - do_check_eq(0xFFFD, invalid_result.charCodeAt(14)); // 11110000 10010000 10000000 01110100 - do_check_eq(0x74, invalid_result.charCodeAt(15)); - do_check_eq(0xFFFD, invalid_result.charCodeAt(16)); // 11110000 10000000 10000000 01110100 - do_check_eq(0xFFFD, invalid_result.charCodeAt(17)); - do_check_eq(0xFFFD, invalid_result.charCodeAt(18)); - do_check_eq(0x74, invalid_result.charCodeAt(19)); - do_check_eq(0xFFFD, invalid_result.charCodeAt(20)); // 11110000 01110100 - do_check_eq(0x74, invalid_result.charCodeAt(21)); - - // Test decoding of UTF-8 and CESU-8 - let utf8_cesu8_string = ctypes.unsigned_char.array(10)(); - utf8_cesu8_string[0] = 0xF0; // U+10400 in UTF-8 - utf8_cesu8_string[1] = 0x90; - utf8_cesu8_string[2] = 0x90; - utf8_cesu8_string[3] = 0x80; - utf8_cesu8_string[4] = 0xED; // U+10400 in CESU-8 - utf8_cesu8_string[5] = 0xA0; - utf8_cesu8_string[6] = 0x81; - utf8_cesu8_string[7] = 0xED; - utf8_cesu8_string[8] = 0xB0; - utf8_cesu8_string[9] = 0x80; - let utf8_cesu8_result = utf8_cesu8_string.readStringReplaceMalformed(); - do_check_eq(0xD801, utf8_cesu8_result.charCodeAt(0)); - do_check_eq(0xDC00, utf8_cesu8_result.charCodeAt(1)); - do_check_eq(0xFFFD, utf8_cesu8_result.charCodeAt(2)); - do_check_eq(0xFFFD, utf8_cesu8_result.charCodeAt(3)); -} - -function run_struct_tests(library) { - const point_t = new ctypes.StructType("myPOINT", - [{ x: ctypes.int32_t }, - { y: ctypes.int32_t }]); - const rect_t = new ctypes.StructType("myRECT", - [{ top : ctypes.int32_t }, - { left : ctypes.int32_t }, - { bottom: ctypes.int32_t }, - { right : ctypes.int32_t }]); - - let test_pt_in_rect = library.declare("test_pt_in_rect", ctypes.default_abi, ctypes.int32_t, rect_t, point_t); - let rect = new rect_t(10, 5, 5, 10); - let pt1 = new point_t(6, 6); - do_check_eq(test_pt_in_rect(rect, pt1), 1); - let pt2 = new point_t(2, 2); - do_check_eq(test_pt_in_rect(rect, pt2), 0); - - const inner_t = new ctypes.StructType("INNER", - [{ i1: ctypes.uint8_t }, - { i2: ctypes.int64_t }, - { i3: ctypes.uint8_t }]); - const nested_t = new ctypes.StructType("NESTED", - [{ n1 : ctypes.int32_t }, - { n2 : ctypes.int16_t }, - { inner: inner_t }, - { n3 : ctypes.int64_t }, - { n4 : ctypes.int32_t }]); - - let test_nested_struct = library.declare("test_nested_struct", ctypes.default_abi, ctypes.int32_t, nested_t); - let inner = new inner_t(161, 523412, 43); - let nested = new nested_t(13155, 1241, inner, 24512115, 1234111); - // add up all the numbers and make sure the C function agrees - do_check_eq(test_nested_struct(nested), 26284238); - - // test returning a struct by value - let test_struct_return = library.declare("test_struct_return", ctypes.default_abi, point_t, rect_t); - let ret = test_struct_return(rect); - do_check_eq(ret.x, rect.left); - do_check_eq(ret.y, rect.top); - - // struct parameter ABI depends on size; test returning a large struct by value - test_struct_return = library.declare("test_large_struct_return", ctypes.default_abi, rect_t, rect_t, rect_t); - ret = test_struct_return(rect_t(1, 2, 3, 4), rect_t(5, 6, 7, 8)); - do_check_eq(ret.left, 2); - do_check_eq(ret.right, 4); - do_check_eq(ret.top, 5); - do_check_eq(ret.bottom, 7); - - // ... and tests structs < 8 bytes in size - for (let i = 1; i < 8; ++i) - run_small_struct_test(library, rect_t, i); - - // test passing a struct by pointer - let test_init_pt = library.declare("test_init_pt", ctypes.default_abi, ctypes.void_t, point_t.ptr, ctypes.int32_t, ctypes.int32_t); - test_init_pt(pt1.address(), 9, 10); - do_check_eq(pt1.x, 9); - do_check_eq(pt1.y, 10); -} - -function run_small_struct_test(library, rect_t, bytes) -{ - let fields = []; - for (let i = 0; i < bytes; ++i) { - let field = {}; - field["f" + i] = ctypes.uint8_t; - fields.push(field); - } - const small_t = new ctypes.StructType("SMALL", fields); - - let test_small_struct_return = library.declare("test_" + bytes + "_byte_struct_return", ctypes.default_abi, small_t, rect_t); - let ret = test_small_struct_return(rect_t(1, 7, 13, 45)); - - let exp = [1, 7, 13, 45]; - let j = 0; - for (let i = 0; i < bytes; ++i) { - do_check_eq(ret["f" + i], exp[j]); - if (++j == 4) - j = 0; - } -} - -function run_function_tests(library) -{ - let test_ansi_len = library.declare("test_ansi_len", ctypes.default_abi, - ctypes.int32_t, ctypes.char.ptr); - let fn_t = ctypes.FunctionType(ctypes.default_abi, ctypes.int32_t, - [ ctypes.char.ptr ]).ptr; - - let test_fnptr = library.declare("test_fnptr", ctypes.default_abi, fn_t); - - // Test that the value handed back by test_fnptr matches the function pointer - // for test_ansi_len itself. - let ptr = test_fnptr(); - do_check_eq(ptrValue(test_ansi_len), ptrValue(ptr)); - - // Test that we can call ptr(). - do_check_eq(ptr("function pointers rule!"), 23); - - // Test that we can call via call and apply - do_check_eq(ptr.call(null, "function pointers rule!"), 23); - do_check_eq(ptr.apply(null, ["function pointers rule!"]), 23); - - // Test that we cannot call non-function pointers via call and apply - let p_t = ctypes.PointerType(ctypes.int32_t); - let p = p_t(); - do_check_throws(function() { p.call(null, "woo"); }, TypeError); - do_check_throws(function() { p.apply(null, ["woo"]); }, TypeError); - - // Test the function pointers still behave as regular pointers - do_check_false(ptr.isNull(), "PointerType methods should still be valid"); - - // Test that library.declare() returns data of type FunctionType.ptr, and that - // it is immutable. - do_check_true(test_ansi_len.constructor.targetType.__proto__ === - ctypes.FunctionType.prototype); - do_check_eq(test_ansi_len.constructor.toSource(), - "ctypes.FunctionType(ctypes.default_abi, ctypes.int32_t, [ctypes.char.ptr]).ptr"); -/* disabled temporarily per bug 598225. - do_check_throws(function() { test_ansi_len.value = null; }, Error); - do_check_eq(ptrValue(test_ansi_len), ptrValue(ptr)); -*/ - - // Test that the library.declare(name, functionType) form works. - let test_ansi_len_2 = library.declare("test_ansi_len", fn_t); - do_check_true(test_ansi_len_2.constructor === fn_t); - do_check_eq(ptrValue(test_ansi_len), ptrValue(test_ansi_len_2)); -/* disabled temporarily per bug 598225. - do_check_throws(function() { test_ansi_len_2.value = null; }, Error); - do_check_eq(ptrValue(test_ansi_len_2), ptrValue(ptr)); -*/ -} - -function run_closure_tests(library) -{ - run_single_closure_tests(library, ctypes.default_abi, "cdecl"); - if ("winLastError" in ctypes) { - run_single_closure_tests(library, ctypes.stdcall_abi, "stdcall"); - - // Check that attempting to construct a ctypes.winapi_abi closure throws. - function closure_fn() - { - return 1; - } - let fn_t = ctypes.FunctionType(ctypes.winapi_abi, ctypes.int32_t, []).ptr; - do_check_throws(function() { fn_t(closure_fn) }, Error); - } -} - -function run_single_closure_tests(library, abi, suffix) -{ - let b = 23; - - function closure_fn(i) - { - if (i == 42) - throw "7.5 million years for that?"; - return "a" in this ? i + this.a : i + b; - } - - do_check_eq(closure_fn(7), 7 + b); - let thisobj = { a: 5 }; - do_check_eq(closure_fn.call(thisobj, 7), 7 + thisobj.a); - - // Construct a closure, and call it ourselves. - let fn_t = ctypes.FunctionType(abi, ctypes.int32_t, [ ctypes.int8_t ]).ptr; - let closure = fn_t(closure_fn); - do_check_eq(closure(-17), -17 + b); - - // Have C code call it. - let test_closure = library.declare("test_closure_" + suffix, - ctypes.default_abi, ctypes.int32_t, ctypes.int8_t, fn_t); - do_check_eq(test_closure(-52, closure), -52 + b); - - // Do the same, but specify 'this'. - let closure2 = fn_t(closure_fn, thisobj); - do_check_eq(closure2(-17), -17 + thisobj.a); - do_check_eq(test_closure(-52, closure2), -52 + thisobj.a); - - // Specify an error sentinel, and have the JS code throw (see bug 599791). - let closure3 = fn_t(closure_fn, null, 54); - do_check_eq(closure3(42), 54); - do_check_eq(test_closure(42, closure3), 54); - - // Check what happens when the return type is bigger than a word. - var fn_64_t = ctypes.FunctionType(ctypes.default_abi, ctypes.uint64_t, [ctypes.bool]).ptr; - var bignum1 = ctypes.UInt64.join(0xDEADBEEF, 0xBADF00D); - var bignum2 = ctypes.UInt64.join(0xDEFEC8ED, 0xD15EA5E); - function closure_fn_64(fail) - { - if (fail) - throw "Just following orders, sir!"; - return bignum1; - } - var closure64 = fn_64_t(closure_fn_64, null, bignum2); - do_check_eq(ctypes.UInt64.compare(closure64(false), bignum1), 0); - do_check_eq(ctypes.UInt64.compare(closure64(true), bignum2), 0); - - // Test a callback that returns void (see bug 682504). - var fn_v_t = ctypes.FunctionType(ctypes.default_abi, ctypes.void_t, []).ptr; - fn_v_t(function() {})(); // Don't crash - - // Code evaluated in a sandbox uses (and pushes) a separate JSContext. - // Make sure that we don't run into an assertion caused by a cx stack - // mismatch with the cx stashed in the closure. - try { - var sb = Components.utils.Sandbox("http://www.example.com"); - sb.fn = fn_v_t(function() { sb.foo = {}; }); - Components.utils.evalInSandbox("fn();", sb); - } catch (e) {} // Components not available in workers. - - // Make sure that a void callback can't return an error sentinel. - var sentinelThrew = false; - try { - fn_v_t(function() {}, null, -1); - } catch (e) { - sentinelThrew = true; - } - do_check_true(sentinelThrew); -} - -function run_variadic_tests(library) { - let sum_va_type = ctypes.FunctionType(ctypes.default_abi, - ctypes.int32_t, - [ctypes.uint8_t, "..."]).ptr, - sum_va = library.declare("test_sum_va_cdecl", ctypes.default_abi, ctypes.int32_t, - ctypes.uint8_t, "..."); - - do_check_eq(sum_va_type.toSource(), - 'ctypes.FunctionType(ctypes.default_abi, ctypes.int32_t, [ctypes.uint8_t, "..."]).ptr'); - do_check_eq(sum_va.constructor.name, "int32_t(*)(uint8_t, ...)"); - do_check_true(sum_va.constructor.targetType.isVariadic); - - do_check_eq(sum_va(3, - ctypes.int32_t(1), - ctypes.int32_t(2), - ctypes.int32_t(3)), - 6); - - do_check_throws(function() { - ctypes.FunctionType(ctypes.default_abi, ctypes.bool, - [ctypes.bool, "...", ctypes.bool]); - }, Error); - - do_check_throws(function() { - ctypes.FunctionType(ctypes.default_abi, ctypes.bool, ["..."]); - }, Error); - - if ("winLastError" in ctypes) { - do_check_throws(function() { - ctypes.FunctionType(ctypes.stdcall_abi, ctypes.bool, - [ctypes.bool, "..."]); - }, Error); - do_check_throws(function() { - ctypes.FunctionType(ctypes.winapi_abi, ctypes.bool, - [ctypes.bool, "..."]); - }, Error); - } - - do_check_throws(function() { - // No variadic closure callbacks allowed. - sum_va_type(function() {}); - }, Error); - - let count_true_va = library.declare("test_sum_va_cdecl", ctypes.default_abi, ctypes.uint8_t, - ctypes.uint8_t, "..."); - do_check_eq(count_true_va(8, - ctypes.bool(false), - ctypes.bool(false), - ctypes.bool(false), - ctypes.bool(true), - ctypes.bool(true), - ctypes.bool(false), - ctypes.bool(true), - ctypes.bool(true)), - 4); - - let add_char_short_int_va = library.declare("test_add_char_short_int_va_cdecl", - ctypes.default_abi, ctypes.void_t, - ctypes.uint32_t.ptr, "..."), - result = ctypes.uint32_t(3); - - add_char_short_int_va(result.address(), - ctypes.char(5), - ctypes.short(7), - ctypes.uint32_t(11)); - - do_check_eq(result.value, 3 + 5 + 7 + 11); - - result = ctypes.int32_t.array(3)([1, 1, 1]), - v1 = ctypes.int32_t.array(4)([1, 2, 3, 5]), - v2 = ctypes.int32_t.array(3)([7, 11, 13]), - vector_add_va = library.declare("test_vector_add_va_cdecl", - ctypes.default_abi, ctypes.int32_t.ptr, - ctypes.uint8_t, ctypes.uint8_t, "..."), - // Note that vector_add_va zeroes out result first. - vec_sum = vector_add_va(2, 3, result, v1, v2); - do_check_eq(vec_sum.contents, 8); - do_check_eq(result[0], 8); - do_check_eq(result[1], 13); - do_check_eq(result[2], 16); - - do_check_true(!!(sum_va_type().value = sum_va_type())); - let sum_notva_type = ctypes.FunctionType(sum_va_type.targetType.abi, - sum_va_type.targetType.returnType, - [ctypes.uint8_t]).ptr; - do_check_throws(function() { - sum_va_type().value = sum_notva_type(); - }, TypeError); -} - -function run_static_data_tests(library) -{ - const rect_t = new ctypes.StructType("myRECT", - [{ top : ctypes.int32_t }, - { left : ctypes.int32_t }, - { bottom: ctypes.int32_t }, - { right : ctypes.int32_t }]); - - let data_rect = library.declare("data_rect", rect_t); - - // Test reading static data. - do_check_true(data_rect.constructor === rect_t); - do_check_eq(data_rect.top, -1); - do_check_eq(data_rect.left, -2); - do_check_eq(data_rect.bottom, 3); - do_check_eq(data_rect.right, 4); - - // Test writing. - data_rect.top = 9; - data_rect.left = 8; - data_rect.bottom = -11; - data_rect.right = -12; - do_check_eq(data_rect.top, 9); - do_check_eq(data_rect.left, 8); - do_check_eq(data_rect.bottom, -11); - do_check_eq(data_rect.right, -12); - - // Make sure it's been written, not copied. - let data_rect_2 = library.declare("data_rect", rect_t); - do_check_eq(data_rect_2.top, 9); - do_check_eq(data_rect_2.left, 8); - do_check_eq(data_rect_2.bottom, -11); - do_check_eq(data_rect_2.right, -12); - do_check_eq(ptrValue(data_rect.address()), ptrValue(data_rect_2.address())); -} - -function run_cpp_class_tests(library) -{ - // try the gcc mangling, unless we're using MSVC. - let OS = get_os(); - let ctor_symbol; - let add_symbol; - let abi; - if (OS == "WINNT") { - // for compatibility for Win32 vs Win64 - abi = ctypes.thiscall_abi; - if (ctypes.size_t.size == 8) { - ctor_symbol = '??0TestClass@@QEAA@H@Z'; - add_symbol = '?Add@TestClass@@QEAAHH@Z'; - } else { - ctor_symbol = '??0TestClass@@QAE@H@Z'; - add_symbol = '?Add@TestClass@@QAEHH@Z'; - } - } else { - abi = ctypes.default_abi; - ctor_symbol = "_ZN9TestClassC1Ei"; - add_symbol = "_ZN9TestClass3AddEi"; - } - - let test_class_ctor = library.declare(ctor_symbol, abi, ctypes.void_t, - ctypes.int32_t.ptr, ctypes.int32_t); - let i = ctypes.int32_t(); - test_class_ctor(i.address(), 8); - do_check_eq(i.value, 8); - - let test_class_add = library.declare(add_symbol, abi, ctypes.int32_t, - ctypes.int32_t.ptr, ctypes.int32_t); - let j = test_class_add(i.address(), 5); - do_check_eq(j, 13); - do_check_eq(i.value, 13); -} - -// bug 522360 - try loading system library without full path -function run_load_system_library() -{ - let syslib; - let OS = get_os(); - if (OS == "WINNT") { - syslib = ctypes.open("user32.dll"); - } else if (OS == "Darwin") { - syslib = ctypes.open("libm.dylib"); - } else if (OS == "Linux" || OS == "Android" || OS.match(/BSD$/)) { - try { - syslib = ctypes.open("libm.so"); - } catch (e) { - // limb.so wasn't available, try libm.so.6 instead - syslib = ctypes.open("libm.so.6"); - } - } else { - do_throw("please add a system library for this test"); - } - syslib.close(); - return true; -} |