ffi 0.5.0-x86-mingw32

data/spec/ffi/number_spec.rb

@@ -0,0 +1,231 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+describe "Function with primitive integer arguments" do
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    attach_function :ret_s8, [ :char ], :char
+    attach_function :ret_u8, [ :uchar ], :uchar
+    attach_function :ret_s16, [ :short ], :short
+    attach_function :ret_u16, [ :ushort ], :ushort
+    attach_function :ret_s32, [ :int ], :int
+    attach_function :ret_u32, [ :uint ], :uint
+    attach_function :ret_s64, [ :long_long ], :long_long
+    attach_function :ret_u64, [ :ulong_long ], :ulong_long
+    attach_function :ret_long, [ :long ], :long
+    attach_function :ret_ulong, [ :ulong ], :ulong
+    attach_function :set_s8, [ :char ], :void
+    attach_function :get_s8, [ ], :char
+    attach_function :set_float, [ :float ], :void
+    attach_function :get_float, [ ], :float
+    attach_function :set_double, [ :double ], :void
+    attach_function :get_double, [ ], :double
+  end
+  it "int8.size" do
+    FFI::TYPE_INT8.size.should == 1
+  end
+  it "uint8.size" do
+    FFI::TYPE_UINT8.size.should == 1
+  end
+  it "int16.size" do
+    FFI::TYPE_INT16.size.should == 2
+  end
+  it "uint16.size" do
+    FFI::TYPE_UINT16.size.should == 2
+  end
+  it "int32.size" do
+    FFI::TYPE_INT32.size.should == 4
+  end
+  it "uint32.size" do
+    FFI::TYPE_UINT32.size.should == 4
+  end
+  it "int64.size" do
+    FFI::TYPE_INT64.size.should == 8
+  end
+  it "uint64.size" do
+    FFI::TYPE_UINT64.size.should == 8
+  end
+  it "float.size" do
+    FFI::TYPE_FLOAT32.size.should == 4
+  end
+  it "double.size" do
+    FFI::TYPE_FLOAT64.size.should == 8
+  end
+  [ 0, 127, -128, -1 ].each do |i|
+    it ":char call(:char (#{i}))" do
+      LibTest.ret_s8(i).should == i
+    end
+  end
+  [ 0, 0x7f, 0x80, 0xff ].each do |i|
+    it ":uchar call(:uchar (#{i}))" do
+      LibTest.ret_u8(i).should == i
+    end
+  end
+  [ 0, 0x7fff, -0x8000, -1 ].each do |i|
+    it ":short call(:short (#{i}))" do
+      LibTest.ret_s16(i).should == i
+    end
+  end
+  [ 0, 0x7fff, 0x8000, 0xffff ].each do |i|
+    it ":ushort call(:ushort (#{i}))" do
+      LibTest.ret_u16(i).should == i
+    end
+  end
+  [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
+    it ":int call(:int (#{i}))" do
+      LibTest.ret_s32(i).should == i
+    end
+  end
+  [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
+    it ":uint call(:uint (#{i}))" do
+      LibTest.ret_u32(i).should == i
+    end
+  end
+  [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
+    it ":long_long call(:long_long (#{i}))" do
+      LibTest.ret_s64(i).should == i
+    end
+  end
+  [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
+    it ":ulong_long call(:ulong_long (#{i}))" do
+      LibTest.ret_u64(i).should == i
+    end
+  end
+  if FFI::Platform::LONG_SIZE == 32
+    [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
+      it ":long call(:long (#{i}))" do
+        LibTest.ret_long(i).should == i
+      end
+    end
+    [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
+      it ":ulong call(:ulong (#{i}))" do
+        LibTest.ret_ulong(i).should == i
+      end
+    end
+  else
+    [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
+      it ":long call(:long (#{i}))" do
+        LibTest.ret_long(i).should == i
+      end
+    end
+    [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
+      it ":ulong call(:ulong (#{i}))" do
+        LibTest.ret_ulong(i).should == i
+      end
+    end
+    [ 0.0, 0.1, 1.1, 1.23 ].each do |f|
+      it ":float call(:double (#{f}))" do
+        LibTest.set_float(f)
+        (LibTest.get_float - f).abs.should < 0.001
+      end
+    end
+    [ 0.0, 0.1, 1.1, 1.23 ].each do |f|
+      it ":double call(:double (#{f}))" do
+        LibTest.set_double(f)
+        (LibTest.get_double - f).abs.should < 0.001
+      end
+    end
+  end
+end
+describe "Integer parameter range checking" do
+  [ 128, -129 ].each do |i|
+    it ":char call(:char (#{i}))" do
+      lambda { LibTest.ret_int8_t(i).should == i }.should raise_error
+    end
+  end
+  [ -1, 256 ].each do |i|
+    it ":uchar call(:uchar (#{i}))" do
+      lambda { LibTest.ret_u_int8_t(i).should == i }.should raise_error
+    end
+  end
+  [ 0x8000, -0x8001 ].each do |i|
+    it ":short call(:short (#{i}))" do
+      lambda { LibTest.ret_int16_t(i).should == i }.should raise_error
+    end
+  end
+  [ -1, 0x10000 ].each do |i|
+    it ":ushort call(:ushort (#{i}))" do
+      lambda { LibTest.ret_u_int16_t(i).should == i }.should raise_error
+    end
+  end
+  [ 0x80000000, -0x80000001 ].each do |i|
+    it ":int call(:int (#{i}))" do
+      lambda { LibTest.ret_int32_t(i).should == i }.should raise_error
+    end
+  end
+  [ -1, 0x100000000 ].each do |i|
+    it ":ushort call(:ushort (#{i}))" do
+      lambda { LibTest.ret_u_int32_t(i).should == i }.should raise_error
+    end
+  end
+end
+describe "Three different size Integer arguments" do
+  TYPE_MAP = {
+    's8' => :char, 'u8' => :uchar, 's16' => :short, 'u16' => :ushort,
+    's32' => :int, 'u32' => :uint, 's64' => :long_long, 'u64' => :ulong_long,
+    'sL' => :long, 'uL' => :ulong, 'f32' => :float, 'f64' => :double
+  }
+  TYPES = TYPE_MAP.keys
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    
+    
+    [ 's32', 'u32', 's64', 'u64' ].each do |rt|
+      TYPES.each do |t1|
+        TYPES.each do |t2|
+          TYPES.each do |t3|
+            begin
+              attach_function "pack_#{t1}#{t2}#{t3}_#{rt}",
+                [ TYPE_MAP[t1], TYPE_MAP[t2], TYPE_MAP[t3], :buffer_out ], :void
+            rescue FFI::NotFoundError
+            end
+          end
+        end
+      end
+    end
+  end
+
+  PACK_VALUES = {
+    's8' => [ 0x12  ],
+    'u8' => [ 0x34  ],
+    's16' => [ 0x5678 ],
+    'u16' => [ 0x9abc ],
+    's32' => [ 0x7654321f ],
+    'u32' => [ 0xfee1babe ],
+    'sL' => [ 0x1f2e3d4c ],
+    'uL' => [ 0xf7e8d9ca ],
+    's64' => [ 0x1eafdeadbeefa1b2 ],
+#    'f32' => [ 1.234567 ],
+    'f64' => [ 9.87654321 ]
+  }
+  module Number
+    def self.verify(p, off, t, v)
+      if t == 'f32'
+        p.get_float32(off).should == v
+      elsif t == 'f64'
+        p.get_float64(off).should == v
+      else
+        p.get_int64(off).should == v
+      end
+    end
+  end
+  PACK_VALUES.keys.each do |t1|
+    PACK_VALUES.keys.each do |t2|
+      PACK_VALUES.keys.each do |t3|
+        PACK_VALUES[t1].each do |v1|
+          PACK_VALUES[t2].each do |v2|
+            PACK_VALUES[t3].each do |v3|
+              it "call(#{TYPE_MAP[t1]} (#{v1}), #{TYPE_MAP[t2]} (#{v2}), #{TYPE_MAP[t3]} (#{v3}))" do
+                p = FFI::Buffer.new :long_long, 3
+                LibTest.send("pack_#{t1}#{t2}#{t3}_s64", v1, v2, v3, p)
+                Number.verify(p, 0, t1, v1)
+                Number.verify(p, 8, t2, v2)
+                Number.verify(p, 16, t3, v3)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/ffi/pointer_spec.rb

@@ -0,0 +1,195 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'delegate'
+require 'java' if RUBY_PLATFORM =~ /java/
+
+module LibTest
+  attach_function :ptr_ret_int32_t, [ :pointer, :int ], :int
+  attach_function :ptr_from_address, [ FFI::Platform::ADDRESS_SIZE == 32 ? :uint : :ulong_long ], :pointer
+  attach_function :ptr_set_pointer, [ :pointer, :int, :pointer ], :void
+  attach_function :ptr_ret_pointer, [ :pointer, :int ], :pointer
+end
+describe "Pointer" do
+  include FFI
+  class ToPtrTest
+    def initialize(ptr)
+      @ptr = ptr
+    end
+    def to_ptr
+      @ptr
+    end
+  end
+  it "Any object implementing #to_ptr can be passed as a :pointer parameter" do
+    memory = FFI::MemoryPointer.new :long_long
+    magic = 0x12345678
+    memory.put_int32(0, magic)
+    tp = ToPtrTest.new(memory)
+    LibTest.ptr_ret_int32_t(tp, 0).should == magic
+  end
+  class PointerDelegate < DelegateClass(FFI::Pointer)
+    def initialize(ptr)
+      @ptr = ptr
+    end
+    def to_ptr
+      @ptr
+    end
+  end
+  it "A DelegateClass(Pointer) can be passed as a :pointer parameter" do
+    memory = FFI::MemoryPointer.new :long_long
+    magic = 0x12345678
+    memory.put_int32(0, magic)
+    ptr = PointerDelegate.new(memory)
+    LibTest.ptr_ret_int32_t(ptr, 0).should == magic
+  end
+  it "Fixnum cannot be used as a Pointer argument" do
+    lambda { LibTest.ptr_ret_int32(0, 0) }.should raise_error
+  end
+  it "Bignum cannot be used as a Pointer argument" do
+    lambda { LibTest.ptr_ret_int32(0xfee1deadbeefcafebabe, 0) }.should raise_error
+  end
+
+  describe "pointer type methods" do
+
+    describe "#read_pointer" do
+      memory = FFI::MemoryPointer.new :pointer
+      LibTest.ptr_set_pointer(memory, 0, LibTest.ptr_from_address(0xdeadbeef))
+      memory.read_pointer.address.should == 0xdeadbeef
+    end
+
+    describe "#write_pointer" do
+      memory = FFI::MemoryPointer.new :pointer
+      memory.write_pointer(LibTest.ptr_from_address(0xdeadbeef))
+      LibTest.ptr_ret_pointer(memory, 0).address.should == 0xdeadbeef
+    end
+
+    describe "#read_array_of_pointer" do
+      values = [0x12345678, 0xfeedf00d, 0xdeadbeef]
+      memory = FFI::MemoryPointer.new :pointer, values.size
+      values.each_with_index do |address, j|
+        LibTest.ptr_set_pointer(memory, j * FFI.type_size(:pointer), LibTest.ptr_from_address(address))
+      end
+      array = memory.read_array_of_pointer(values.size)
+      values.each_with_index do |address, j|
+        array[j].address.should == address
+      end
+    end
+
+    describe "#write_array_of_pointer" do
+      values = [0x12345678, 0xfeedf00d, 0xdeadbeef]
+      memory = FFI::MemoryPointer.new :pointer, values.size
+      memory.write_array_of_pointer(values.map { |address| LibTest.ptr_from_address(address) })
+      array = []
+      values.each_with_index do |address, j|
+        array << LibTest.ptr_ret_pointer(memory, j * FFI.type_size(:pointer))
+      end
+      values.each_with_index do |address, j|
+        array[j].address.should == address
+      end
+    end
+    
+  end
+
+  describe 'NULL' do
+    it 'should be obtained using Pointer::NULL constant' do
+      null_ptr = FFI::Pointer::NULL
+      null_ptr.null?.should be_true
+    end
+    it 'should be obtained passing address 0 to constructor' do
+      FFI::Pointer.new(0).null?.should be_true
+    end
+    it 'should raise an error when attempting read/write operations on it' do
+      null_ptr = FFI::Pointer::NULL
+      lambda { null_ptr.read_int }.should raise_error(FFI::NullPointerError)
+      lambda { null_ptr.write_int(0xff1) }.should raise_error(FFI::NullPointerError)
+    end
+  end
+
+end
+
+describe "AutoPointer" do
+  loop_count = 30
+  wiggle_room = 2 # GC rarely cleans up all objects. we can get most of them, and that's enough to determine if the basic functionality is working.
+  magic = 0x12345678
+
+  class AutoPointerTestHelper
+    @@count = 0
+    def self.release
+      @@count += 1 if @@count > 0
+    end
+    def self.reset
+      @@count = 0
+    end
+    def self.gc_everything(count)
+      loop = 5
+      while @@count < count && loop > 0
+        loop -= 1
+        if RUBY_PLATFORM =~ /java/
+          java.lang.System.gc
+        else
+          GC.start
+        end
+        sleep 0.05 unless @@count == count
+      end
+      @@count = 0
+    end
+    def self.finalizer
+      self.method(:release).to_proc
+    end
+  end
+  class AutoPointerSubclass < FFI::AutoPointer
+    def self.release(ptr); end
+  end
+  it "cleanup via default release method" do
+    AutoPointerSubclass.should_receive(:release).at_least(loop_count-wiggle_room).times
+    AutoPointerTestHelper.reset
+    loop_count.times do
+      # note that if we called
+      # AutoPointerTestHelper.method(:release).to_proc inline, we'd
+      # have a reference to the pointer and it would never get GC'd.
+      ap = AutoPointerSubclass.new(LibTest.ptr_from_address(magic))
+    end
+    AutoPointerTestHelper.gc_everything loop_count
+  end
+
+  it "cleanup when passed a proc" do
+    #  NOTE: passing a proc is touchy, because it's so easy to create a memory leak.
+    #
+    #  specifically, if we made an inline call to
+    #
+    #      AutoPointerTestHelper.method(:release).to_proc
+    #
+    #  we'd have a reference to the pointer and it would
+    #  never get GC'd.
+    AutoPointerTestHelper.should_receive(:release).at_least(loop_count-wiggle_room).times
+    AutoPointerTestHelper.reset
+    loop_count.times do
+      ap = FFI::AutoPointer.new(LibTest.ptr_from_address(magic),
+                                AutoPointerTestHelper.finalizer)
+    end
+    AutoPointerTestHelper.gc_everything loop_count
+  end
+
+  it "cleanup when passed a method" do
+    AutoPointerTestHelper.should_receive(:release).at_least(loop_count-wiggle_room).times
+    AutoPointerTestHelper.reset
+    loop_count.times do
+      ap = FFI::AutoPointer.new(LibTest.ptr_from_address(magic),
+                                AutoPointerTestHelper.method(:release))
+    end
+    AutoPointerTestHelper.gc_everything loop_count
+  end
+end
+describe "AutoPointer#new" do
+  class AutoPointerSubclass < FFI::AutoPointer
+    def self.release(ptr); end
+  end
+  it "MemoryPointer argument raises TypeError" do
+    lambda { FFI::AutoPointer.new(FFI::MemoryPointer.new(:int))}.should raise_error(::TypeError)
+  end
+  it "AutoPointer argument raises TypeError" do
+    lambda { AutoPointerSubclass.new(AutoPointerSubclass.new(LibTest.ptr_from_address(0))) }.should raise_error(::TypeError)
+  end
+  it "Buffer argument raises TypeError" do
+    lambda { FFI::AutoPointer.new(FFI::Buffer.new(:int))}.should raise_error(::TypeError)
+  end
+
+end

data/spec/ffi/rbx/attach_function_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+class Timeval < FFI::Struct
+  layout :tv_sec, :ulong, 0, :tv_usec, :ulong, 4  
+end
+
+module LibC
+  extend FFI::Library
+  
+  attach_function :gettimeofday, [:pointer, :pointer], :int
+end
+
+describe FFI::Library, "#attach_function" do
+  it "correctly returns a value for gettimeofday" do
+    t = Timeval.new
+    time = LibC.gettimeofday(t.pointer, nil)
+    time.should be_kind_of(Integer)
+  end
+  
+  it "correctly populates a struct for gettimeofday" do
+    t = Timeval.new
+    time = LibC.gettimeofday(t.pointer, nil)
+    t[:tv_sec].should be_kind_of(Numeric)
+    t[:tv_usec].should be_kind_of(Numeric)
+  end
+end
+