ffi 1.9.5-x64-mingw32 → 1.9.6-x64-mingw32

data/spec/ffi/ffi_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe "FFI" do
 
@@ -12,19 +11,18 @@ describe "FFI" do
 
     let(:prefix) { FFI::Platform::LIBPREFIX }
     let(:suffix) { FFI::Platform::LIBSUFFIX }
-    
+
     it "should add platform library extension if not present" do
-      FFI.map_library_name("#{prefix}dummy").should == "#{prefix}dummy.#{suffix}"
+      expect(FFI.map_library_name("#{prefix}dummy")).to eq("#{prefix}dummy.#{suffix}")
     end
 
     it "should add platform library extension even if lib suffix is present in name" do
-      FFI.map_library_name("#{prefix}dummy_with_#{suffix}").should == "#{prefix}dummy_with_#{suffix}.#{suffix}"
+      expect(FFI.map_library_name("#{prefix}dummy_with_#{suffix}")).to eq("#{prefix}dummy_with_#{suffix}.#{suffix}")
     end
 
     it "should return Platform::LIBC when called with 'c'" do
-      FFI.map_library_name('c').should == FFI::Library::LIBC
+      expect(FFI.map_library_name('c')).to eq(FFI::Library::LIBC)
     end
 
   end
-
 end

data/spec/ffi/function_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe FFI::Function do
   module LibTest
@@ -16,33 +15,41 @@ describe FFI::Function 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
-    lambda { FFI::Function.new([], :int).new { } }.should raise_error TypeError 
+    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 }
-    LibTest.testFunctionAdd(10, 10, function_add).should == 20
+    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 })
-    LibTest.testFunctionAdd(10, 10, function_add).should == 20
+    expect(LibTest.testFunctionAdd(10, 10, function_add)).to eq(20)
   end
+
   it 'can be used to wrap an existing function pointer' do
-    FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd')).call(10, 10).should == 20
+    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')
-    Foo.add(10, 10).should == 20
+    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
@@ -52,27 +59,31 @@ describe FFI::Function do
       end
     end
     fp.attach(foo.singleton_class, 'add')
-    foo.add(10, 10).should == 20    
+    expect(foo.add(10, 10)).to eq(20)
   end
+
   it 'can wrap a blocking function' do
     fp = FFI::Function.new(:void, [ :int ], @libtest.find_function('testBlocking'), :blocking => true)
     time = Time.now
     threads = []
     threads << Thread.new { fp.call(2) }
-    threads << Thread.new(time) { (Time.now - time).should < 1 }
+    threads << Thread.new(time) { expect(Time.now - time).to be < 1 }
     threads.each { |t| t.join }
   end
+
   it 'autorelease flag is set to true by default' do
     fp = FFI::Function.new(:int, [:int, :int], @libtest.find_function('testAdd'))
-    fp.autorelease?.should be_true
+    expect(fp.autorelease?).to be true
   end
+
   it 'can explicity free itself' do
     fp = FFI::Function.new(:int, []) { }
     fp.free
-    lambda { fp.free }.should raise_error RuntimeError
+    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'))
-    lambda { fp.free }.should raise_error RuntimeError
+    expect { fp.free }.to raise_error RuntimeError
   end
 end

data/spec/ffi/io_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 if false # disabled for #390
   describe "FFI::IO.for_fd" do

data/spec/ffi/library_spec.rb

@@ -4,15 +4,30 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 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
-      m.ffi_convention.should == :default
+      expect(m.ffi_convention).to eq(:default)
     end
 
     it "should be settable" do
@@ -20,9 +35,9 @@ describe "Library" do
         extend FFI::Library
       end
 
-      m.ffi_convention.should == :default
+      expect(m.ffi_convention).to eq(:default)
       m.ffi_convention :stdcall
-      m.ffi_convention.should == :stdcall
+      expect(m.ffi_convention).to eq(:stdcall)
     end
   end
 
@@ -51,76 +66,83 @@ describe "Library" do
 
   describe "ffi_lib" do
     it "empty name list should raise error" do
-      lambda {
+      expect {
         Module.new do |m|
           m.extend FFI::Library
           ffi_lib
         end
-      }.should raise_error(LoadError)
+      }.to raise_error(LoadError)
     end
     
   end
+
   unless RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
     it "attach_function with no library specified" do
-      lambda {
+      expect {
         Module.new do |m|
           m.extend FFI::Library
           attach_function :getpid, [ ], :uint
         end
-      }.should raise_error
+      }.to raise_error
     end
+
     it "attach_function :getpid from this process" do
-      lambda {
-        Module.new do |m|
+      expect {
+        expect(Module.new do |m|
           m.extend FFI::Library
           ffi_lib FFI::Library::CURRENT_PROCESS
           attach_function :getpid, [ ], :uint
-        end.getpid.should == Process.pid
-      }.should_not raise_error
+        end.getpid).to eq(Process.pid)
+      }.not_to raise_error
     end
+
     it "attach_function :getpid from [ 'c', 'libc.so.6'] " do
-      lambda {
-        Module.new do |m|
+      expect {
+        expect(Module.new do |m|
           m.extend FFI::Library
           ffi_lib [ 'c', 'libc.so.6' ]
           attach_function :getpid, [ ], :uint
-        end.getpid.should == Process.pid
-      }.should_not raise_error
+        end.getpid).to eq(Process.pid)
+      }.not_to raise_error
     end
+
     it "attach_function :getpid from [ 'libc.so.6', 'c' ] " do
-      lambda {
-        Module.new do |m|
+      expect {
+        expect(Module.new do |m|
           m.extend FFI::Library
           ffi_lib [ 'libc.so.6', 'c' ]
           attach_function :getpid, [ ], :uint
-        end.getpid.should == Process.pid
-      }.should_not raise_error
+        end.getpid).to eq(Process.pid)
+      }.not_to raise_error
     end
+
     it "attach_function :getpid from [ 'libfubar.so.0xdeadbeef', nil, 'c' ] " do
-      lambda {
-        Module.new do |m|
+      expect {
+        expect(Module.new do |m|
           m.extend FFI::Library
           ffi_lib [ 'libfubar.so.0xdeadbeef', nil, 'c' ]
           attach_function :getpid, [ ], :uint
-        end.getpid.should == Process.pid
-      }.should_not raise_error
+        end.getpid).to eq(Process.pid)
+      }.not_to raise_error
     end
+
     it "attach_function :getpid from [ 'libfubar.so.0xdeadbeef' ] " do
-      lambda {
-        Module.new do |m|
+      expect {
+        expect(Module.new do |m|
           m.extend FFI::Library
           ffi_lib 'libfubar.so.0xdeadbeef'
           attach_function :getpid, [ ], :uint
-        end.getpid.should == Process.pid
-      }.should raise_error(LoadError)
+        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
-      Module.new do |m|
+      mod = Module.new do |m|
         m.extend FFI::Library
         ffi_lib File.expand_path(TestLibrary::PATH)
         attach_function :bool_return_true, [ ], :bool
-        m.bool_return_true.should == true
       end
+      expect(mod.bool_return_true).to be true
     end
   end
 
@@ -133,60 +155,71 @@ describe "Library" do
       attach_function :set, "gvar_#{name}_set", [ type ], :void
     end
   end
+
   def gvar_test(name, type, val)
     lib = gvar_lib(name, type)
     lib.set(val)
-    lib.gvar.should == val
+    expect(lib.gvar).to eq(val)
     lib.set(0)
     lib.gvar = val
-    lib.get.should == 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)
@@ -198,20 +231,22 @@ describe "Library" 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)
-    lib.gvar.should == val
+    expect(lib.gvar).to eq(val)
     lib.set(nil)
     lib.gvar = val
-    lib.get.should == val
+    expect(lib.get).to eq(val)
   end
 
   [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
@@ -231,11 +266,11 @@ describe "Library" do
       val = GlobalStruct.new
       val[:data] = i
       lib.set(val)
-      lib.gvar[:data].should == i
+      expect(lib.gvar[:data]).to eq(i)
       val[:data] = 0
       lib.gvar[:data] = i
       val = GlobalStruct.new(lib.get)
-      val[:data].should == i
+      expect(val[:data]).to eq(i)
     end
   end
 end

data/spec/ffi/long_double.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 require 'bigdecimal'
 
 describe ":long_double arguments and return values" do
@@ -16,16 +15,16 @@ describe ":long_double arguments and return values" do
   end
 
   it "returns first parameter" do
-    LibTest.ret_f128(0.1).should be_within(0.01).of(0.1)
+    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")
-    LibTest.ret_f128(ld).should be_within(tolerance).of(ld)
+    expect(LibTest.ret_f128(ld)).to be_within(tolerance).of(ld)
   end
 
   it "add two long double numbers" do
-    LibTest.add_f128(0.1, 0.2).should be_within(0.01).of(0.3)
+    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

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe "Managed Struct" do
   include FFI
@@ -13,9 +12,10 @@ describe "Managed Struct" do
     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(ManagedStructTestLib.ptr_from_address(0x12345678)) }.should raise_error(NoMethodError)
+    expect { NoRelease.new(ManagedStructTestLib.ptr_from_address(0x12345678)) }.to raise_error(NoMethodError)
   end
 
   it "should be the right class" do
@@ -25,7 +25,17 @@ describe "Managed Struct" do
       end
     end    
 
-    WhatClassAmI.new(ManagedStructTestLib.ptr_from_address(0x12345678)).class.should == WhatClassAmI
+    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
 
   it "should release memory properly" do
@@ -48,7 +58,7 @@ describe "Managed Struct" do
     loop_count = 30
     wiggle_room = 5
 
-    PleaseReleaseMe.should_receive(:release).at_least(loop_count-wiggle_room).times
+    expect(PleaseReleaseMe).to receive(:release).at_least(loop_count-wiggle_room).times
     loop_count.times do
       PleaseReleaseMe.new(ManagedStructTestLib.ptr_from_address(0x12345678))
     end