diff options
Diffstat (limited to 'test/fiddle')
| -rw-r--r-- | test/fiddle/helper.rb | 154 | ||||
| -rw-r--r-- | test/fiddle/test_c_struct_entry.rb | 77 | ||||
| -rw-r--r-- | test/fiddle/test_c_union_entity.rb | 35 | ||||
| -rw-r--r-- | test/fiddle/test_closure.rb | 85 | ||||
| -rw-r--r-- | test/fiddle/test_cparser.rb | 217 | ||||
| -rw-r--r-- | test/fiddle/test_fiddle.rb | 17 | ||||
| -rw-r--r-- | test/fiddle/test_func.rb | 83 | ||||
| -rw-r--r-- | test/fiddle/test_function.rb | 117 | ||||
| -rw-r--r-- | test/fiddle/test_handle.rb | 175 | ||||
| -rw-r--r-- | test/fiddle/test_import.rb | 228 | ||||
| -rw-r--r-- | test/fiddle/test_pointer.rb | 241 |
11 files changed, 0 insertions, 1429 deletions
diff --git a/test/fiddle/helper.rb b/test/fiddle/helper.rb deleted file mode 100644 index f405b53a53..0000000000 --- a/test/fiddle/helper.rb +++ /dev/null @@ -1,154 +0,0 @@ -# frozen_string_literal: true -require 'test/unit' -require 'fiddle' - -# FIXME: this is stolen from DL and needs to be refactored. - -libc_so = libm_so = nil - -case RUBY_PLATFORM -when /cygwin/ - libc_so = "cygwin1.dll" - libm_so = "cygwin1.dll" -when /android/ - libdir = '/system/lib' - if [0].pack('L!').size == 8 - libdir = '/system/lib64' - end - libc_so = File.join(libdir, "libc.so") - libm_so = File.join(libdir, "libm.so") -when /linux-musl/ - Dir.glob('/lib/ld-musl-*.so.1') do |ld| - libc_so = libm_so = ld - end -when /linux/ - libdir = '/lib' - case RbConfig::SIZEOF['void*'] - when 4 - # 32-bit ruby - case RUBY_PLATFORM - when /armv\w+-linux/ - # In the ARM 32-bit libc package such as libc6:armhf libc6:armel, - # libc.so and libm.so are installed to /lib/arm-linux-gnu*. - # It's not installed to /lib32. - dir, = Dir.glob('/lib/arm-linux-gnu*') - libdir = dir if dir && File.directory?(dir) - else - libdir = '/lib32' if File.directory? '/lib32' - end - when 8 - # 64-bit ruby - libdir = '/lib64' if File.directory? '/lib64' - end - - # Handle musl libc - libc_so, = Dir.glob(File.join(libdir, "libc.musl*.so*")) - if libc_so - libm_so = libc_so - else - # glibc - libc_so = File.join(libdir, "libc.so.6") - libm_so = File.join(libdir, "libm.so.6") - end -when /mingw/, /mswin/ - require "rbconfig" - crtname = RbConfig::CONFIG["RUBY_SO_NAME"][/msvc\w+/] || 'ucrtbase' - libc_so = libm_so = "#{crtname}.dll" -when /darwin/ - libc_so = "/usr/lib/libc.dylib" - libm_so = "/usr/lib/libm.dylib" -when /kfreebsd/ - libc_so = "/lib/libc.so.0.1" - libm_so = "/lib/libm.so.1" -when /gnu/ #GNU/Hurd - libc_so = "/lib/libc.so.0.3" - libm_so = "/lib/libm.so.6" -when /mirbsd/ - libc_so = "/usr/lib/libc.so.41.10" - libm_so = "/usr/lib/libm.so.7.0" -when /freebsd/ - libc_so = "/lib/libc.so.7" - libm_so = "/lib/libm.so.5" -when /bsd|dragonfly/ - libc_so = "/usr/lib/libc.so" - libm_so = "/usr/lib/libm.so" -when /solaris/ - libdir = '/lib' - case RbConfig::SIZEOF['void*'] - when 4 - # 32-bit ruby - libdir = '/lib' if File.directory? '/lib' - when 8 - # 64-bit ruby - libdir = '/lib/64' if File.directory? '/lib/64' - end - libc_so = File.join(libdir, "libc.so") - libm_so = File.join(libdir, "libm.so") -when /aix/ - pwd=Dir.pwd - libc_so = libm_so = "#{pwd}/libaixdltest.so" - unless File.exist? libc_so - cobjs=%w!strcpy.o! - mobjs=%w!floats.o sin.o! - funcs=%w!sin sinf strcpy strncpy! - expfile='dltest.exp' - require 'tmpdir' - Dir.mktmpdir do |dir| - begin - Dir.chdir dir - %x!/usr/bin/ar x /usr/lib/libc.a #{cobjs.join(' ')}! - %x!/usr/bin/ar x /usr/lib/libm.a #{mobjs.join(' ')}! - %x!echo "#{funcs.join("\n")}\n" > #{expfile}! - require 'rbconfig' - if RbConfig::CONFIG["GCC"] = 'yes' - lflag='-Wl,' - else - lflag='' - end - flags="#{lflag}-bE:#{expfile} #{lflag}-bnoentry -lm" - %x!#{RbConfig::CONFIG["LDSHARED"]} -o #{libc_so} #{(cobjs+mobjs).join(' ')} #{flags}! - ensure - Dir.chdir pwd - end - end - end -else - libc_so = ARGV[0] if ARGV[0] && ARGV[0][0] == ?/ - libm_so = ARGV[1] if ARGV[1] && ARGV[1][0] == ?/ - if( !(libc_so && libm_so) ) - $stderr.puts("libc and libm not found: #{$0} <libc> <libm>") - end -end - -libc_so = nil if !libc_so || (libc_so[0] == ?/ && !File.file?(libc_so)) -libm_so = nil if !libm_so || (libm_so[0] == ?/ && !File.file?(libm_so)) - -if !libc_so || !libm_so - ruby = EnvUtil.rubybin - # When the ruby binary is 32-bit and the host is 64-bit, - # `ldd ruby` outputs "not a dynamic executable" message. - # libc_so and libm_so are not set. - ldd = `ldd #{ruby}` - #puts ldd - libc_so = $& if !libc_so && %r{/\S*/libc\.so\S*} =~ ldd - libm_so = $& if !libm_so && %r{/\S*/libm\.so\S*} =~ ldd - #p [libc_so, libm_so] -end - -Fiddle::LIBC_SO = libc_so -Fiddle::LIBM_SO = libm_so - -module Fiddle - class TestCase < Test::Unit::TestCase - def setup - @libc = Fiddle.dlopen(LIBC_SO) - @libm = Fiddle.dlopen(LIBM_SO) - end - - def teardown - if /linux/ =~ RUBY_PLATFORM - GC.start - end - end - end -end diff --git a/test/fiddle/test_c_struct_entry.rb b/test/fiddle/test_c_struct_entry.rb deleted file mode 100644 index 33bfee6218..0000000000 --- a/test/fiddle/test_c_struct_entry.rb +++ /dev/null @@ -1,77 +0,0 @@ -# frozen_string_literal: true -begin - require_relative 'helper' - require 'fiddle/struct' -rescue LoadError -end - -module Fiddle - class TestCStructEntity < TestCase - def test_class_size - types = [TYPE_DOUBLE, TYPE_CHAR] - - size = CStructEntity.size types - - alignments = types.map { |type| PackInfo::ALIGN_MAP[type] } - - expected = PackInfo.align 0, alignments[0] - expected += PackInfo::SIZE_MAP[TYPE_DOUBLE] - - expected = PackInfo.align expected, alignments[1] - expected += PackInfo::SIZE_MAP[TYPE_CHAR] - - expected = PackInfo.align expected, alignments.max - - assert_equal expected, size - end - - def test_class_size_with_count - size = CStructEntity.size([[TYPE_DOUBLE, 2], [TYPE_CHAR, 20]]) - - types = [TYPE_DOUBLE, TYPE_CHAR] - alignments = types.map { |type| PackInfo::ALIGN_MAP[type] } - - expected = PackInfo.align 0, alignments[0] - expected += PackInfo::SIZE_MAP[TYPE_DOUBLE] * 2 - - expected = PackInfo.align expected, alignments[1] - expected += PackInfo::SIZE_MAP[TYPE_CHAR] * 20 - - expected = PackInfo.align expected, alignments.max - - assert_equal expected, size - end - - def test_set_ctypes - union = CStructEntity.malloc [TYPE_INT, TYPE_LONG], Fiddle::RUBY_FREE - union.assign_names %w[int long] - - # this test is roundabout because the stored ctypes are not accessible - union['long'] = 1 - union['int'] = 2 - - assert_equal 1, union['long'] - assert_equal 2, union['int'] - end - - def test_aref_pointer_array - team = CStructEntity.malloc([[TYPE_VOIDP, 2]], Fiddle::RUBY_FREE) - team.assign_names(["names"]) - alice = Fiddle::Pointer.malloc(6, Fiddle::RUBY_FREE) - alice[0, 6] = "Alice\0" - bob = Fiddle::Pointer.malloc(4, Fiddle::RUBY_FREE) - bob[0, 4] = "Bob\0" - team["names"] = [alice, bob] - assert_equal(["Alice", "Bob"], team["names"].map(&:to_s)) - end - - def test_aref_pointer - user = CStructEntity.malloc([TYPE_VOIDP], Fiddle::RUBY_FREE) - user.assign_names(["name"]) - alice = Fiddle::Pointer.malloc(6, Fiddle::RUBY_FREE) - alice[0, 6] = "Alice\0" - user["name"] = alice - assert_equal("Alice", user["name"].to_s) - end - end -end if defined?(Fiddle) diff --git a/test/fiddle/test_c_union_entity.rb b/test/fiddle/test_c_union_entity.rb deleted file mode 100644 index 9310084733..0000000000 --- a/test/fiddle/test_c_union_entity.rb +++ /dev/null @@ -1,35 +0,0 @@ -# frozen_string_literal: true -begin - require_relative 'helper' - require 'fiddle/struct' -rescue LoadError -end - - -module Fiddle - class TestCUnionEntity < TestCase - def test_class_size - size = CUnionEntity.size([TYPE_DOUBLE, TYPE_CHAR]) - - assert_equal SIZEOF_DOUBLE, size - end - - def test_class_size_with_count - size = CUnionEntity.size([[TYPE_DOUBLE, 2], [TYPE_CHAR, 20]]) - - assert_equal SIZEOF_CHAR * 20, size - end - - def test_set_ctypes - union = CUnionEntity.malloc [TYPE_INT, TYPE_LONG], Fiddle::RUBY_FREE - union.assign_names %w[int long] - - # this test is roundabout because the stored ctypes are not accessible - union['long'] = 1 - assert_equal 1, union['long'] - - union['int'] = 1 - assert_equal 1, union['int'] - end - end -end if defined?(Fiddle) diff --git a/test/fiddle/test_closure.rb b/test/fiddle/test_closure.rb deleted file mode 100644 index 2de0660725..0000000000 --- a/test/fiddle/test_closure.rb +++ /dev/null @@ -1,85 +0,0 @@ -# frozen_string_literal: true -begin - require_relative 'helper' -rescue LoadError -end - -module Fiddle - class TestClosure < Fiddle::TestCase - def test_argument_errors - assert_raise(TypeError) do - Closure.new(TYPE_INT, TYPE_INT) - end - - assert_raise(TypeError) do - Closure.new('foo', [TYPE_INT]) - end - - assert_raise(TypeError) do - Closure.new(TYPE_INT, ['meow!']) - end - end - - def test_call - closure = Class.new(Closure) { - def call - 10 - end - }.new(TYPE_INT, []) - - func = Function.new(closure, [], TYPE_INT) - assert_equal 10, func.call - end - - def test_returner - closure = Class.new(Closure) { - def call thing - thing - end - }.new(TYPE_INT, [TYPE_INT]) - - func = Function.new(closure, [TYPE_INT], TYPE_INT) - assert_equal 10, func.call(10) - end - - def test_block_caller - cb = Closure::BlockCaller.new(TYPE_INT, [TYPE_INT]) do |one| - one - end - func = Function.new(cb, [TYPE_INT], TYPE_INT) - assert_equal 11, func.call(11) - end - - def test_memsize - require 'objspace' - bug = '[ruby-dev:42480]' - n = 10000 - assert_equal(n, n.times {ObjectSpace.memsize_of(Closure.allocate)}, bug) - end - - %w[INT SHORT CHAR LONG LONG_LONG].each do |name| - type = Fiddle.const_get("TYPE_#{name}") rescue next - size = Fiddle.const_get("SIZEOF_#{name}") - [[type, size-1, name], [-type, size, "unsigned_"+name]].each do |t, s, n| - define_method("test_conversion_#{n.downcase}") do - arg = nil - - clos = Class.new(Closure) do - define_method(:call) {|x| arg = x} - end.new(t, [t]) - - v = ~(~0 << (8*s)) - - arg = nil - assert_equal(v, clos.call(v)) - assert_equal(arg, v, n) - - arg = nil - func = Function.new(clos, [t], t) - assert_equal(v, func.call(v)) - assert_equal(arg, v, n) - end - end - end - end -end if defined?(Fiddle) diff --git a/test/fiddle/test_cparser.rb b/test/fiddle/test_cparser.rb deleted file mode 100644 index 5d9ac3c815..0000000000 --- a/test/fiddle/test_cparser.rb +++ /dev/null @@ -1,217 +0,0 @@ -# frozen_string_literal: true -begin - require_relative 'helper' - require 'fiddle/cparser' -rescue LoadError -end - -module Fiddle - class TestCParser < TestCase - include CParser - - def test_char_ctype - assert_equal(TYPE_CHAR, parse_ctype('char')) - assert_equal(TYPE_CHAR, parse_ctype('signed char')) - assert_equal(-TYPE_CHAR, parse_ctype('unsigned char')) - end - - def test_short_ctype - assert_equal(TYPE_SHORT, parse_ctype('short')) - assert_equal(TYPE_SHORT, parse_ctype('short int')) - assert_equal(TYPE_SHORT, parse_ctype('signed short')) - assert_equal(TYPE_SHORT, parse_ctype('signed short int')) - assert_equal(-TYPE_SHORT, parse_ctype('unsigned short')) - assert_equal(-TYPE_SHORT, parse_ctype('unsigned short int')) - end - - def test_int_ctype - assert_equal(TYPE_INT, parse_ctype('int')) - assert_equal(TYPE_INT, parse_ctype('signed int')) - assert_equal(-TYPE_INT, parse_ctype('uint')) - assert_equal(-TYPE_INT, parse_ctype('unsigned int')) - end - - def test_long_ctype - assert_equal(TYPE_LONG, parse_ctype('long')) - assert_equal(TYPE_LONG, parse_ctype('long int')) - assert_equal(TYPE_LONG, parse_ctype('signed long')) - assert_equal(TYPE_LONG, parse_ctype('signed long int')) - assert_equal(-TYPE_LONG, parse_ctype('unsigned long')) - assert_equal(-TYPE_LONG, parse_ctype('unsigned long int')) - end - - def test_size_t_ctype - assert_equal(TYPE_SIZE_T, parse_ctype("size_t")) - end - - def test_ssize_t_ctype - assert_equal(TYPE_SSIZE_T, parse_ctype("ssize_t")) - end - - def test_ptrdiff_t_ctype - assert_equal(TYPE_PTRDIFF_T, parse_ctype("ptrdiff_t")) - end - - def test_intptr_t_ctype - assert_equal(TYPE_INTPTR_T, parse_ctype("intptr_t")) - end - - def test_uintptr_t_ctype - assert_equal(TYPE_UINTPTR_T, parse_ctype("uintptr_t")) - end - - def test_undefined_ctype - assert_raise(DLError) { parse_ctype('DWORD') } - end - - def test_undefined_ctype_with_type_alias - assert_equal(-TYPE_LONG, parse_ctype('DWORD', {"DWORD" => "unsigned long"})) - end - - def test_struct_basic - assert_equal [[TYPE_INT, TYPE_CHAR], ['i', 'c']], parse_struct_signature(['int i', 'char c']) - end - - def test_struct_array - assert_equal [[[TYPE_CHAR,80],[TYPE_INT,5]], ['buffer','x']], parse_struct_signature(['char buffer[80]', 'int[5] x']) - end - - def test_struct_array_str - assert_equal [[[TYPE_CHAR,80],[TYPE_INT,5]], ['buffer','x']], parse_struct_signature('char buffer[80], int[5] x') - end - - def test_struct_function_pointer - assert_equal [[TYPE_VOIDP], ['cb']], parse_struct_signature(['void (*cb)(const char*)']) - end - - def test_struct_function_pointer_str - assert_equal [[TYPE_VOIDP,TYPE_VOIDP], ['cb', 'data']], parse_struct_signature('void (*cb)(const char*), const char* data') - end - - def test_struct_string - assert_equal [[TYPE_INT,TYPE_VOIDP,TYPE_VOIDP], ['x', 'cb', 'name']], parse_struct_signature('int x; void (*cb)(); const char* name') - end - - def test_struct_undefined - assert_raise(DLError) { parse_struct_signature(['int i', 'DWORD cb']) } - end - - def test_struct_undefined_with_type_alias - assert_equal [[TYPE_INT,-TYPE_LONG], ['i', 'cb']], parse_struct_signature(['int i', 'DWORD cb'], {"DWORD" => "unsigned long"}) - end - - def test_signature_basic - func, ret, args = parse_signature('void func()') - assert_equal 'func', func - assert_equal TYPE_VOID, ret - assert_equal [], args - end - - def test_signature_semi - func, ret, args = parse_signature('void func();') - assert_equal 'func', func - assert_equal TYPE_VOID, ret - assert_equal [], args - end - - def test_signature_void_arg - func, ret, args = parse_signature('void func(void)') - assert_equal 'func', func - assert_equal TYPE_VOID, ret - assert_equal [], args - end - - def test_signature_type_args - types = [ - 'char', 'unsigned char', - 'short', 'unsigned short', - 'int', 'unsigned int', - 'long', 'unsigned long', - defined?(TYPE_LONG_LONG) && \ - [ - 'long long', 'unsigned long long', - ], - 'float', 'double', - 'const char*', 'void*', - ].flatten.compact - func, ret, args = parse_signature("void func(#{types.join(',')})") - assert_equal 'func', func - assert_equal TYPE_VOID, ret - assert_equal [ - TYPE_CHAR, -TYPE_CHAR, - TYPE_SHORT, -TYPE_SHORT, - TYPE_INT, -TYPE_INT, - TYPE_LONG, -TYPE_LONG, - defined?(TYPE_LONG_LONG) && \ - [ - TYPE_LONG_LONG, -TYPE_LONG_LONG, - ], - TYPE_FLOAT, TYPE_DOUBLE, - TYPE_VOIDP, TYPE_VOIDP, - ].flatten.compact, args - end - - def test_signature_single_variable - func, ret, args = parse_signature('void func(int x)') - assert_equal 'func', func - assert_equal TYPE_VOID, ret - assert_equal [TYPE_INT], args - end - - def test_signature_multiple_variables - func, ret, args = parse_signature('void func(int x, const char* s)') - assert_equal 'func', func - assert_equal TYPE_VOID, ret - assert_equal [TYPE_INT, TYPE_VOIDP], args - end - - def test_signature_array_variable - func, ret, args = parse_signature('void func(int x[], int y[40])') - assert_equal 'func', func - assert_equal TYPE_VOID, ret - assert_equal [TYPE_VOIDP, TYPE_VOIDP], args - end - - def test_signature_function_pointer - func, ret, args = parse_signature('int func(int (*sum)(int x, int y), int x, int y)') - assert_equal 'func', func - assert_equal TYPE_INT, ret - assert_equal [TYPE_VOIDP, TYPE_INT, TYPE_INT], args - end - - def test_signature_return_pointer - func, ret, args = parse_signature('void* malloc(size_t)') - assert_equal 'malloc', func - assert_equal TYPE_VOIDP, ret - assert_equal [TYPE_SIZE_T], args - end - - def test_signature_return_array - func, ret, args = parse_signature('int (*func())[32]') - assert_equal 'func', func - assert_equal TYPE_VOIDP, ret - assert_equal [], args - end - - def test_signature_return_array_with_args - func, ret, args = parse_signature('int (*func(const char* s))[]') - assert_equal 'func', func - assert_equal TYPE_VOIDP, ret - assert_equal [TYPE_VOIDP], args - end - - def test_signature_return_function_pointer - func, ret, args = parse_signature('int (*func())(int x, int y)') - assert_equal 'func', func - assert_equal TYPE_VOIDP, ret - assert_equal [], args - end - - def test_signature_return_function_pointer_with_args - func, ret, args = parse_signature('int (*func(int z))(int x, int y)') - assert_equal 'func', func - assert_equal TYPE_VOIDP, ret - assert_equal [TYPE_INT], args - end - end -end if defined?(Fiddle) diff --git a/test/fiddle/test_fiddle.rb b/test/fiddle/test_fiddle.rb deleted file mode 100644 index 8751d96920..0000000000 --- a/test/fiddle/test_fiddle.rb +++ /dev/null @@ -1,17 +0,0 @@ -# frozen_string_literal: true -begin - require_relative 'helper' -rescue LoadError -end - -class TestFiddle < Fiddle::TestCase - def test_windows_constant - require 'rbconfig' - if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ - assert Fiddle::WINDOWS, "Fiddle::WINDOWS should be 'true' on Windows platforms" - else - refute Fiddle::WINDOWS, "Fiddle::WINDOWS should be 'false' on non-Windows platforms" - end - end - -end if defined?(Fiddle) diff --git a/test/fiddle/test_func.rb b/test/fiddle/test_func.rb deleted file mode 100644 index ca89173766..0000000000 --- a/test/fiddle/test_func.rb +++ /dev/null @@ -1,83 +0,0 @@ -# frozen_string_literal: true -begin - require_relative 'helper' -rescue LoadError -end - -module Fiddle - class TestFunc < TestCase - def test_random - f = Function.new(@libc['srand'], [-TYPE_LONG], TYPE_VOID) - assert_nil f.call(10) - end - - def test_sinf - begin - f = Function.new(@libm['sinf'], [TYPE_FLOAT], TYPE_FLOAT) - rescue Fiddle::DLError - skip "libm may not have sinf()" - end - assert_in_delta 1.0, f.call(90 * Math::PI / 180), 0.0001 - end - - def test_sin - f = Function.new(@libm['sin'], [TYPE_DOUBLE], TYPE_DOUBLE) - assert_in_delta 1.0, f.call(90 * Math::PI / 180), 0.0001 - end - - def test_string - stress, GC.stress = GC.stress, true - f = Function.new(@libc['strcpy'], [TYPE_VOIDP, TYPE_VOIDP], TYPE_VOIDP) - buff = +"000" - str = f.call(buff, "123") - assert_equal("123", buff) - assert_equal("123", str.to_s) - ensure - GC.stress = stress - end - - def test_isdigit - f = Function.new(@libc['isdigit'], [TYPE_INT], TYPE_INT) - r1 = f.call(?1.ord) - r2 = f.call(?2.ord) - rr = f.call(?r.ord) - assert_operator r1, :>, 0 - assert_operator r2, :>, 0 - assert_equal 0, rr - end - - def test_atof - f = Function.new(@libc['atof'], [TYPE_VOIDP], TYPE_DOUBLE) - r = f.call("12.34") - assert_includes(12.00..13.00, r) - end - - def test_strtod - f = Function.new(@libc['strtod'], [TYPE_VOIDP, TYPE_VOIDP], TYPE_DOUBLE) - buff1 = Pointer["12.34"] - buff2 = buff1 + 4 - r = f.call(buff1, - buff2) - assert_in_delta(12.34, r, 0.001) - end - - def test_qsort1 - cb = Class.new(Closure) { - def call(x, y) - Pointer.new(x)[0] <=> Pointer.new(y)[0] - end - }.new(TYPE_INT, [TYPE_VOIDP, TYPE_VOIDP]) - - qsort = Function.new(@libc['qsort'], - [TYPE_VOIDP, TYPE_SIZE_T, TYPE_SIZE_T, TYPE_VOIDP], - TYPE_VOID) - buff = "9341" - qsort.call(buff, buff.size, 1, cb) - assert_equal("1349", buff) - - bug4929 = '[ruby-core:37395]' - buff = "9341" - EnvUtil.under_gc_stress {qsort.call(buff, buff.size, 1, cb)} - assert_equal("1349", buff, bug4929) - end - end -end if defined?(Fiddle) diff --git a/test/fiddle/test_function.rb b/test/fiddle/test_function.rb deleted file mode 100644 index 4a6bc6c3d4..0000000000 --- a/test/fiddle/test_function.rb +++ /dev/null @@ -1,117 +0,0 @@ -# frozen_string_literal: true -begin - require_relative 'helper' -rescue LoadError -end - -module Fiddle - class TestFunction < Fiddle::TestCase - def setup - super - Fiddle.last_error = nil - end - - def test_default_abi - func = Function.new(@libm['sin'], [TYPE_DOUBLE], TYPE_DOUBLE) - assert_equal Function::DEFAULT, func.abi - end - - def test_name - func = Function.new(@libm['sin'], [TYPE_DOUBLE], TYPE_DOUBLE, name: 'sin') - assert_equal 'sin', func.name - end - - def test_argument_errors - assert_raise(TypeError) do - Function.new(@libm['sin'], TYPE_DOUBLE, TYPE_DOUBLE) - end - - assert_raise(TypeError) do - Function.new(@libm['sin'], ['foo'], TYPE_DOUBLE) - end - - assert_raise(TypeError) do - Function.new(@libm['sin'], [TYPE_DOUBLE], 'foo') - end - end - - def test_call - func = Function.new(@libm['sin'], [TYPE_DOUBLE], TYPE_DOUBLE) - assert_in_delta 1.0, func.call(90 * Math::PI / 180), 0.0001 - end - - def test_argument_count - closure = Class.new(Closure) { - def call one - 10 + one - end - }.new(TYPE_INT, [TYPE_INT]) - func = Function.new(closure, [TYPE_INT], TYPE_INT) - - assert_raise(ArgumentError) do - func.call(1,2,3) - end - assert_raise(ArgumentError) do - func.call - end - end - - def test_last_error - func = Function.new(@libc['strcpy'], [TYPE_VOIDP, TYPE_VOIDP], TYPE_VOIDP) - - assert_nil Fiddle.last_error - func.call(+"000", "123") - refute_nil Fiddle.last_error - end - - def test_strcpy - f = Function.new(@libc['strcpy'], [TYPE_VOIDP, TYPE_VOIDP], TYPE_VOIDP) - buff = +"000" - str = f.call(buff, "123") - assert_equal("123", buff) - assert_equal("123", str.to_s) - end - - def test_nogvl_poll - # XXX hack to quiet down CI errors on EINTR from r64353 - # [ruby-core:88360] [Misc #14937] - # Making pipes (and sockets) non-blocking by default would allow - # us to get rid of POSIX timers / timer pthread - # https://bugs.ruby-lang.org/issues/14968 - IO.pipe { |r,w| IO.select([r], [w]) } - begin - poll = @libc['poll'] - rescue Fiddle::DLError - skip 'poll(2) not available' - end - f = Function.new(poll, [TYPE_VOIDP, TYPE_INT, TYPE_INT], TYPE_INT) - - msec = 200 - t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) - th = Thread.new { f.call(nil, 0, msec) } - n1 = f.call(nil, 0, msec) - n2 = th.value - t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) - assert_in_delta(msec, t1 - t0, 180, 'slept amount of time') - assert_equal(0, n1, perror("poll(2) in main-thread")) - assert_equal(0, n2, perror("poll(2) in sub-thread")) - end - - def test_no_memory_leak - prep = 'r = Fiddle::Function.new(Fiddle.dlopen(nil)["rb_obj_frozen_p"], [Fiddle::TYPE_UINTPTR_T], Fiddle::TYPE_UINTPTR_T); a = "a"' - code = 'begin r.call(a); rescue TypeError; end' - assert_no_memory_leak(%w[-W0 -rfiddle], "#{prep}\n1000.times{#{code}}", "10_000.times {#{code}}", limit: 1.2) - end - - private - - def perror(m) - proc do - if e = Fiddle.last_error - m = "#{m}: #{SystemCallError.new(e).message}" - end - m - end - end - end -end if defined?(Fiddle) diff --git a/test/fiddle/test_handle.rb b/test/fiddle/test_handle.rb deleted file mode 100644 index 17f9c92a11..0000000000 --- a/test/fiddle/test_handle.rb +++ /dev/null @@ -1,175 +0,0 @@ -# frozen_string_literal: true -begin - require_relative 'helper' -rescue LoadError -end - -module Fiddle - class TestHandle < TestCase - include Fiddle - - def test_to_i - handle = Fiddle::Handle.new(LIBC_SO) - assert_kind_of Integer, handle.to_i - end - - def test_static_sym_unknown - assert_raise(DLError) { Fiddle::Handle.sym('fooo') } - assert_raise(DLError) { Fiddle::Handle['fooo'] } - end - - def test_static_sym - begin - # Linux / Darwin / FreeBSD - refute_nil Fiddle::Handle.sym('dlopen') - assert_equal Fiddle::Handle.sym('dlopen'), Fiddle::Handle['dlopen'] - return - rescue - end - - begin - # NetBSD - require '-test-/dln/empty' - refute_nil Fiddle::Handle.sym('Init_empty') - assert_equal Fiddle::Handle.sym('Init_empty'), Fiddle::Handle['Init_empty'] - return - rescue - end - end unless /mswin|mingw/ =~ RUBY_PLATFORM - - def test_sym_closed_handle - handle = Fiddle::Handle.new(LIBC_SO) - handle.close - assert_raise(DLError) { handle.sym("calloc") } - assert_raise(DLError) { handle["calloc"] } - end - - def test_sym_unknown - handle = Fiddle::Handle.new(LIBC_SO) - assert_raise(DLError) { handle.sym('fooo') } - assert_raise(DLError) { handle['fooo'] } - end - - def test_sym_with_bad_args - handle = Handle.new(LIBC_SO) - assert_raise(TypeError) { handle.sym(nil) } - assert_raise(TypeError) { handle[nil] } - end - - def test_sym - handle = Handle.new(LIBC_SO) - refute_nil handle.sym('calloc') - refute_nil handle['calloc'] - end - - def test_handle_close - handle = Handle.new(LIBC_SO) - assert_equal 0, handle.close - end - - def test_handle_close_twice - handle = Handle.new(LIBC_SO) - handle.close - assert_raise(DLError) do - handle.close - end - end - - def test_dlopen_returns_handle - assert_instance_of Handle, dlopen(LIBC_SO) - end - - def test_initialize_noargs - handle = Handle.new - refute_nil handle['rb_str_new'] - end - - def test_initialize_flags - handle = Handle.new(LIBC_SO, RTLD_LAZY | RTLD_GLOBAL) - refute_nil handle['calloc'] - end - - def test_enable_close - handle = Handle.new(LIBC_SO) - assert !handle.close_enabled?, 'close is enabled' - - handle.enable_close - assert handle.close_enabled?, 'close is not enabled' - end - - def test_disable_close - handle = Handle.new(LIBC_SO) - - handle.enable_close - assert handle.close_enabled?, 'close is enabled' - handle.disable_close - assert !handle.close_enabled?, 'close is enabled' - end - - def test_NEXT - begin - # Linux / Darwin - # - # There are two special pseudo-handles, RTLD_DEFAULT and RTLD_NEXT. The former will find - # the first occurrence of the desired symbol using the default library search order. The - # latter will find the next occurrence of a function in the search order after the current - # library. This allows one to provide a wrapper around a function in another shared - # library. - # --- Ubuntu Linux 8.04 dlsym(3) - handle = Handle::NEXT - refute_nil handle['malloc'] - return - rescue - end - - begin - # BSD - # - # If dlsym() is called with the special handle RTLD_NEXT, then the search - # for the symbol is limited to the shared objects which were loaded after - # the one issuing the call to dlsym(). Thus, if the function is called - # from the main program, all the shared libraries are searched. If it is - # called from a shared library, all subsequent shared libraries are - # searched. RTLD_NEXT is useful for implementing wrappers around library - # functions. For example, a wrapper function getpid() could access the - # "real" getpid() with dlsym(RTLD_NEXT, "getpid"). (Actually, the dlfunc() - # interface, below, should be used, since getpid() is a function and not a - # data object.) - # --- FreeBSD 8.0 dlsym(3) - require '-test-/dln/empty' - handle = Handle::NEXT - refute_nil handle['Init_empty'] - return - rescue - end - end unless /mswin|mingw/ =~ RUBY_PLATFORM - - def test_DEFAULT - handle = Handle::DEFAULT - refute_nil handle['malloc'] - end unless /mswin|mingw/ =~ RUBY_PLATFORM - - def test_dlerror - # FreeBSD (at least 7.2 to 7.2) calls nsdispatch(3) when it calls - # getaddrinfo(3). And nsdispatch(3) doesn't call dlerror(3) even if - # it calls _nss_cache_cycle_prevention_function with dlsym(3). - # So our Fiddle::Handle#sym must call dlerror(3) before call dlsym. - # In general uses of dlerror(3) should call it before use it. - require 'socket' - Socket.gethostbyname("localhost") - Fiddle.dlopen("/lib/libc.so.7").sym('strcpy') - end if /freebsd/=~ RUBY_PLATFORM - - def test_no_memory_leak - assert_no_memory_leak(%w[-W0 -rfiddle.so], '', '100_000.times {Fiddle::Handle.allocate}; GC.start', rss: true) - end - - if /cygwin|mingw|mswin/ =~ RUBY_PLATFORM - def test_fallback_to_ansi - k = Fiddle::Handle.new("kernel32.dll") - ansi = k["GetFileAttributesA"] - assert_equal(ansi, k["GetFileAttributes"], "should fallback to ANSI version") - end - end - end -end if defined?(Fiddle) diff --git a/test/fiddle/test_import.rb b/test/fiddle/test_import.rb deleted file mode 100644 index fce8b864d9..0000000000 --- a/test/fiddle/test_import.rb +++ /dev/null @@ -1,228 +0,0 @@ -# coding: US-ASCII -# frozen_string_literal: true -begin - require_relative 'helper' - require 'fiddle/import' -rescue LoadError -end - -module Fiddle - module LIBC - extend Importer - dlload LIBC_SO, LIBM_SO - - typealias 'string', 'char*' - typealias 'FILE*', 'void*' - - extern "void *strcpy(char*, char*)" - extern "int isdigit(int)" - extern "double atof(string)" - extern "unsigned long strtoul(char*, char **, int)" - extern "int qsort(void*, unsigned long, unsigned long, void*)" - extern "int fprintf(FILE*, char*)" rescue nil - extern "int gettimeofday(timeval*, timezone*)" rescue nil - - BoundQsortCallback = bind("void *bound_qsort_callback(void*, void*)"){|ptr1,ptr2| ptr1[0] <=> ptr2[0]} - Timeval = struct [ - "long tv_sec", - "long tv_usec", - ] - Timezone = struct [ - "int tz_minuteswest", - "int tz_dsttime", - ] - MyStruct = struct [ - "short num[5]", - "char c", - "unsigned char buff[7]", - ] - - CallCallback = bind("void call_callback(void*, void*)"){ | ptr1, ptr2| - f = Function.new(ptr1.to_i, [TYPE_VOIDP], TYPE_VOID) - f.call(ptr2) - } - end - - class TestImport < TestCase - def test_ensure_call_dlload - err = assert_raise(RuntimeError) do - Class.new do - extend Importer - extern "void *strcpy(char*, char*)" - end - end - assert_match(/call dlload before/, err.message) - end - - def test_struct_memory_access() - # check memory operations performed directly on struct - my_struct = Fiddle::Importer.struct(['int id']).malloc - begin - my_struct[0, Fiddle::SIZEOF_INT] = "\x01".b * Fiddle::SIZEOF_INT - assert_equal 0x01010101, my_struct.id - - my_struct.id = 0 - assert_equal "\x00".b * Fiddle::SIZEOF_INT, my_struct[0, Fiddle::SIZEOF_INT] - ensure - Fiddle.free my_struct.to_ptr - end - end - - def test_struct_ptr_array_subscript_multiarg() - # check memory operations performed on struct#to_ptr - struct = Fiddle::Importer.struct([ 'int x' ]).malloc - begin - ptr = struct.to_ptr - - struct.x = 0x02020202 - assert_equal("\x02".b * Fiddle::SIZEOF_INT, ptr[0, Fiddle::SIZEOF_INT]) - - ptr[0, Fiddle::SIZEOF_INT] = "\x01".b * Fiddle::SIZEOF_INT - assert_equal 0x01010101, struct.x - ensure - Fiddle.free struct.to_ptr - end - end - - def test_malloc() - s1 = LIBC::Timeval.malloc() - begin - s2 = LIBC::Timeval.malloc() - begin - refute_equal(s1.to_ptr.to_i, s2.to_ptr.to_i) - ensure - Fiddle.free s2.to_ptr - end - ensure - Fiddle.free s1.to_ptr - end - end - - def test_sizeof() - assert_equal(SIZEOF_VOIDP, LIBC.sizeof("FILE*")) - assert_equal(LIBC::MyStruct.size(), LIBC.sizeof(LIBC::MyStruct)) - my_struct = LIBC::MyStruct.malloc() - begin - assert_equal(LIBC::MyStruct.size(), LIBC.sizeof(my_struct)) - ensure - Fiddle.free my_struct.to_ptr - end - assert_equal(SIZEOF_LONG_LONG, LIBC.sizeof("long long")) if defined?(SIZEOF_LONG_LONG) - end - - Fiddle.constants.grep(/\ATYPE_(?!VOID\z)(.*)/) do - type = $& - size = Fiddle.const_get("SIZEOF_#{$1}") - name = $1.sub(/P\z/,"*").gsub(/_(?!T\z)/, " ").downcase - define_method("test_sizeof_#{name}") do - assert_equal(size, Fiddle::Importer.sizeof(name), type) - end - end - - def test_unsigned_result() - d = (2 ** 31) + 1 - - r = LIBC.strtoul(d.to_s, 0, 0) - assert_equal(d, r) - end - - def test_io() - if( RUBY_PLATFORM != BUILD_RUBY_PLATFORM ) || !defined?(LIBC.fprintf) - return - end - io_in,io_out = IO.pipe() - LIBC.fprintf(io_out, "hello") - io_out.flush() - io_out.close() - str = io_in.read() - io_in.close() - assert_equal("hello", str) - end - - def test_value() - i = LIBC.value('int', 2) - assert_equal(2, i.value) - - d = LIBC.value('double', 2.0) - assert_equal(2.0, d.value) - - ary = LIBC.value('int[3]', [0,1,2]) - assert_equal([0,1,2], ary.value) - end - - def test_struct_array_assignment() - instance = Fiddle::Importer.struct(["unsigned int stages[3]"]).malloc - begin - instance.stages[0] = 1024 - instance.stages[1] = 10 - instance.stages[2] = 100 - assert_equal 1024, instance.stages[0] - assert_equal 10, instance.stages[1] - assert_equal 100, instance.stages[2] - assert_equal [1024, 10, 100].pack(Fiddle::PackInfo::PACK_MAP[-Fiddle::TYPE_INT] * 3), - instance.to_ptr[0, 3 * Fiddle::SIZEOF_INT] - assert_raise(IndexError) { instance.stages[-1] = 5 } - assert_raise(IndexError) { instance.stages[3] = 5 } - ensure - Fiddle.free instance.to_ptr - end - end - - def test_struct() - s = LIBC::MyStruct.malloc() - begin - s.num = [0,1,2,3,4] - s.c = ?a.ord - s.buff = "012345\377" - assert_equal([0,1,2,3,4], s.num) - assert_equal(?a.ord, s.c) - assert_equal([?0.ord,?1.ord,?2.ord,?3.ord,?4.ord,?5.ord,?\377.ord], s.buff) - ensure - Fiddle.free s.to_ptr - end - end - - def test_gettimeofday() - if( defined?(LIBC.gettimeofday) ) - timeval = LIBC::Timeval.malloc() - begin - timezone = LIBC::Timezone.malloc() - begin - LIBC.gettimeofday(timeval, timezone) - ensure - Fiddle.free timezone.to_ptr - end - cur = Time.now() - assert(cur.to_i - 2 <= timeval.tv_sec && timeval.tv_sec <= cur.to_i) - ensure - Fiddle.free timeval.to_ptr - end - end - end - - def test_strcpy() - buff = +"000" - str = LIBC.strcpy(buff, "123") - assert_equal("123", buff) - assert_equal("123", str.to_s) - end - - def test_isdigit - r1 = LIBC.isdigit(?1.ord) - r2 = LIBC.isdigit(?2.ord) - rr = LIBC.isdigit(?r.ord) - assert_operator(r1, :>, 0) - assert_operator(r2, :>, 0) - assert_equal(0, rr) - end - - def test_atof - r = LIBC.atof("12.34") - assert_includes(12.00..13.00, r) - end - - def test_no_message_with_debug - assert_in_out_err(%w[--debug --disable=gems -rfiddle/import], 'p Fiddle::Importer', ['Fiddle::Importer']) - end - end -end if defined?(Fiddle) diff --git a/test/fiddle/test_pointer.rb b/test/fiddle/test_pointer.rb deleted file mode 100644 index c69e4f7142..0000000000 --- a/test/fiddle/test_pointer.rb +++ /dev/null @@ -1,241 +0,0 @@ -# frozen_string_literal: true -begin - require_relative 'helper' -rescue LoadError -end - -module Fiddle - class TestPointer < TestCase - def dlwrap arg - Fiddle.dlwrap arg - end - - def test_cptr_to_int - null = Fiddle::NULL - assert_equal(null.to_i, null.to_int) - end - - def test_malloc_free_func_int - free = Fiddle::Function.new(Fiddle::RUBY_FREE, [TYPE_VOIDP], TYPE_VOID) - assert_equal free.to_i, Fiddle::RUBY_FREE.to_i - - ptr = Pointer.malloc(10, free.to_i) - assert_equal 10, ptr.size - assert_equal free.to_i, ptr.free.to_i - end - - def test_malloc_free_func - free = Fiddle::Function.new(Fiddle::RUBY_FREE, [TYPE_VOIDP], TYPE_VOID) - - ptr = Pointer.malloc(10, free) - assert_equal 10, ptr.size - assert_equal free.to_i, ptr.free.to_i - end - - def test_to_str - str = Marshal.load(Marshal.dump("hello world")) - ptr = Pointer[str] - - assert_equal 3, ptr.to_str(3).length - assert_equal str, ptr.to_str - - ptr[5] = 0 - assert_equal "hello\0world", ptr.to_str - end - - def test_to_s - str = Marshal.load(Marshal.dump("hello world")) - ptr = Pointer[str] - - assert_equal 3, ptr.to_s(3).length - assert_equal str, ptr.to_s - - ptr[5] = 0 - assert_equal 'hello', ptr.to_s - end - - def test_minus - str = "hello world" - ptr = Pointer[str] - assert_equal ptr.to_s, (ptr + 3 - 3).to_s - end - - # TODO: what if the pointer size is 0? raise an exception? do we care? - def test_plus - str = "hello world" - ptr = Pointer[str] - new_str = ptr + 3 - assert_equal 'lo world', new_str.to_s - end - - def test_inspect - ptr = Pointer.new(0) - inspect = ptr.inspect - assert_match(/size=#{ptr.size}/, inspect) - assert_match(/free=#{sprintf("%#x", ptr.free.to_i)}/, inspect) - assert_match(/ptr=#{sprintf("%#x", ptr.to_i)}/, inspect) - end - - def test_to_ptr_string - str = "hello world" - ptr = Pointer[str] - assert_equal str.length, ptr.size - assert_equal 'hello', ptr[0,5] - end - - def test_to_ptr_io - buf = Pointer.malloc(10, Fiddle::RUBY_FREE) - File.open(__FILE__, 'r') do |f| - ptr = Pointer.to_ptr f - fread = Function.new(@libc['fread'], - [TYPE_VOIDP, TYPE_INT, TYPE_INT, TYPE_VOIDP], - TYPE_INT) - fread.call(buf.to_i, Fiddle::SIZEOF_CHAR, buf.size - 1, ptr.to_i) - end - - File.open(__FILE__, 'r') do |f| - assert_equal f.read(9), buf.to_s - end - end - - def test_to_ptr_with_ptr - ptr = Pointer.new 0 - ptr2 = Pointer.to_ptr Struct.new(:to_ptr).new(ptr) - assert_equal ptr, ptr2 - - assert_raise(Fiddle::DLError) do - Pointer.to_ptr Struct.new(:to_ptr).new(nil) - end - end - - def test_to_ptr_with_num - ptr = Pointer.new 0 - assert_equal ptr, Pointer[0] - end - - def test_equals - ptr = Pointer.new 0 - ptr2 = Pointer.new 0 - assert_equal ptr2, ptr - end - - def test_not_equals - ptr = Pointer.new 0 - refute_equal 10, ptr, '10 should not equal the pointer' - end - - def test_cmp - ptr = Pointer.new 0 - assert_nil(ptr <=> 10, '10 should not be comparable') - end - - def test_ref_ptr - ary = [0,1,2,4,5] - addr = Pointer.new(dlwrap(ary)) - assert_equal addr.to_i, addr.ref.ptr.to_i - - assert_equal addr.to_i, (+ (- addr)).to_i - end - - def test_to_value - ary = [0,1,2,4,5] - addr = Pointer.new(dlwrap(ary)) - assert_equal ary, addr.to_value - end - - def test_free - ptr = Pointer.malloc(4) - begin - assert_nil ptr.free - ensure - Fiddle.free ptr - end - end - - def test_free= - assert_normal_exit(<<-"End", '[ruby-dev:39269]') - require 'fiddle' - include Fiddle - free = Fiddle::Function.new(Fiddle::RUBY_FREE, [TYPE_VOIDP], TYPE_VOID) - ptr = Fiddle::Pointer.malloc(4) - ptr.free = free - free.ptr - ptr.free.ptr - End - - free = Function.new(Fiddle::RUBY_FREE, [TYPE_VOIDP], TYPE_VOID) - ptr = Pointer.malloc(4) - ptr.free = free - - assert_equal free.ptr, ptr.free.ptr - end - - def test_null? - ptr = Pointer.new(0) - assert ptr.null? - end - - def test_size - ptr = Pointer.malloc(4) - begin - assert_equal 4, ptr.size - ensure - Fiddle.free ptr - end - end - - def test_size= - ptr = Pointer.malloc(4) - begin - ptr.size = 10 - assert_equal 10, ptr.size - ensure - Fiddle.free ptr - end - end - - def test_aref_aset - check = Proc.new{|str,ptr| - assert_equal(str.size(), ptr.size()) - assert_equal(str, ptr.to_s()) - assert_equal(str[0,2], ptr.to_s(2)) - assert_equal(str[0,2], ptr[0,2]) - assert_equal(str[1,2], ptr[1,2]) - assert_equal(str[1,0], ptr[1,0]) - assert_equal(str[0].ord, ptr[0]) - assert_equal(str[1].ord, ptr[1]) - } - str = Marshal.load(Marshal.dump('abc')) - ptr = Pointer[str] - check.call(str, ptr) - - str[0] = "c" - assert_equal 'c'.ord, ptr[0] = "c".ord - check.call(str, ptr) - - str[0,2] = "aa" - assert_equal 'aa', ptr[0,2] = "aa" - check.call(str, ptr) - - ptr2 = Pointer['cdeeee'] - str[0,2] = "cd" - assert_equal ptr2, ptr[0,2] = ptr2 - check.call(str, ptr) - - ptr3 = Pointer['vvvv'] - str[0,2] = "vv" - assert_equal ptr3.to_i, ptr[0,2] = ptr3.to_i - check.call(str, ptr) - end - - def test_null_pointer - nullpo = Pointer.new(0) - assert_raise(DLError) {nullpo[0]} - assert_raise(DLError) {nullpo[0] = 1} - end - - def test_no_memory_leak - assert_no_memory_leak(%w[-W0 -rfiddle.so], '', '100_000.times {Fiddle::Pointer.allocate}', rss: true) - end - end -end if defined?(Fiddle) |