ffi 1.0.10 → 1.0.11

data/spec/ffi/library_spec.rb

@@ -16,8 +16,26 @@
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
 describe "Library" do
+  describe "#ffi_convention" do
+    it "defaults to :default" do
+      m = Module.new do
+        extend FFI::Library
+      end
+      m.ffi_convention.should eq :default
+    end
+
+    it "should be settable" do
+      m = Module.new do
+        extend FFI::Library
+      end
+
+      m.ffi_convention.should eq :default
+      m.ffi_convention :stdcall
+      m.ffi_convention.should eq :stdcall
+    end
+  end
 
-  unless Config::CONFIG['target_os'] =~ /mswin|mingw/
+  unless RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
     it "attach_function with no library specified" do
       lambda {
         Module.new do |m|
@@ -32,7 +50,7 @@ describe "Library" do
           m.extend FFI::Library
           ffi_lib FFI::Library::CURRENT_PROCESS
           attach_function :getpid, [ ], :uint
-        end.getpid.should == Process.pid
+        end.getpid.should eq Process.pid
       }.should_not raise_error
     end
     it "attach_function :getpid from [ 'c', 'libc.so.6'] " do
@@ -41,7 +59,7 @@ describe "Library" do
           m.extend FFI::Library
           ffi_lib [ 'c', 'libc.so.6' ]
           attach_function :getpid, [ ], :uint
-        end.getpid.should == Process.pid
+        end.getpid.should eq Process.pid
       }.should_not raise_error
     end
     it "attach_function :getpid from [ 'libc.so.6', 'c' ] " do
@@ -50,7 +68,7 @@ describe "Library" do
           m.extend FFI::Library
           ffi_lib [ 'libc.so.6', 'c' ]
           attach_function :getpid, [ ], :uint
-        end.getpid.should == Process.pid
+        end.getpid.should eq Process.pid
       }.should_not raise_error
     end
     it "attach_function :getpid from [ 'libfubar.so.0xdeadbeef', nil, 'c' ] " do
@@ -59,7 +77,7 @@ describe "Library" do
           m.extend FFI::Library
           ffi_lib [ 'libfubar.so.0xdeadbeef', nil, 'c' ]
           attach_function :getpid, [ ], :uint
-        end.getpid.should == Process.pid
+        end.getpid.should eq Process.pid
       }.should_not raise_error
     end
     it "attach_function :getpid from [ 'libfubar.so.0xdeadbeef' ] " do
@@ -68,7 +86,7 @@ describe "Library" do
           m.extend FFI::Library
           ffi_lib 'libfubar.so.0xdeadbeef'
           attach_function :getpid, [ ], :uint
-        end.getpid.should == Process.pid
+        end.getpid.should eq Process.pid
       }.should raise_error(LoadError)
     end
   end
@@ -85,10 +103,10 @@ describe "Library" do
   def gvar_test(name, type, val)
     lib = gvar_lib(name, type)
     lib.set(val)
-    lib.gvar.should == val
+    lib.gvar.should eq val
     lib.set(0)
     lib.gvar = val
-    lib.get.should == val
+    lib.get.should eq val
   end
   [ 0, 127, -128, -1 ].each do |i|
     it ":char variable" do
@@ -157,10 +175,10 @@ describe "Library" do
     lib = gvar_lib("pointer", :pointer)
     val = FFI::MemoryPointer.new :long
     lib.set(val)
-    lib.gvar.should == val
+    lib.gvar.should eq val
     lib.set(nil)
     lib.gvar = val
-    lib.get.should == val
+    lib.get.should eq val
   end
 
   [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
@@ -180,11 +198,11 @@ describe "Library" do
       val = GlobalStruct.new
       val[:data] = i
       lib.set(val)
-      lib.gvar[:data].should == i
+      lib.gvar[:data].should eq i
       val[:data] = 0
       lib.gvar[:data] = i
       val = GlobalStruct.new(lib.get)
-      val[:data].should == i
+      val[:data].should eq i
     end
   end
 end

data/spec/ffi/managed_struct_spec.rb

@@ -19,14 +19,14 @@ require 'java' if RUBY_PLATFORM =~ /java/
 
 describe "Managed Struct" do
   include FFI
-  module LibTest
+  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
-    lambda { NoRelease.new(LibTest.ptr_from_address(0x12345678)) }.should raise_error(NoMethodError)
+    lambda { NoRelease.new(ManagedStructTestLib.ptr_from_address(0x12345678)) }.should raise_error(NoMethodError)
   end
 
   it "should be the right class" do
@@ -36,7 +36,7 @@ describe "Managed Struct" do
       end
     end    
 
-    WhatClassAmI.new(LibTest.ptr_from_address(0x12345678)).class.should == WhatClassAmI
+    WhatClassAmI.new(ManagedStructTestLib.ptr_from_address(0x12345678)).class.should eq WhatClassAmI
   end
 
   it "should release memory properly" do
@@ -65,7 +65,7 @@ describe "Managed Struct" do
 
     PleaseReleaseMe.should_receive(:release).at_least(loop_count-wiggle_room).times
     loop_count.times do
-      s = PleaseReleaseMe.new(LibTest.ptr_from_address(0x12345678))
+      PleaseReleaseMe.new(ManagedStructTestLib.ptr_from_address(0x12345678))
     end
     PleaseReleaseMe.wait_gc loop_count
   end

data/spec/ffi/number_spec.rb

@@ -37,95 +37,95 @@ describe "Function with primitive integer arguments" do
     attach_function :get_double, [ ], :double
   end
   it "int8.size" do
-    FFI::TYPE_INT8.size.should == 1
+    FFI::TYPE_INT8.size.should eq 1
   end
   it "uint8.size" do
-    FFI::TYPE_UINT8.size.should == 1
+    FFI::TYPE_UINT8.size.should eq 1
   end
   it "int16.size" do
-    FFI::TYPE_INT16.size.should == 2
+    FFI::TYPE_INT16.size.should eq 2
   end
   it "uint16.size" do
-    FFI::TYPE_UINT16.size.should == 2
+    FFI::TYPE_UINT16.size.should eq 2
   end
   it "int32.size" do
-    FFI::TYPE_INT32.size.should == 4
+    FFI::TYPE_INT32.size.should eq 4
   end
   it "uint32.size" do
-    FFI::TYPE_UINT32.size.should == 4
+    FFI::TYPE_UINT32.size.should eq 4
   end
   it "int64.size" do
-    FFI::TYPE_INT64.size.should == 8
+    FFI::TYPE_INT64.size.should eq 8
   end
   it "uint64.size" do
-    FFI::TYPE_UINT64.size.should == 8
+    FFI::TYPE_UINT64.size.should eq 8
   end
   it "float.size" do
-    FFI::TYPE_FLOAT32.size.should == 4
+    FFI::TYPE_FLOAT32.size.should eq 4
   end
   it "double.size" do
-    FFI::TYPE_FLOAT64.size.should == 8
+    FFI::TYPE_FLOAT64.size.should eq 8
   end
   [ 0, 127, -128, -1 ].each do |i|
     it ":char call(:char (#{i}))" do
-      LibTest.ret_s8(i).should == i
+      LibTest.ret_s8(i).should eq i
     end
   end
   [ 0, 0x7f, 0x80, 0xff ].each do |i|
     it ":uchar call(:uchar (#{i}))" do
-      LibTest.ret_u8(i).should == i
+      LibTest.ret_u8(i).should eq i
     end
   end
   [ 0, 0x7fff, -0x8000, -1 ].each do |i|
     it ":short call(:short (#{i}))" do
-      LibTest.ret_s16(i).should == i
+      LibTest.ret_s16(i).should eq i
     end
   end
   [ 0, 0x7fff, 0x8000, 0xffff ].each do |i|
     it ":ushort call(:ushort (#{i}))" do
-      LibTest.ret_u16(i).should == i
+      LibTest.ret_u16(i).should eq i
     end
   end
   [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
     it ":int call(:int (#{i}))" do
-      LibTest.ret_s32(i).should == i
+      LibTest.ret_s32(i).should eq i
     end
   end
   [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
     it ":uint call(:uint (#{i}))" do
-      LibTest.ret_u32(i).should == i
+      LibTest.ret_u32(i).should eq i
     end
   end
   [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
     it ":long_long call(:long_long (#{i}))" do
-      LibTest.ret_s64(i).should == i
+      LibTest.ret_s64(i).should eq i
     end
   end
   [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
     it ":ulong_long call(:ulong_long (#{i}))" do
-      LibTest.ret_u64(i).should == i
+      LibTest.ret_u64(i).should eq 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
+        LibTest.ret_long(i).should eq i
       end
     end
     [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
       it ":ulong call(:ulong (#{i}))" do
-        LibTest.ret_ulong(i).should == i
+        LibTest.ret_ulong(i).should eq i
       end
     end
   else
     [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
       it ":long call(:long (#{i}))" do
-        LibTest.ret_long(i).should == i
+        LibTest.ret_long(i).should eq i
       end
     end
     [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
       it ":ulong call(:ulong (#{i}))" do
-        LibTest.ret_ulong(i).should == i
+        LibTest.ret_ulong(i).should eq i
       end
     end
     [ 0.0, 0.1, 1.1, 1.23 ].each do |f|
@@ -145,32 +145,32 @@ 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
+      lambda { LibTest.ret_int8_t(i).should eq 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
+      lambda { LibTest.ret_u_int8_t(i).should eq 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
+      lambda { LibTest.ret_int16_t(i).should eq 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
+      lambda { LibTest.ret_u_int16_t(i).should eq 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
+      lambda { LibTest.ret_int32_t(i).should eq 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
+      lambda { LibTest.ret_u_int32_t(i).should eq i }.should raise_error
     end
   end
 end
@@ -214,17 +214,17 @@ describe "Three different size Integer arguments" do
 #    '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
+
+  def verify(p, off, t, v)
+    if t == 'f32'
+      p.get_float32(off).should eq v
+    elsif t == 'f64'
+      p.get_float64(off).should eq v
+    else
+      p.get_int64(off).should eq v
     end
   end
+
   PACK_VALUES.keys.each do |t1|
     PACK_VALUES.keys.each do |t2|
       PACK_VALUES.keys.each do |t3|
@@ -234,9 +234,9 @@ describe "Three different size Integer arguments" do
               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)
+                verify(p, 0, t1, v1)
+                verify(p, 8, t2, v2)
+                verify(p, 16, t3, v3)
               end
             end
           end

data/spec/ffi/pointer_spec.rb

@@ -40,7 +40,7 @@ describe "Pointer" do
     magic = 0x12345678
     memory.put_int32(0, magic)
     tp = ToPtrTest.new(memory)
-    PointerTestLib.ptr_ret_int32_t(tp, 0).should == magic
+    PointerTestLib.ptr_ret_int32_t(tp, 0).should eq magic
   end
   class PointerDelegate < DelegateClass(FFI::Pointer)
     def initialize(ptr)
@@ -55,7 +55,7 @@ describe "Pointer" do
     magic = 0x12345678
     memory.put_int32(0, magic)
     ptr = PointerDelegate.new(memory)
-    PointerTestLib.ptr_ret_int32_t(ptr, 0).should == magic
+    PointerTestLib.ptr_ret_int32_t(ptr, 0).should eq magic
   end
   it "Fixnum cannot be used as a Pointer argument" do
     lambda { PointerTestLib.ptr_ret_int32(0, 0) }.should raise_error
@@ -69,13 +69,13 @@ describe "Pointer" do
     it "#read_pointer" do
       memory = FFI::MemoryPointer.new :pointer
       PointerTestLib.ptr_set_pointer(memory, 0, PointerTestLib.ptr_from_address(0xdeadbeef))
-      memory.read_pointer.address.should == 0xdeadbeef
+      memory.read_pointer.address.should eq 0xdeadbeef
     end
 
     it "#write_pointer" do
       memory = FFI::MemoryPointer.new :pointer
       memory.write_pointer(PointerTestLib.ptr_from_address(0xdeadbeef))
-      PointerTestLib.ptr_ret_pointer(memory, 0).address.should == 0xdeadbeef
+      PointerTestLib.ptr_ret_pointer(memory, 0).address.should eq 0xdeadbeef
     end
 
     it "#read_array_of_pointer" do
@@ -86,7 +86,7 @@ describe "Pointer" do
       end
       array = memory.read_array_of_pointer(values.size)
       values.each_with_index do |address, j|
-        array[j].address.should == address
+        array[j].address.should eq address
       end
     end
     
@@ -149,7 +149,7 @@ describe "AutoPointer" 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(PointerTestLib.ptr_from_address(magic))
+      AutoPointerSubclass.new(PointerTestLib.ptr_from_address(magic))
     end
     AutoPointerTestHelper.gc_everything loop_count
   end
@@ -166,8 +166,8 @@ describe "AutoPointer" do
     AutoPointerTestHelper.should_receive(:release).at_least(loop_count-wiggle_room).times
     AutoPointerTestHelper.reset
     loop_count.times do
-      ap = FFI::AutoPointer.new(PointerTestLib.ptr_from_address(magic),
-                                AutoPointerTestHelper.finalizer)
+      FFI::AutoPointer.new(PointerTestLib.ptr_from_address(magic),
+                           AutoPointerTestHelper.finalizer)
     end
     AutoPointerTestHelper.gc_everything loop_count
   end
@@ -176,8 +176,8 @@ describe "AutoPointer" do
     AutoPointerTestHelper.should_receive(:release).at_least(loop_count-wiggle_room).times
     AutoPointerTestHelper.reset
     loop_count.times do
-      ap = FFI::AutoPointer.new(PointerTestLib.ptr_from_address(magic),
-                                AutoPointerTestHelper.method(:release))
+      FFI::AutoPointer.new(PointerTestLib.ptr_from_address(magic),
+                           AutoPointerTestHelper.method(:release))
     end
     AutoPointerTestHelper.gc_everything loop_count
   end
@@ -194,21 +194,18 @@ describe "AutoPointer" do
       end
     end.should_not raise_error
   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(PointerTestLib.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
+  describe "#new" do
+    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(PointerTestLib.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
 end
 

data/spec/ffi/rbx/memory_pointer_spec.rb

@@ -12,44 +12,44 @@ end
 describe "MemoryPointer" do
   it "makes a pointer from a string" do
     m = FFI::MemoryPointer.from_string("FFI is Awesome")
-    m.total.should == 15
-    m.type_size.should == 1
+    m.total.should eq 15
+    m.type_size.should eq 1
   end
 
   it "makes a pointer from a string with multibyte characters" do
     m = FFI::MemoryPointer.from_string("ぱんだ")
-    m.total.should == 10
-    m.type_size.should == 1
+    m.total.should eq 10
+    m.type_size.should eq 1
   end
 
   it "reads back a string" do
     m = FFI::MemoryPointer.from_string("FFI is Awesome")
-    m.read_string.should == "FFI is Awesome"
+    m.read_string.should eq "FFI is Awesome"
   end
   
   it "makes a pointer for a certain number of bytes" do
     m = FFI::MemoryPointer.new(8)
     m.write_array_of_int([1,2])
-    m.read_array_of_int(2).should == [1,2]
+    m.read_array_of_int(2).should eq [1,2]
   end
 
   it "allows access to an element of the pointer (as an array)" do
     m = FFI::MemoryPointer.new(:int, 2)
     m.write_array_of_int([1,2])
-    m[0].read_int.should == 1
-    m[1].read_int.should == 2
+    m[0].read_int.should eq 1
+    m[1].read_int.should eq 2
   end
   
   it "allows writing as an int" do
     m = FFI::MemoryPointer.new(:int)
     m.write_int(1)
-    m.read_int.should == 1
+    m.read_int.should eq 1
   end
   
   it "allows writing as a long" do
     m = FFI::MemoryPointer.new(:long)
     m.write_long(10)
-    m.read_long.should == 10
+    m.read_long.should eq 10
   end
   
   it "raises an error if you try putting a long into a pointer of size 1" do
@@ -72,40 +72,40 @@ describe "MemoryPointer" do
   it "makes a pointer for a certain type" do
     m = FFI::MemoryPointer.new(:int)
     m.write_int(10)
-    m.read_int.should == 10
+    m.read_int.should eq 10
   end
   
   it "makes a memory pointer for a number of a certain type" do
     m = FFI::MemoryPointer.new(:int, 2)
     m.write_array_of_int([1,2])
-    m.read_array_of_int(2).should == [1,2]
+    m.read_array_of_int(2).should eq [1,2]
   end
   
   it "makes a pointer for an object responding to #size" do
     m = FFI::MemoryPointer.new(Struct.new(:size).new(8))
     m.write_array_of_int([1,2])
-    m.read_array_of_int(2).should == [1,2]
+    m.read_array_of_int(2).should eq [1,2]
   end
 
   it "makes a pointer for a number of an object responding to #size" do
     m = FFI::MemoryPointer.new(Struct.new(:size).new(4), 2)
     m.write_array_of_int([1,2])
-    m.read_array_of_int(2).should == [1,2]
+    m.read_array_of_int(2).should eq [1,2]
   end  
   it "MemoryPointer#address returns correct value" do
     m = FFI::MemoryPointer.new(:long_long)
     magic = 0x12345678
     m.write_long(magic)
-    m.read_pointer.address.should == magic
+    m.read_pointer.address.should eq magic
   end
   it "MemoryPointer#null? returns true for zero value" do
     m = FFI::MemoryPointer.new(:long_long)
     m.write_long(0)    
-    m.read_pointer.null?.should == true
+    m.read_pointer.null?.should eq true
   end
   it "MemoryPointer#null? returns false for non-zero value" do
     m = FFI::MemoryPointer.new(:long_long)
     m.write_long(0x12345678)
-    m.read_pointer.null?.should == false
+    m.read_pointer.null?.should eq false
   end
 end