alinta-ffi 1.9.19

data/spec/ffi/function_spec.rb

@@ -0,0 +1,97 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe FFI::Function do
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    attach_function :testFunctionAdd, [:int, :int, :pointer], :int
+  end
+  before do
+    @libtest = FFI::DynamicLibrary.open(TestLibrary::PATH,
+                                        FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_GLOBAL)
+  end
+
+  it 'is initialized with a signature and a block' do
+    fn = FFI::Function.new(:int, []) { 5 }
+    expect(fn.call).to eql 5
+  end
+
+  it 'raises an error when passing a wrong signature' do
+    expect { FFI::Function.new([], :int).new { } }.to raise_error TypeError
+  end
+
+  it 'returns a native pointer' do
+    expect(FFI::Function.new(:int, []) { }).to be_a_kind_of FFI::Pointer
+  end
+
+  it 'can be used as callback from C passing to it a block' do
+    function_add = FFI::Function.new(:int, [:int, :int]) { |a, b| a + b }
+    expect(LibTest.testFunctionAdd(10, 10, function_add)).to eq(20)
+  end
+
+  it 'can be used as callback from C passing to it a Proc object' do
+    function_add = FFI::Function.new(:int, [:int, :int], Proc.new { |a, b| a + b })
+    expect(LibTest.testFunctionAdd(10, 10, function_add)).to eq(20)
+  end
+
+  it 'can be used to wrap an existing function pointer' do
+    expect(FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd')).call(10, 10)).to eq(20)
+  end
+
+  it 'can be attached to a module' do
+    module Foo; end
+    fp = FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd'))
+    fp.attach(Foo, 'add')
+    expect(Foo.add(10, 10)).to eq(20)
+  end
+
+  it 'can be used to extend an object' do
+    fp = FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd'))
+    foo = Object.new
+    class << foo
+      def singleton_class
+        class << self; self; end
+      end
+    end
+    fp.attach(foo.singleton_class, 'add')
+    expect(foo.add(10, 10)).to eq(20)
+  end
+
+  it 'can wrap a blocking function' do
+    fpOpen = FFI::Function.new(:pointer, [ ], @libtest.find_function('testBlockingOpen'))
+    fpRW = FFI::Function.new(:char, [ :pointer, :char ], @libtest.find_function('testBlockingRW'), :blocking => true)
+    fpWR = FFI::Function.new(:char, [ :pointer, :char ], @libtest.find_function('testBlockingWR'), :blocking => true)
+    fpClose = FFI::Function.new(:void, [ :pointer ], @libtest.find_function('testBlockingClose'))
+    handle = fpOpen.call
+    expect(handle).not_to be_null
+    begin
+      thWR = Thread.new { fpWR.call(handle, 63) }
+      thRW = Thread.new { fpRW.call(handle, 64) }
+      expect(thWR.value).to eq(64)
+      expect(thRW.value).to eq(63)
+    ensure
+      fpClose.call(handle)
+    end
+  end
+
+  it 'autorelease flag is set to true by default' do
+    fp = FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd'))
+    expect(fp.autorelease?).to be true
+  end
+
+  it 'can explicity free itself' do
+    fp = FFI::Function.new(:int, []) { }
+    fp.free
+    expect { fp.free }.to raise_error RuntimeError
+  end
+
+  it 'can\'t explicity free itself if not previously allocated' do
+    fp = FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd'))
+    expect { fp.free }.to raise_error RuntimeError
+  end
+end

data/spec/ffi/io_spec.rb

@@ -0,0 +1,16 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+if false # disabled for #390
+  describe "FFI::IO.for_fd" do
+    it "produces an IO wrapping the specified file descriptor" do
+      expect do
+        FFI::IO.for_fd(2, "r")
+      end.to_not raise_error
+    end
+  end
+end

data/spec/ffi/library_spec.rb

@@ -0,0 +1,286 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe "Library" do
+  describe ".enum_value" do
+    m = Module.new do
+      extend FFI::Library
+      enum :something, [:one, :two]
+    end
+
+    it "should return a value for a valid key" do
+      expect(m.enum_value(:one)).to eq(0)
+      expect(m.enum_value(:two)).to eq(1)
+    end
+
+    it "should return nil for an invalid key" do
+      expect(m.enum_value(:three)).to be nil
+    end
+  end
+
+  describe "#ffi_convention" do
+    it "defaults to :default" do
+      m = Module.new do
+        extend FFI::Library
+      end
+      expect(m.ffi_convention).to eq(:default)
+    end
+
+    it "should be settable" do
+      m = Module.new do
+        extend FFI::Library
+      end
+
+      expect(m.ffi_convention).to eq(:default)
+      m.ffi_convention :stdcall
+      expect(m.ffi_convention).to eq(:stdcall)
+    end
+  end
+
+  if FFI::Platform::OS =~ /windows|cygwin/ && FFI::Platform::ARCH == 'i386'
+    module LibTestStdcall
+      extend FFI::Library
+      ffi_lib TestLibrary::PATH
+      ffi_convention :stdcall
+
+      class StructUCDP < FFI::Struct
+        layout :a1, :uchar,
+          :a2, :double,
+          :a3, :pointer
+      end
+
+      attach_function :testStdcallManyParams, [ :pointer, :int8, :int16, :int32, :int64,
+              StructUCDP.by_value, StructUCDP.by_ref, :float, :double ], :void
+    end
+
+    it "adds stdcall decoration: testStdcallManyParams@64" do
+      s = LibTestStdcall::StructUCDP.new
+      po = FFI::MemoryPointer.new :long
+      LibTestStdcall.testStdcallManyParams po, 1, 2, 3, 4, s, s, 1.0, 2.0
+    end
+  end
+
+  describe "ffi_lib" do
+    it "empty name list should raise error" do
+      expect {
+        Module.new do |m|
+          m.extend FFI::Library
+          ffi_lib
+        end
+      }.to raise_error(LoadError)
+    end
+    
+  end
+
+  unless RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
+    it "attach_function with no library specified" do
+      expect {
+        Module.new do |m|
+          m.extend FFI::Library
+          attach_function :getpid, [ ], :uint
+        end
+      }.to raise_error
+    end
+
+    it "attach_function :getpid from this process" do
+      expect {
+        expect(Module.new do |m|
+          m.extend FFI::Library
+          ffi_lib FFI::Library::CURRENT_PROCESS
+          attach_function :getpid, [ ], :uint
+        end.getpid).to eq(Process.pid)
+      }.not_to raise_error
+    end
+
+    it "loads library using symbol" do
+      expect {
+        expect(Module.new do |m|
+          m.extend FFI::Library
+          ffi_lib :c
+          attach_function :getpid, [ ], :uint
+        end.getpid).to eq(Process.pid)
+      }.not_to raise_error
+    end
+
+    it "attach_function :getpid from [ 'c', 'libc.so.6'] " do
+      expect {
+        expect(Module.new do |m|
+          m.extend FFI::Library
+          ffi_lib [ 'c', 'libc.so.6' ]
+          attach_function :getpid, [ ], :uint
+        end.getpid).to eq(Process.pid)
+      }.not_to raise_error
+    end
+
+    it "attach_function :getpid from [ 'libc.so.6', 'c' ] " do
+      expect {
+        expect(Module.new do |m|
+          m.extend FFI::Library
+          ffi_lib [ 'libc.so.6', 'c' ]
+          attach_function :getpid, [ ], :uint
+        end.getpid).to eq(Process.pid)
+      }.not_to raise_error
+    end
+
+    it "attach_function :getpid from [ 'libfubar.so.0xdeadbeef', nil, 'c' ] " do
+      expect {
+        expect(Module.new do |m|
+          m.extend FFI::Library
+          ffi_lib [ 'libfubar.so.0xdeadbeef', nil, 'c' ]
+          attach_function :getpid, [ ], :uint
+        end.getpid).to eq(Process.pid)
+      }.not_to raise_error
+    end
+
+    it "attach_function :getpid from [ 'libfubar.so.0xdeadbeef' ] " do
+      expect {
+        expect(Module.new do |m|
+          m.extend FFI::Library
+          ffi_lib 'libfubar.so.0xdeadbeef'
+          attach_function :getpid, [ ], :uint
+        end.getpid).to eq(Process.pid)
+      }.to raise_error(LoadError)
+    end
+
+    it "attach_function :bool_return_true from [ File.expand_path(#{TestLibrary::PATH.inspect}) ]" do
+      mod = Module.new do |m|
+        m.extend FFI::Library
+        ffi_lib File.expand_path(TestLibrary::PATH)
+        attach_function :bool_return_true, [ ], :bool
+      end
+      expect(mod.bool_return_true).to be true
+    end
+  end
+
+  def gvar_lib(name, type)
+    Module.new do |m|
+      m.extend FFI::Library
+      ffi_lib TestLibrary::PATH
+      attach_variable :gvar, "gvar_#{name}", type
+      attach_function :get, "gvar_#{name}_get", [], type
+      attach_function :set, "gvar_#{name}_set", [ type ], :void
+    end
+  end
+
+  def gvar_test(name, type, val)
+    lib = gvar_lib(name, type)
+    lib.set(val)
+    expect(lib.gvar).to eq(val)
+    lib.set(0)
+    lib.gvar = val
+    expect(lib.get).to eq(val)
+  end
+
+  [ 0, 127, -128, -1 ].each do |i|
+    it ":char variable" do
+      gvar_test("s8", :char, i)
+    end
+  end
+
+  [ 0, 0x7f, 0x80, 0xff ].each do |i|
+    it ":uchar variable" do
+      gvar_test("u8", :uchar, i)
+    end
+  end
+
+  [ 0, 0x7fff, -0x8000, -1 ].each do |i|
+    it ":short variable" do
+      gvar_test("s16", :short, i)
+    end
+  end
+
+  [ 0, 0x7fff, 0x8000, 0xffff ].each do |i|
+    it ":ushort variable" do
+      gvar_test("u16", :ushort, i)
+    end
+  end
+
+  [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
+    it ":int variable" do
+      gvar_test("s32", :int, i)
+    end
+  end
+
+  [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
+    it ":uint variable" do
+      gvar_test("u32", :uint, i)
+    end
+  end
+
+  [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
+    it ":long_long variable" do
+      gvar_test("s64", :long_long, i)
+    end
+  end
+
+  [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
+    it ":ulong_long variable" do
+      gvar_test("u64", :ulong_long, i)
+    end
+  end
+
+  if FFI::Platform::LONG_SIZE == 32
+    [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
+      it ":long variable" do
+        gvar_test("long", :long, i)
+      end
+    end
+
+    [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
+      it ":ulong variable" do
+        gvar_test("ulong", :ulong, i)
+      end
+    end
+  else
+    [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
+      it ":long variable" do
+        gvar_test("long", :long, i)
+      end
+    end
+
+    [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
+      it ":ulong variable" do
+        gvar_test("ulong", :ulong, i)
+      end
+    end
+  end
+
+  it "Pointer variable" do
+    lib = gvar_lib("pointer", :pointer)
+    val = FFI::MemoryPointer.new :long
+    lib.set(val)
+    expect(lib.gvar).to eq(val)
+    lib.set(nil)
+    lib.gvar = val
+    expect(lib.get).to eq(val)
+  end
+
+  [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
+    it "structure" do
+      class GlobalStruct < FFI::Struct
+        layout :data, :long
+      end
+
+      lib = Module.new do |m|
+        m.extend FFI::Library
+        ffi_lib TestLibrary::PATH
+        attach_variable :gvar, "gvar_gstruct", GlobalStruct
+        attach_function :get, "gvar_gstruct_get", [], GlobalStruct
+        attach_function :set, "gvar_gstruct_set", [ GlobalStruct ], :void
+      end
+
+      val = GlobalStruct.new
+      val[:data] = i
+      lib.set(val)
+      expect(lib.gvar[:data]).to eq(i)
+      val[:data] = 0
+      lib.gvar[:data] = i
+      val = GlobalStruct.new(lib.get)
+      expect(val[:data]).to eq(i)
+    end
+  end
+end

data/spec/ffi/long_double.rb

@@ -0,0 +1,30 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'bigdecimal'
+
+describe ":long_double arguments and return values" do
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    attach_function :add_f128, [ :long_double, :long_double ], :long_double
+    attach_function :ret_f128, [ :long_double ], :long_double
+  end
+
+  it "returns first parameter" do
+    expect(LibTest.ret_f128(0.1)).to be_within(0.01).of(0.1)
+  end
+
+  it "returns first parameter with high precision" do
+    ld =        BigDecimal.new("1.234567890123456789")
+    tolerance = BigDecimal.new("0.0000000000000000001")
+    expect(LibTest.ret_f128(ld)).to be_within(tolerance).of(ld)
+  end
+
+  it "add two long double numbers" do
+    expect(LibTest.add_f128(0.1, 0.2)).to be_within(0.01).of(0.3)
+  end
+end

data/spec/ffi/managed_struct_spec.rb

@@ -0,0 +1,68 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe "Managed Struct" do
+  include FFI
+  module ManagedStructTestLib
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    attach_function :ptr_from_address, [ FFI::Platform::ADDRESS_SIZE == 32 ? :uint : :ulong_long ], :pointer
+  end
+
+  it "should raise an error if release() is not defined" do
+    class NoRelease < FFI::ManagedStruct ; layout :i, :int; end
+    expect { NoRelease.new(ManagedStructTestLib.ptr_from_address(0x12345678)) }.to raise_error(NoMethodError)
+  end
+
+  it "should be the right class" do
+    class WhatClassAmI < FFI::ManagedStruct
+      layout :i, :int
+      def self.release
+      end
+    end    
+
+    expect(WhatClassAmI.new(ManagedStructTestLib.ptr_from_address(0x12345678)).class).to eq(WhatClassAmI)
+  end
+
+  it "should build with self reference" do
+    class ClassWithSelfRef < FFI::ManagedStruct
+      layout :data, self.ptr
+      def self.release
+      end
+    end
+
+    expect(ClassWithSelfRef.new(ManagedStructTestLib.ptr_from_address(0x12345678)).class).to eq(ClassWithSelfRef)
+  end
+
+  # see #427
+  it "should release memory properly", :broken => true do
+    class PleaseReleaseMe < FFI::ManagedStruct
+      layout :i, :int
+      @@count = 0
+      def self.release
+        @@count += 1
+      end
+      def self.wait_gc(count)
+        loop = 5
+        while loop > 0 && @@count < count
+          loop -= 1
+          TestLibrary.force_gc
+          sleep 0.05 if @@count < count
+        end
+      end
+    end
+
+    loop_count = 30
+    wiggle_room = 5
+
+    expect(PleaseReleaseMe).to receive(:release).at_least(loop_count-wiggle_room).times
+    loop_count.times do
+      PleaseReleaseMe.new(ManagedStructTestLib.ptr_from_address(0x12345678))
+    end
+    PleaseReleaseMe.wait_gc loop_count
+  end
+end