ffi 0.1.1 → 0.2.0

data/specs/managed_struct_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe "Managed Struct" do
+  include FFI
+  module LibTest
+    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 ; end
+    lambda { NoRelease.new(LibTest.ptr_from_address(0x12345678)) }.should raise_error(NoMethodError)
+  end
+
+  it "should release memory properly" do
+    class PleaseReleaseMe < FFI::ManagedStruct
+      @@count = 0
+      def self.release
+        @@count += 1
+      end
+      def self.wait_gc(count)
+        loop = 5
+        while loop > 0 && @@count < count
+          loop -= 1
+          GC.start
+          sleep 0.05 if @@count < count
+        end
+      end
+    end
+
+    loop_count = 30
+    wiggle_room = 2
+
+    PleaseReleaseMe.should_receive(:release).at_least(loop_count-wiggle_room).times
+    loop_count.times do
+      s = PleaseReleaseMe.new(LibTest.ptr_from_address(0x12345678))
+    end
+    PleaseReleaseMe.wait_gc loop_count
+  end
+end

data/specs/number_spec.rb

@@ -0,0 +1,183 @@
+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_int8_t, [ :char ], :char
+    attach_function :ret_u_int8_t, [ :uchar ], :uchar
+    attach_function :ret_int16_t, [ :short ], :short
+    attach_function :ret_u_int16_t, [ :ushort ], :ushort
+    attach_function :ret_int32_t, [ :int ], :int
+    attach_function :ret_u_int32_t, [ :uint ], :uint
+    attach_function :ret_int64_t, [ :long_long ], :long_long
+    attach_function :ret_u_int64_t, [ :ulong_long ], :ulong_long
+    attach_function :ret_long, [ :long ], :long
+    attach_function :ret_ulong, [ :ulong ], :ulong
+  end
+  [ 0, 127, -128, -1 ].each do |i|
+    it ":char call(:char (#{i}))" do
+      LibTest.ret_int8_t(i).should == i
+    end
+  end
+  [ 0, 0x7f, 0x80, 0xff ].each do |i|
+    it ":uchar call(:uchar (#{i}))" do
+      LibTest.ret_u_int8_t(i).should == i
+    end
+  end
+  [ 0, 0x7fff, -0x8000, -1 ].each do |i|
+    it ":short call(:short (#{i}))" do
+      LibTest.ret_int16_t(i).should == i
+    end
+  end
+  [ 0, 0x7fff, 0x8000, 0xffff ].each do |i|
+    it ":ushort call(:ushort (#{i}))" do
+      LibTest.ret_u_int16_t(i).should == i
+    end
+  end
+  [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
+    it ":int call(:int (#{i}))" do
+      LibTest.ret_int32_t(i).should == i
+    end
+  end
+  [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
+    it ":uint call(:uint (#{i}))" do
+      LibTest.ret_u_int32_t(i).should == i
+    end
+  end
+  [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
+    it ":long_long call(:long_long (#{i}))" do
+      LibTest.ret_int64_t(i).should == i
+    end
+  end
+  [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
+    it ":ulong_long call(:ulong_long (#{i}))" do
+      LibTest.ret_u_int64_t(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
+  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/specs/pointer_spec.rb

@@ -0,0 +1,126 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'delegate'
+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
+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 = 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)
+      super
+      @ptr = ptr
+    end
+    def to_ptr
+      @ptr
+    end
+  end
+  it "A DelegateClass(Pointer) can be passed as a :pointer parameter" do
+    memory = 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
+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
+        GC.start
+        sleep 0.05 unless @@count == count
+      end
+      @@count = 0
+    end
+    def self.finalizer
+      self.method(:release).to_proc
+    end
+  end
+
+  it "cleanup via default release method" do
+    FFI::AutoPointer.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 = FFI::AutoPointer.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
+  it "MemoryPointer argument raises ArgumentError" do
+    lambda { FFI::AutoPointer.new(FFI::MemoryPointer.new(:int))}.should raise_error(ArgumentError)
+  end
+  it "AutoPointer argument raises ArgumentError" do
+    lambda { FFI::AutoPointer.new(FFI::AutoPointer.new(LibTest.ptr_from_address(0))) }.should raise_error(ArgumentError)
+  end
+  it "Buffer argument raises ArgumentError" do
+    lambda { FFI::AutoPointer.new(FFI::Buffer.new(:int))}.should raise_error(ArgumentError)
+  end
+
+end

data/specs/rbx/memory_pointer_spec.rb

@@ -58,13 +58,13 @@ describe MemoryPointer do
     m = MemoryPointer.new(1)
     lambda { m.write_int(10) }.should raise_error
   end
-  it "does not raise IndexError for opaque pointers" do
-    m = MemoryPointer.new(8)
-    p2 = MemoryPointer.new(1024)
-    m.write_long(p2.address)
-    p = m.read_pointer
-    lambda { p.write_int(10) }.should_not raise_error
-  end
+#  it "does not raise IndexError for opaque pointers" do
+#    m = MemoryPointer.new(8)
+#    p2 = MemoryPointer.new(1024)
+#    m.write_long(p2.address)
+#    p = m.read_pointer
+#    lambda { p.write_int(10) }.should_not raise_error
+#  end
   
   it "makes a pointer for a certain type" do
     m = MemoryPointer.new(:int)

data/specs/spec_helper.rb

@@ -1,2 +1,9 @@
 $:.unshift File.join(File.dirname(__FILE__), "..", "lib") if ENV["MRI_FFI"]
 require "ffi"
+module TestLibrary
+  PATH = "#{Dir.getwd}/build/libtest.#{FFI::Platform::LIBSUFFIX}"
+end
+module LibTest
+  extend FFI::Library
+  ffi_lib TestLibrary::PATH
+end

data/specs/string_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+describe "String tests" do
+  include FFI
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    attach_function :ptr_ret_pointer, [ :pointer, :int], :string
+    attach_function :string_equals, [ :string, :string ], :int
+  end
+  it "MemoryPointer#get_string returns a tainted string" do
+    mp = MemoryPointer.new 1024
+    mp.put_string(0, "test\0")
+    str = mp.get_string(0)
+    str.tainted?.should == true
+  end
+  it "String returned by a method is tainted" do
+    mp = MemoryPointer.new :pointer
+    sp = MemoryPointer.new 1024
+    sp.put_string(0, "test")
+    mp.put_pointer(0, sp)
+    str = LibTest.ptr_ret_pointer(mp, 0)
+    str.should == "test"
+    str.tainted?.should == true
+  end
+  it "Tainted String parameter should throw a SecurityError" do
+    $SAFE = 1
+    str = "test"
+    str.taint
+    begin
+      LibTest.string_equals(str, str).should == false
+    rescue SecurityError => e
+    end
+  end if false
+end

data/specs/struct_spec.rb

@@ -0,0 +1,223 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+describe "Struct tests" do
+  include FFI
+  StructTypes = {
+    's8' => :char,
+    's16' => :short,
+    's32' => :int,
+    's64' => :long_long,
+    'long' => :long,
+    'f32' => :float,
+    'f64' => :double
+  }
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    attach_function :ptr_ret_pointer, [ :pointer, :int], :string
+    attach_function :ptr_from_address, [ :ulong ], :pointer
+    attach_function :string_equals, [ :string, :string ], :int
+    [ 's8', 's16', 's32', 's64', 'f32', 'f64', 'long' ].each do |t|
+      attach_function "struct_align_#{t}", [ :pointer ], StructTypes[t]
+    end
+  end
+  class PointerMember < FFI::Struct
+    layout :pointer, :pointer
+  end
+  class StringMember < FFI::Struct
+    layout :string, :string
+  end
+  it "Struct#[:pointer]" do
+    magic = 0x12345678
+    mp = MemoryPointer.new :long
+    mp.put_long(0, magic)
+    smp = MemoryPointer.new :pointer
+    smp.put_pointer(0, mp)
+    s = PointerMember.new smp
+    s[:pointer].should == mp
+  end
+  it "Struct#[:pointer].nil? for NULL value" do
+    magic = 0x12345678
+    mp = MemoryPointer.new :long
+    mp.put_long(0, magic)
+    smp = MemoryPointer.new :pointer
+    smp.put_pointer(0, nil)
+    s = PointerMember.new smp
+    s[:pointer].null?.should == true
+  end
+  it "Struct#[:pointer]=" do
+    magic = 0x12345678
+    mp = MemoryPointer.new :long
+    mp.put_long(0, magic)
+    smp = MemoryPointer.new :pointer
+    s = PointerMember.new smp
+    s[:pointer] = mp
+    smp.get_pointer(0).should == mp
+  end
+  it "Struct#[:pointer]=nil" do
+    smp = MemoryPointer.new :pointer
+    s = PointerMember.new smp
+    s[:pointer] = nil
+    smp.get_pointer(0).null?.should == true
+  end
+  it "Struct#[:string]" do
+    magic = "test"
+    mp = MemoryPointer.new 1024
+    mp.put_string(0, magic)
+    smp = MemoryPointer.new :pointer
+    smp.put_pointer(0, mp)
+    s = StringMember.new smp
+    s[:string].should == magic
+  end
+  it "Struct#[:string].nil? for NULL value" do
+    smp = MemoryPointer.new :pointer
+    smp.put_pointer(0, nil)
+    s = StringMember.new smp
+    s[:string].nil?.should == true
+  end
+  it "Struct#layout works with :name, :type pairs" do
+    class PairLayout < FFI::Struct
+      layout :a, :int, :b, :long_long
+    end
+    PairLayout.size.should == 12
+    mp = MemoryPointer.new(12)
+    s = PairLayout.new mp
+    s[:a] = 0x12345678
+    mp.get_int(0).should == 0x12345678
+    s[:b] = 0xfee1deadbeef
+    mp.get_int64(4).should == 0xfee1deadbeef
+  end
+  it "Struct#layout works with :name, :type, offset tuples" do
+    class PairLayout < FFI::Struct
+      layout :a, :int, 0, :b, :long_long, 4
+    end
+    PairLayout.size.should == 12
+    mp = MemoryPointer.new(12)
+    s = PairLayout.new mp
+    s[:a] = 0x12345678
+    mp.get_int(0).should == 0x12345678
+    s[:b] = 0xfee1deadbeef
+    mp.get_int64(4).should == 0xfee1deadbeef
+  end
+  it "Struct#layout works with mixed :name,:type and :name,:type,offset" do
+    class MixedLayout < FFI::Struct
+      layout :a, :int, :b, :long_long, 4
+    end
+    MixedLayout.size.should == 12
+    mp = MemoryPointer.new(12)
+    s = MixedLayout.new mp
+    s[:a] = 0x12345678
+    mp.get_int(0).should == 0x12345678
+    s[:b] = 0xfee1deadbeef
+    mp.get_int64(4).should == 0xfee1deadbeef
+  end
+  rb_maj, rb_min = RUBY_VERSION.split('.')
+  if rb_maj.to_i >= 1 && rb_min.to_i >= 9 || RUBY_PLATFORM =~ /java/
+    it "Struct#layout withs with a hash of :name => type" do
+      class HashLayout < FFI::Struct
+        layout :a => :int, :b => :long_long
+      end
+      HashLayout.size.should == 12
+      mp = MemoryPointer.new(12)
+      s = HashLayout.new mp
+      s[:a] = 0x12345678
+      mp.get_int(0).should == 0x12345678
+      s[:b] = 0xfee1deadbeef
+      mp.get_int64(4).should == 0xfee1deadbeef
+      end
+  end
+  it "Can use Struct subclass as parameter type" do
+    module StructParam
+      extend FFI::Library
+      ffi_lib TestLibrary::PATH
+      class TestStruct < FFI::Struct
+        layout :c, :char
+      end
+      attach_function :struct_field_s8, [ TestStruct ], :char
+    end
+  end
+  it "Can use Struct subclass as IN parameter type" do
+    module StructParam
+      extend FFI::Library
+      ffi_lib TestLibrary::PATH
+      class TestStruct < FFI::Struct
+        layout :c, :char
+      end
+      attach_function :struct_field_s8, [ TestStruct.in ], :char
+    end
+  end
+  it "Can use Struct subclass as OUT parameter type" do
+    module StructParam
+      extend FFI::Library
+      ffi_lib TestLibrary::PATH
+      class TestStruct < FFI::Struct
+        layout :c, :char
+      end
+      attach_function :struct_field_s8, [ TestStruct.out ], :char
+    end
+  end
+  it ":char member aligned correctly" do
+    class AlignChar < FFI::Struct
+      layout :c, :char, :v, :char
+    end
+    s = AlignChar.new
+    s[:v] = 0x12
+    LibTest.struct_align_s8(s.pointer).should == 0x12
+  end
+  it ":short member aligned correctly" do
+    class AlignShort < FFI::Struct
+      layout :c, :char, :v, :short
+    end
+    s = AlignShort.alloc_in
+    s[:v] = 0x1234
+    LibTest.struct_align_s16(s.pointer).should == 0x1234
+  end
+  it ":int member aligned correctly" do
+    class AlignInt < FFI::Struct
+      layout :c, :char, :v, :int
+    end
+    s = AlignInt.alloc_in
+    s[:v] = 0x12345678
+    LibTest.struct_align_s32(s.pointer).should == 0x12345678
+  end
+  it ":long_long member aligned correctly" do
+    class AlignLongLong < FFI::Struct
+      layout :c, :char, :v, :long_long
+    end
+    s = AlignLongLong.alloc_in
+    s[:v] = 0x123456789abcdef0
+    LibTest.struct_align_s64(s.pointer).should == 0x123456789abcdef0
+  end
+  it ":long member aligned correctly" do
+    class AlignLong < FFI::Struct
+      layout :c, :char, :v, :long
+    end
+    s = AlignLong.alloc_in
+    s[:v] = 0x12345678
+    LibTest.struct_align_long(s.pointer).should == 0x12345678
+  end
+  it ":float member aligned correctly" do
+    class AlignFloat < FFI::Struct
+      layout :c, :char, :v, :float
+    end
+    s = AlignFloat.alloc_in
+    s[:v] = 1.23456
+    (LibTest.struct_align_f32(s.pointer) - 1.23456).abs.should < 0.00001
+  end
+  it ":double member aligned correctly" do
+    class AlignDouble < FFI::Struct
+      layout :c, :char, :v, :double
+    end
+    s = AlignDouble.alloc_in
+    s[:v] = 1.23456789
+    (LibTest.struct_align_f64(s.pointer) - 1.23456789).abs.should < 0.00000001
+  end
+  it ":ulong, :pointer struct" do
+    class ULPStruct < FFI::Struct
+      layout :ul, :ulong, :p, :pointer
+    end
+    s = ULPStruct.alloc_in
+    s[:ul] = 0xdeadbeef
+    s[:p] = LibTest.ptr_from_address(0x12345678)
+    s.pointer.get_ulong(0).should == 0xdeadbeef
+  end
+end