ffi 1.9.5 → 1.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7013b75917232a600f34c40064aea616e6556cda
-  data.tar.gz: 8a604d6fe1692dd01a41e1d76da0628bf50b2ee6
+  metadata.gz: cbe4e813add8c92cda54f9eff70d9d4c5e9c6b2d
+  data.tar.gz: 8b44830705842817d995adc6bf071745048420bc
 SHA512:
-  metadata.gz: ab9eb638b362b5c77ef1bb6c6308d5e36889bb281bb86f4615ca792061687567d924b1c6df6b50ec769d209afd6b539bd498a499e8d91d6417636d5bef8c54bd
-  data.tar.gz: 994ccfce09d582d6f1bbac43edb2ac1cdaff7d9e760e4766c0f6b1e54b53eac1e55de9db5a8304d88ddbedb1a07730f0cac1865b6f0a1cf2f46ddb18c935d087
+  metadata.gz: 85e073b1dca3bcc90b61e7efce2b75fad8aa39d76f6969faea08e74649b20cf139fdbeb8e75cffea11162cbf36e05fc94f59335773c9a4a26a03674d7fcaee5f
+  data.tar.gz: 81b40510ce47dc5b291cf694a058cda4bbea674be2b46593fc9db0fc090f9d92ffc8eb4556caed73fba52df0e9f68835429946ef58dd1e80f6d82c75f96c1589

data/Rakefile

@@ -150,11 +150,6 @@ task 'spec:specdoc' => TEST_DEPS
 
 task :default => :specs
 
-task 'gem:win32' do
-  sh("rake cross native gem RUBY_CC_VERSION='1.8.7:1.9.3:2.0.0:2.1.3'") || raise("win32 build failed!")
-end
-
-
 namespace 'java' do
 
   java_gem_spec = Gem::Specification.new do |s|
@@ -190,11 +185,23 @@ if USE_RAKE_COMPILER
     ext.cross_platform = %w[i386-mingw32 x64-mingw32]                     # forces the Windows platform instead of the default one
   end
 
-  ENV['RUBY_CC_VERSION'].to_s.split(':').each do |ruby_version|
+  task 'gem:win32' => ['gem:win32-x64', 'gem:win32-i386']
+
+  task 'gem:win32-x86' do
+    sh("rake cross native:i386-mingw32 gem RUBY_CC_VERSION='1.8.7:1.9.3:2.0.0:2.1.3'") || raise("win32-i386 build failed!")
+  end
+
+  task 'gem:win32-x64' do
+    sh("rake cross native:x64-mingw32 gem RUBY_CC_VERSION='2.0.0:2.1.3'") || raise("win32-x64 build failed!")
+  end
+
+  (ENV['RUBY_CC_VERSION'] || '1.8.7:1.9.3:2.0.0:2.1.3' ).to_s.split(':').each do |ruby_version|
     task "copy:ffi_c:i386-mingw32:#{ruby_version}" do |t|
       sh "i686-w64-mingw32-strip -S #{BUILD_DIR}/i386-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/ffi_c.so"
     end
+  end
 
+  (ENV['RUBY_CC_VERSION'] || '2.0.0:2.1.3' ).to_s.split(':').each do |ruby_version|
     task "copy:ffi_c:x64-mingw32:#{ruby_version}" do |t|
       sh "x86_64-w64-mingw32-strip -S #{BUILD_DIR}/x64-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/ffi_c.so"
     end

data/ext/ffi_c/extconf.rb

@@ -9,8 +9,8 @@ if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
   $warnflags = ''
   $CFLAGS.gsub!(/[\s+]-ansi/, '')
   $CFLAGS.gsub!(/[\s+]-std=[^\s]+/, '')
-  # solaris needs -c99 for <stdbool.h>
-  $CFLAGS << " -std=c99" if RbConfig::CONFIG['host_os'] =~ /solaris/
+  # solaris 10 needs -c99 for <stdbool.h>
+  $CFLAGS << " -std=c99" if RbConfig::CONFIG['host_os'] =~ /solaris(!?2\.11)/
   
   if ENV['RUBY_CC_VERSION'].nil? && (pkg_config("libffi") ||
      have_header("ffi.h") ||

data/lib/ffi.rb

@@ -7,6 +7,8 @@ if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
       require '1.9/ffi_c'
     elsif RUBY_VERSION =~ /2.0/
       require '2.0/ffi_c'
+    elsif RUBY_VERSION =~ /2.1/
+      require '2.1/ffi_c'
     else
       require 'ffi_c'
     end

data/lib/ffi/version.rb

@@ -1,4 +1,4 @@
 module FFI
-  VERSION = '1.9.5'
+  VERSION = '1.9.6'
 end
 

data/spec/ffi/async_callback_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe "async callback" do
   module LibTest
@@ -21,8 +20,8 @@ describe "async callback" do
     called = false
     cb = Proc.new {|i| v = i; called = true }
     LibTest.testAsyncCallback(cb, 0x7fffffff) 
-    called.should be_true
-    v.should == 0x7fffffff
+    expect(called).to be true
+    expect(v).to eq(0x7fffffff)
   end
   
   it "called a second time" do
@@ -30,7 +29,7 @@ describe "async callback" do
     called = false
     cb = Proc.new {|i| v = i; called = true }
     LibTest.testAsyncCallback(cb, 0x7fffffff) 
-    called.should be_true
-    v.should == 0x7fffffff
+    expect(called).to be true
+    expect(v).to eq(0x7fffffff)
   end
 end

data/spec/ffi/bool_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe "Function with primitive boolean arguments and return values" do
   module LibTest
@@ -15,17 +14,19 @@ describe "Function with primitive boolean arguments and return values" do
     attach_function :bool_return_val, [ :bool ], :bool
     attach_function :bool_reverse_val, [ :bool ], :bool
   end
+
   it "bools" do
-    LibTest.bool_return_true.should == true
-    LibTest.bool_return_false.should == false
+    expect(LibTest.bool_return_true).to be true
+    expect(LibTest.bool_return_false).to be false
 
-    LibTest.bool_return_val(true).should == true
-    LibTest.bool_return_val(false).should == false
+    expect(LibTest.bool_return_val(true)).to be true
+    expect(LibTest.bool_return_val(false)).to be false
 
-    LibTest.bool_reverse_val(true).should == false
-    LibTest.bool_reverse_val(false).should == true
+    expect(LibTest.bool_reverse_val(true)).to be false
+    expect(LibTest.bool_reverse_val(false)).to be true
   end
+
   it "raise error on invalid types" do
-    lambda { LibTest.bool_return_val(nil) }.should raise_error(::TypeError)
+    expect { LibTest.bool_return_val(nil) }.to raise_error(::TypeError)
   end
 end

data/spec/ffi/buffer_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe "Buffer#total" do
   [1,2,3].each do |i|
@@ -12,14 +11,17 @@ describe "Buffer#total" do
       :uint => 4, :long => FFI::Type::LONG.size, :ulong => FFI::Type::ULONG.size, 
       :long_long => 8, :ulong_long => 8, :float => 4, :double => 8
     }.each_pair do |t, s|
+
       it "Buffer.alloc_in(#{t}, #{i}).total == #{i * s}" do
-        FFI::Buffer.alloc_in(t, i).total.should == i * s
+        expect(FFI::Buffer.alloc_in(t, i).total).to eq(i * s)
       end
+
       it "Buffer.alloc_out(#{t}, #{i}).total == #{i * s}" do
-        FFI::Buffer.alloc_out(t, i).total.should == i * s
+        expect(FFI::Buffer.alloc_out(t, i).total).to eq(i * s)
       end
+
       it "Buffer.alloc_inout(#{t}, #{i}).total == #{i * s}" do
-        FFI::Buffer.alloc_inout(t, i).total.should == i * s
+        expect(FFI::Buffer.alloc_inout(t, i).total).to eq(i * s)
       end
     end
   end
@@ -30,214 +32,239 @@ describe "Buffer#put_char" do
   (0..127).each do |i|
     (0..bufsize-1).each do |offset|
       it "put_char(#{offset}, #{i}).get_char(#{offset}) == #{i}" do
-        FFI::Buffer.alloc_in(bufsize).put_char(offset, i).get_char(offset).should == i
+        expect(FFI::Buffer.alloc_in(bufsize).put_char(offset, i).get_char(offset)).to eq(i)
       end
     end
   end
 end
+
 describe "Buffer#put_uchar" do
   bufsize = 4
   (0..255).each do |i|
     (0..bufsize-1).each do |offset|
       it "Buffer.put_uchar(#{offset}, #{i}).get_uchar(#{offset}) == #{i}" do
-        FFI::Buffer.alloc_in(bufsize).put_uchar(offset, i).get_uchar(offset).should == i
+        expect(FFI::Buffer.alloc_in(bufsize).put_uchar(offset, i).get_uchar(offset)).to eq(i)
       end
     end
   end 
 end
+
 describe "Buffer#put_short" do
   bufsize = 4
   [0, 1, 128, 32767].each do |i|
     (0..bufsize-2).each do |offset|
       it "put_short(#{offset}, #{i}).get_short(#{offset}) == #{i}" do
-        FFI::Buffer.alloc_in(bufsize).put_short(offset, i).get_short(offset).should == i
+        expect(FFI::Buffer.alloc_in(bufsize).put_short(offset, i).get_short(offset)).to eq(i)
       end
     end
   end
 end
+
 describe "Buffer#put_ushort" do
   bufsize = 4
   [ 0, 1, 128, 32767, 65535, 0xfee1, 0xdead, 0xbeef, 0xcafe ].each do |i|
     (0..bufsize-2).each do |offset|
       it "put_ushort(#{offset}, #{i}).get_ushort(#{offset}) == #{i}" do
-        FFI::Buffer.alloc_in(bufsize).put_ushort(offset, i).get_ushort(offset).should == i
+        expect(FFI::Buffer.alloc_in(bufsize).put_ushort(offset, i).get_ushort(offset)).to eq(i)
       end
     end
   end
 end
+
 describe "Buffer#put_int" do
   bufsize = 8
   [0, 1, 128, 32767, 0x7ffffff ].each do |i|
     (0..bufsize-4).each do |offset|
       it "put_int(#{offset}, #{i}).get_int(#{offset}) == #{i}" do
-        FFI::Buffer.alloc_in(bufsize).put_int(offset, i).get_int(offset).should == i
+        expect(FFI::Buffer.alloc_in(bufsize).put_int(offset, i).get_int(offset)).to eq(i)
       end
     end
   end
 end
+
 describe "Buffer#put_uint" do
   bufsize = 8
   [ 0, 1, 128, 32767, 65535, 0xfee1dead, 0xcafebabe, 0xffffffff ].each do |i|
     (0..bufsize-4).each do |offset|
       it "put_uint(#{offset}, #{i}).get_uint(#{offset}) == #{i}" do
-        FFI::Buffer.alloc_in(bufsize).put_uint(offset, i).get_uint(offset).should == i
+        expect(FFI::Buffer.alloc_in(bufsize).put_uint(offset, i).get_uint(offset)).to eq(i)
       end
     end
   end
 end
+
 describe "Buffer#put_long" do
   bufsize = 16
   [0, 1, 128, 32767, 0x7ffffff ].each do |i|
     (0..bufsize-FFI::Type::LONG.size).each do |offset|
       it "put_long(#{offset}, #{i}).get_long(#{offset}) == #{i}" do
-        FFI::Buffer.alloc_in(bufsize).put_long(offset, i).get_long(offset).should == i
+        expect(FFI::Buffer.alloc_in(bufsize).put_long(offset, i).get_long(offset)).to eq(i)
       end
     end
   end
 end
+
 describe "Buffer#put_ulong" do
   bufsize = 16
   [ 0, 1, 128, 32767, 65535, 0xfee1dead, 0xcafebabe, 0xffffffff ].each do |i|
     (0..bufsize-FFI::Type::LONG.size).each do |offset|
       it "put_ulong(#{offset}, #{i}).get_ulong(#{offset}) == #{i}" do
-        FFI::Buffer.alloc_in(bufsize).put_ulong(offset, i).get_ulong(offset).should == i
+        expect(FFI::Buffer.alloc_in(bufsize).put_ulong(offset, i).get_ulong(offset)).to eq(i)
       end
     end
   end
 end
+
 describe "Buffer#put_long_long" do
   bufsize = 16
   [0, 1, 128, 32767, 0x7ffffffffffffff ].each do |i|
     (0..bufsize-8).each do |offset|
       it "put_long_long(#{offset}, #{i}).get_long_long(#{offset}) == #{i}" do
-        FFI::Buffer.alloc_in(bufsize).put_long_long(offset, i).get_long_long(offset).should == i
+        expect(FFI::Buffer.alloc_in(bufsize).put_long_long(offset, i).get_long_long(offset)).to eq(i)
       end
     end
   end
 end
+
 describe "Buffer#put_ulong_long" do
   bufsize = 16
   [ 0, 1, 128, 32767, 65535, 0xdeadcafebabe, 0x7fffffffffffffff ].each do |i|
     (0..bufsize-8).each do |offset|
       it "put_ulong_long(#{offset}, #{i}).get_ulong_long(#{offset}) == #{i}" do
-        FFI::Buffer.alloc_in(bufsize).put_ulong_long(offset, i).get_ulong_long(offset).should == i
+        expect(FFI::Buffer.alloc_in(bufsize).put_ulong_long(offset, i).get_ulong_long(offset)).to eq(i)
       end
     end
   end
 end
+
 describe "Reading/Writing binary strings" do
   it "Buffer#put_bytes" do
     str = "hello\0world"
     buf = FFI::Buffer.new 1024
     buf.put_bytes(0, str);
     s2 = buf.get_bytes(0, 11);
-    s2.should == str
+    expect(s2).to eq(str)
   end
+
   it "Buffer#put_bytes with index and length" do
     str = "hello\0world"
     buf = FFI::Buffer.new 1024
     buf.put_bytes(0, str, 5, 6);
     s2 = buf.get_bytes(0, 6);
-    s2.should == str[5..-1]
+    expect(s2).to eq(str[5..-1])
   end
+
   it "Buffer#put_bytes with only index" do
     str = "hello\0world"
     buf = FFI::Buffer.new 1024
     buf.put_bytes(0, str, 5);
     s2 = buf.get_bytes(0, 6);
-    s2.should == str[5..-1]
+    expect(s2).to eq(str[5..-1])
   end
+
   it "Buffer#put_bytes with index > str.length" do
     str = "hello\0world"
     buf = FFI::Buffer.new 1024
-    lambda { buf.put_bytes(0, str, 12); }.should raise_error
+    expect { buf.put_bytes(0, str, 12); }.to raise_error
   end
+
   it "Buffer#put_bytes with length > str.length" do
     str = "hello\0world"
     buf = FFI::Buffer.new 1024
-    lambda { buf.put_bytes(0, str, 0, 12); }.should raise_error
+    expect { buf.put_bytes(0, str, 0, 12); }.to raise_error
   end
-   it "Buffer#put_bytes with negative index" do
+
+  it "Buffer#put_bytes with negative index" do
     str = "hello\0world"
     buf = FFI::Buffer.new 1024
-    lambda { buf.put_bytes(0, str, -1, 12); }.should raise_error
-   end
+    expect { buf.put_bytes(0, str, -1, 12); }.to raise_error
+  end
 
   it "Buffer#write_bytes" do
     str = "hello\0world"
     buf = FFI::Buffer.new 1024
     buf.write_bytes(str)
     s2 = buf.get_bytes(0, 11)
-    s2.should == str
+    expect(s2).to eq(str)
   end
+
   it "Buffer#write_bytes with index and length" do
     str = "hello\0world"
     buf = FFI::Buffer.new 1024
     buf.write_bytes(str, 5, 6)
     s2 = buf.get_bytes(0, 6)
-    s2.should == str[5..-1]
+    expect(s2).to eq(str[5..-1])
   end
+
   it "Buffer#write_bytes with only index" do
     str = "hello\0world"
     buf = FFI::Buffer.new 1024
     buf.write_bytes(str, 5)
     s2 = buf.get_bytes(0, 6)
-    s2.should == str[5..-1]
+    expect(s2).to eq(str[5..-1])
   end
+
   it "Buffer#write_bytes with index > str.length" do
     str = "hello\0world"
     buf = FFI::Buffer.new 1024
-    lambda { buf.write_bytes(str, 12) }.should raise_error
+    expect { buf.write_bytes(str, 12) }.to raise_error
   end
+
   it "Buffer#put_bytes with length > str.length" do
     str = "hello\0world"
     buf = FFI::Buffer.new 1024
-    lambda { buf.put_bytes(0, str, 0, 12) }.should raise_error
+    expect { buf.put_bytes(0, str, 0, 12) }.to raise_error
   end
-   it "Buffer#write_bytes with negative index" do
+
+  it "Buffer#write_bytes with negative index" do
     str = "hello\0world"
     buf = FFI::Buffer.new 1024
-    lambda { buf.write_bytes(str, -1, 12) }.should raise_error
+    expect { buf.write_bytes(str, -1, 12) }.to raise_error
   end
 end
+
 describe "Reading/Writing ascii strings" do
   it "Buffer#put_string with string containing zero byte" do
     str = "hello\0world"
     buf = FFI::Buffer.new 1024
     buf.put_string(0, str);
     s2 = buf.get_bytes(0, 11);
-    s2.should == str
+    expect(s2).to eq(str)
   end
+
   it "Buffer#get_string with string containing zero byte" do
     str = "hello\0world"
     buf = FFI::Buffer.new 1024
     buf.put_bytes(0, str);
     s2 = buf.get_string(0, 11);
-    s2.should == "hello"
+    expect(s2).to eq("hello")
   end
+
   it "Buffer#put_string without length should NUL terminate" do
     str = "hello"
     buf = FFI::Buffer.new 1024
     buf.put_string(0, str);
     s2 = buf.get_bytes(0, 6);
-    s2.should == "hello\0"
+    expect(s2).to eq("hello\0")
   end
 end
+
 describe "Buffer#put_pointer" do
   it "put_pointer(0, p).get_pointer(0) == p" do
     p = FFI::MemoryPointer.new :ulong_long
     p.put_uint(0, 0xdeadbeef)
     buf = FFI::Buffer.alloc_inout 8
     p2 = buf.put_pointer(0, p).get_pointer(0)
-    p2.should_not be_nil
-    p2.should == p
-    p2.get_uint(0).should == 0xdeadbeef
+    expect(p2).not_to be_nil
+    expect(p2).to eq(p)
+    expect(p2.get_uint(0)).to eq(0xdeadbeef)
   end
 end
+
 describe "Buffer#size" do
   it "should return size" do
     buf = FFI::Buffer.new 14
-    buf.size.should == 14
+    expect(buf.size).to eq(14)
   end
 end
 
@@ -247,6 +274,6 @@ describe "Buffer#initialize" do
     FFI::Buffer.new(:pointer) do |ptr|
       block_executed = true
     end
-    block_executed.should be_true
+    expect(block_executed).to be true
   end
 end

data/spec/ffi/callback_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe "Callback" do
 #  module LibC
@@ -85,161 +84,197 @@ describe "Callback" do
     attach_function :testOptionalCallbackCrV, :testOptionalClosureBrV, [ :cbCrV, :char ], :void
 
   end
+
   it "returning :char (0)" do
-    LibTest.testCallbackVrS8 { 0 }.should == 0
+    expect(LibTest.testCallbackVrS8 { 0 }).to eq(0)
   end
+
   it "returning :char (127)" do
-    LibTest.testCallbackVrS8 { 127 }.should == 127
+    expect(LibTest.testCallbackVrS8 { 127 }).to eq(127)
   end
+
   it "returning :char (-128)" do
-    LibTest.testCallbackVrS8 { -128 }.should == -128
+    expect(LibTest.testCallbackVrS8 { -128 }).to eq(-128)
   end
   # test wrap around
   it "returning :char (128)" do
-    LibTest.testCallbackVrS8 { 128 }.should == -128
+    expect(LibTest.testCallbackVrS8 { 128 }).to eq(-128)
   end
+
   it "returning :char (255)" do
-    LibTest.testCallbackVrS8 { 0xff }.should == -1
+    expect(LibTest.testCallbackVrS8 { 0xff }).to eq(-1)
   end
+
   it "returning :uchar (0)" do
-    LibTest.testCallbackVrU8 { 0 }.should == 0
+    expect(LibTest.testCallbackVrU8 { 0 }).to eq(0)
   end
+
   it "returning :uchar (0xff)" do
-    LibTest.testCallbackVrU8 { 0xff }.should == 0xff
+    expect(LibTest.testCallbackVrU8 { 0xff }).to eq(0xff)
   end
+
   it "returning :uchar (-1)" do
-    LibTest.testCallbackVrU8 { -1 }.should == 0xff
+    expect(LibTest.testCallbackVrU8 { -1 }).to eq(0xff)
   end
+
   it "returning :uchar (128)" do
-    LibTest.testCallbackVrU8 { 128 }.should == 128
+    expect(LibTest.testCallbackVrU8 { 128 }).to eq(128)
   end
+
   it "returning :uchar (-128)" do
-    LibTest.testCallbackVrU8 { -128 }.should == 128
+    expect(LibTest.testCallbackVrU8 { -128 }).to eq(128)
   end
+
   it "returning :short (0)" do
-    LibTest.testCallbackVrS16 { 0 }.should == 0
+    expect(LibTest.testCallbackVrS16 { 0 }).to eq(0)
   end
+
   it "returning :short (0x7fff)" do
-    LibTest.testCallbackVrS16 { 0x7fff }.should == 0x7fff
+    expect(LibTest.testCallbackVrS16 { 0x7fff }).to eq(0x7fff)
   end
   # test wrap around
   it "returning :short (0x8000)" do
-    LibTest.testCallbackVrS16 { 0x8000 }.should == -0x8000
+    expect(LibTest.testCallbackVrS16 { 0x8000 }).to eq(-0x8000)
   end
+
   it "returning :short (0xffff)" do
-    LibTest.testCallbackVrS16 { 0xffff }.should == -1
+    expect(LibTest.testCallbackVrS16 { 0xffff }).to eq(-1)
   end
+
   it "returning :ushort (0)" do
-    LibTest.testCallbackVrU16 { 0 }.should == 0
+    expect(LibTest.testCallbackVrU16 { 0 }).to eq(0)
   end
+
   it "returning :ushort (0x7fff)" do
-    LibTest.testCallbackVrU16 { 0x7fff }.should == 0x7fff
+    expect(LibTest.testCallbackVrU16 { 0x7fff }).to eq(0x7fff)
   end
+
   it "returning :ushort (0x8000)" do
-    LibTest.testCallbackVrU16 { 0x8000 }.should == 0x8000
+    expect(LibTest.testCallbackVrU16 { 0x8000 }).to eq(0x8000)
   end
+
   it "returning :ushort (0xffff)" do
-    LibTest.testCallbackVrU16 { 0xffff }.should == 0xffff
+    expect(LibTest.testCallbackVrU16 { 0xffff }).to eq(0xffff)
   end
+
   it "returning :ushort (-1)" do
-    LibTest.testCallbackVrU16 { -1 }.should == 0xffff
+    expect(LibTest.testCallbackVrU16 { -1 }).to eq(0xffff)
   end
+
   it "returning :int (0)" do
-    LibTest.testCallbackVrS32 { 0 }.should == 0
+    expect(LibTest.testCallbackVrS32 { 0 }).to eq(0)
   end
+
   it "returning :int (0x7fffffff)" do
-    LibTest.testCallbackVrS32 { 0x7fffffff }.should == 0x7fffffff
+    expect(LibTest.testCallbackVrS32 { 0x7fffffff }).to eq(0x7fffffff)
   end
   # test wrap around
   it "returning :int (-0x80000000)" do
-    LibTest.testCallbackVrS32 { -0x80000000 }.should == -0x80000000
+    expect(LibTest.testCallbackVrS32 { -0x80000000 }).to eq(-0x80000000)
   end
+
   it "returning :int (-1)" do
-    LibTest.testCallbackVrS32 { -1 }.should == -1
+    expect(LibTest.testCallbackVrS32 { -1 }).to eq(-1)
   end
+
   it "returning :uint (0)" do
-    LibTest.testCallbackVrU32 { 0 }.should == 0
+    expect(LibTest.testCallbackVrU32 { 0 }).to eq(0)
   end
+
   it "returning :uint (0x7fffffff)" do
-    LibTest.testCallbackVrU32 { 0x7fffffff }.should == 0x7fffffff
+    expect(LibTest.testCallbackVrU32 { 0x7fffffff }).to eq(0x7fffffff)
   end
   # test wrap around
   it "returning :uint (0x80000000)" do
-    LibTest.testCallbackVrU32 { 0x80000000 }.should == 0x80000000
+    expect(LibTest.testCallbackVrU32 { 0x80000000 }).to eq(0x80000000)
   end
+
   it "returning :uint (0xffffffff)" do
-    LibTest.testCallbackVrU32 { 0xffffffff }.should == 0xffffffff
+    expect(LibTest.testCallbackVrU32 { 0xffffffff }).to eq(0xffffffff)
   end
+
   it "returning :uint (-1)" do
-    LibTest.testCallbackVrU32 { -1 }.should == 0xffffffff
+    expect(LibTest.testCallbackVrU32 { -1 }).to eq(0xffffffff)
   end
+
   it "returning :long (0)" do
-    LibTest.testCallbackVrL { 0 }.should == 0
+    expect(LibTest.testCallbackVrL { 0 }).to eq(0)
   end
+
   it "returning :long (0x7fffffff)" do
-    LibTest.testCallbackVrL { 0x7fffffff }.should == 0x7fffffff
+    expect(LibTest.testCallbackVrL { 0x7fffffff }).to eq(0x7fffffff)
   end
   # test wrap around
   it "returning :long (-0x80000000)" do
-    LibTest.testCallbackVrL { -0x80000000 }.should == -0x80000000
+    expect(LibTest.testCallbackVrL { -0x80000000 }).to eq(-0x80000000)
   end
+
   it "returning :long (-1)" do
-    LibTest.testCallbackVrL { -1 }.should == -1
+    expect(LibTest.testCallbackVrL { -1 }).to eq(-1)
   end
+
   it "returning :ulong (0)" do
-    LibTest.testCallbackVrUL { 0 }.should == 0
+    expect(LibTest.testCallbackVrUL { 0 }).to eq(0)
   end
+
   it "returning :ulong (0x7fffffff)" do
-    LibTest.testCallbackVrUL { 0x7fffffff }.should == 0x7fffffff
+    expect(LibTest.testCallbackVrUL { 0x7fffffff }).to eq(0x7fffffff)
   end
   # test wrap around
   it "returning :ulong (0x80000000)" do
-    LibTest.testCallbackVrUL { 0x80000000 }.should == 0x80000000
+    expect(LibTest.testCallbackVrUL { 0x80000000 }).to eq(0x80000000)
   end
+
   it "returning :ulong (0xffffffff)" do
-    LibTest.testCallbackVrUL { 0xffffffff }.should == 0xffffffff
+    expect(LibTest.testCallbackVrUL { 0xffffffff }).to eq(0xffffffff)
   end
+
   it "Callback returning :ulong (-1)" do
     if FFI::Platform::LONG_SIZE == 32
-      LibTest.testCallbackVrUL { -1 }.should == 0xffffffff
+      expect(LibTest.testCallbackVrUL { -1 }).to eq(0xffffffff)
     else
-      LibTest.testCallbackVrUL { -1 }.should == 0xffffffffffffffff
+      expect(LibTest.testCallbackVrUL { -1 }).to eq(0xffffffffffffffff)
     end
   end
+
   it "returning :long_long (0)" do
-    LibTest.testCallbackVrS64 { 0 }.should == 0
+    expect(LibTest.testCallbackVrS64 { 0 }).to eq(0)
   end
+
   it "returning :long_long (0x7fffffffffffffff)" do
-    LibTest.testCallbackVrS64 { 0x7fffffffffffffff }.should == 0x7fffffffffffffff
+    expect(LibTest.testCallbackVrS64 { 0x7fffffffffffffff }).to eq(0x7fffffffffffffff)
   end
   # test wrap around
   it "returning :long_long (-0x8000000000000000)" do
-    LibTest.testCallbackVrS64 { -0x8000000000000000 }.should == -0x8000000000000000
+    expect(LibTest.testCallbackVrS64 { -0x8000000000000000 }).to eq(-0x8000000000000000)
   end
+
   it "returning :long_long (-1)" do
-    LibTest.testCallbackVrS64 { -1 }.should == -1
+    expect(LibTest.testCallbackVrS64 { -1 }).to eq(-1)
   end
+
   it "returning bool" do
-    LibTest.testCallbackVrZ { true }.should be_true
+    expect(LibTest.testCallbackVrZ { true }).to be true
   end
+
   it "returning :pointer (nil)" do
-    LibTest.testCallbackVrP { nil }.null?.should be_true
+    expect(LibTest.testCallbackVrP { nil }).to be_null
   end
+
   it "returning :pointer (MemoryPointer)" do
     p = FFI::MemoryPointer.new :long
-    LibTest.testCallbackVrP { p }.should == p
+    expect(LibTest.testCallbackVrP { p }).to eq(p)
   end
 
-
   it "returning struct by value" do
     s = LibTest::S8F32S32.new
     s[:s8] = 0x12
     s[:s32] = 0x1eefbeef
     s[:f32] = 1.234567
     ret = LibTest.testCallbackVrT { s }
-    ret[:s8].should == s[:s8]
-    ret[:f32].should == s[:f32]
-    ret[:s32].should == s[:s32]
+    expect(ret[:s8]).to eq(s[:s8])
+    expect(ret[:f32]).to eq(s[:f32])
+    expect(ret[:s32]).to eq(s[:s32])
 
   end
 
@@ -249,11 +284,13 @@ describe "Callback" do
     s[:s32] = 0x1eefbeef
     s[:f32] = 1.234567
     s2 = LibTest::S8F32S32.new
+
     LibTest.testCallbackTrV(s) do |struct|
       s2[:s8] = struct[:s8]
       s2[:f32] = struct[:f32]
       s2[:s32] = struct[:s32]
     end
+
     expect(s2[:s8]).to eql 0x12
     expect(s2[:s32]).to eql 0x1eefbeef
     expect(s2[:f32]).to be_within(0.0000001).of 1.234567
@@ -263,12 +300,12 @@ describe "Callback" do
   it "global variable" do
     proc = Proc.new { 0x1e }
     LibTest.cbVrS8 = proc
-    LibTest.testGVarCallbackVrS8(LibTest.pVrS8).should == 0x1e
+    expect(LibTest.testGVarCallbackVrS8(LibTest.pVrS8)).to eq(0x1e)
   end
 
   describe "When the callback is considered optional by the underlying library" do
     it "should handle receiving 'nil' in place of the closure" do
-      LibTest.testOptionalCallbackCrV(nil, 13).should be_nil
+      expect(LibTest.testOptionalCallbackCrV(nil, 13)).to be_nil
     end
   end
 
@@ -279,20 +316,20 @@ describe "Callback" do
         ffi_lib TestLibrary::PATH
         attach_function :testAnonymousCallbackVrS8, :testClosureVrB, [ callback([ ], :char) ], :char
       end
-      LibTest.testAnonymousCallbackVrS8 { 0 }.should == 0
+      expect(LibTest.testAnonymousCallbackVrS8 { 0 }).to eq(0)
     end
   end
 
   describe "as return value" do
 
     it "should not blow up when a callback is defined that returns a callback" do
-      module LibTest
+      expect(module LibTest
         extend FFI::Library
         ffi_lib TestLibrary::PATH
         callback :cb_return_type_1, [ :short ], :short
         callback :cb_lookup_1, [ :short ], :cb_return_type_1
         attach_function :testReturnsCallback_1, :testReturnsClosure, [ :cb_lookup_1, :short ], :cb_return_type_1
-      end.should be_an_instance_of FFI::Function
+      end).to be_an_instance_of FFI::Function
     end
 
     it "should return a callback" do
@@ -317,9 +354,9 @@ describe "Callback" do
       end
 
       val = LibTest.testReturnsCallback(lookup_proc, 0x1234)
-      val.should == 0x1234 * 2
-      lookup_proc_called.should be_true
-      return_proc_called.should be_true
+      expect(val).to eq(0x1234 * 2)
+      expect(lookup_proc_called).to be true
+      expect(return_proc_called).to be true
     end
 
     it "should return a method callback" do
@@ -339,17 +376,17 @@ describe "Callback" do
         end
       end
 
-      LibTest.testReturnsCallback_2(MethodCallback.method(:lookup), 0x1234).should == 0x2468
+      expect(LibTest.testReturnsCallback_2(MethodCallback.method(:lookup), 0x1234)).to eq(0x2468)
     end
 
     it 'should not blow up when a callback takes a callback as argument' do
-      module LibTest
+      expect(module LibTest
         extend FFI::Library
         ffi_lib TestLibrary::PATH
         callback :cb_argument, [ :int ], :int
         callback :cb_with_cb_argument, [ :cb_argument, :int ], :int
         attach_function :testCallbackAsArgument_2, :testArgumentClosure, [ :cb_with_cb_argument, :int ], :int
-      end.should be_an_instance_of FFI::Function
+      end).to be_an_instance_of FFI::Function
     end
     it 'should be able to use the callback argument' do
       module LibTest
@@ -360,7 +397,7 @@ describe "Callback" do
         attach_function :testCallbackAsArgument, :testArgumentClosure, [ :cb_with_cb_argument, :cb_argument, :int ], :int
       end   
       callback_arg_called = false
-      callback_with_callback_arg_called = false         
+      callback_with_callback_arg_called = false
       callback_arg = Proc.new do |val|
         callback_arg_called = true
         val * 2
@@ -370,9 +407,9 @@ describe "Callback" do
         cb.call(val)
       end
       val = LibTest.testCallbackAsArgument(callback_with_callback_arg, callback_arg, 0xff1)
-      val.should == 0xff1 * 2
-      callback_arg_called.should be_true
-      callback_with_callback_arg_called.should be_true         
+      expect(val).to eq(0xff1 * 2)
+      expect(callback_arg_called).to be true
+      expect(callback_with_callback_arg_called).to be true
     end
     it 'function returns callable object' do
       module LibTest
@@ -382,7 +419,7 @@ describe "Callback" do
         attach_function :testReturnsFunctionPointer, [  ], :funcptr
       end
       f = LibTest.testReturnsFunctionPointer
-      f.call(3).should == 6
+      expect(f.call(3)).to eq(6)
     end
   end
 
@@ -433,239 +470,281 @@ describe "Callback with " do
     attach_function :testCallbackPrV, :testClosurePrV, [ :cbPrV, :pointer], :void
     attach_function :testCallbackYrV, :testClosurePrV, [ :cbYrV, S8F32S32.in ], :void
   end
+
   it "function with Callback plus another arg should raise error if no arg given" do
-    lambda { LibTest.testCallbackCrV { |*a| }}.should raise_error
+    expect { LibTest.testCallbackCrV { |*a| }}.to raise_error
   end
+
   it ":char (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackCrV(0) { |i| v = i }
-    v.should == 0
+    expect(v).to eq(0)
   end
+
   it ":char (127) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackCrV(127) { |i| v = i }
-    v.should == 127
+    expect(v).to eq(127)
   end
+
   it ":char (-128) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackCrV(-128) { |i| v = i }
-    v.should == -128
+    expect(v).to eq(-128)
   end
+
   it ":char (-1) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackCrV(-1) { |i| v = i }
-    v.should == -1
+    expect(v).to eq(-1)
   end
+
   it ":uchar (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU8rV(0) { |i| v = i }
-    v.should == 0
+    expect(v).to eq(0)
   end
+
   it ":uchar (127) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU8rV(127) { |i| v = i }
-    v.should == 127
+    expect(v).to eq(127)
   end
+
   it ":uchar (128) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU8rV(128) { |i| v = i }
-    v.should == 128
+    expect(v).to eq(128)
   end
+
   it ":uchar (255) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU8rV(255) { |i| v = i }
-    v.should == 255
+    expect(v).to eq(255)
   end
 
   it ":short (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackSrV(0) { |i| v = i }
-    v.should == 0
+    expect(v).to eq(0)
   end
+
   it ":short (0x7fff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackSrV(0x7fff) { |i| v = i }
-    v.should == 0x7fff
+    expect(v).to eq(0x7fff)
   end
+
   it ":short (-0x8000) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackSrV(-0x8000) { |i| v = i }
-    v.should == -0x8000
+    expect(v).to eq(-0x8000)
   end
+
   it ":short (-1) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackSrV(-1) { |i| v = i }
-    v.should == -1
+    expect(v).to eq(-1)
   end
+
   it ":ushort (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU16rV(0) { |i| v = i }
-    v.should == 0
+    expect(v).to eq(0)
   end
+
   it ":ushort (0x7fff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU16rV(0x7fff) { |i| v = i }
-    v.should == 0x7fff
+    expect(v).to eq(0x7fff)
   end
+
   it ":ushort (0x8000) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU16rV(0x8000) { |i| v = i }
-    v.should == 0x8000
+    expect(v).to eq(0x8000)
   end
+
   it ":ushort (0xffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU16rV(0xffff) { |i| v = i }
-    v.should == 0xffff
+    expect(v).to eq(0xffff)
   end
+
   it ":bool (true) argument" do
     v = false
     LibTest.testCallbackZrV(true) { |i| v = i }
-    v.should be_true
+    expect(v).to be true
   end
+
   it ":int (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackIrV(0) { |i| v = i }
-    v.should == 0
+    expect(v).to eq(0)
   end
+
   it ":int (0x7fffffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackIrV(0x7fffffff) { |i| v = i }
-    v.should == 0x7fffffff
+    expect(v).to eq(0x7fffffff)
   end
+
   it ":int (-0x80000000) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackIrV(-0x80000000) { |i| v = i }
-    v.should == -0x80000000
+    expect(v).to eq(-0x80000000)
   end
+
   it ":int (-1) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackIrV(-1) { |i| v = i }
-    v.should == -1
+    expect(v).to eq(-1)
   end
+
   it ":uint (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU32rV(0) { |i| v = i }
-    v.should == 0
+    expect(v).to eq(0)
   end
+
   it ":uint (0x7fffffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU32rV(0x7fffffff) { |i| v = i }
-    v.should == 0x7fffffff
+    expect(v).to eq(0x7fffffff)
   end
+
   it ":uint (0x80000000) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU32rV(0x80000000) { |i| v = i }
-    v.should == 0x80000000
+    expect(v).to eq(0x80000000)
   end
+
   it ":uint (0xffffffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackU32rV(0xffffffff) { |i| v = i }
-    v.should == 0xffffffff
+    expect(v).to eq(0xffffffff)
   end
+
   it ":long (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLrV(0) { |i| v = i }
-    v.should == 0
+    expect(v).to eq(0)
   end
+
   it ":long (0x7fffffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLrV(0x7fffffff) { |i| v = i }
-    v.should == 0x7fffffff
+    expect(v).to eq(0x7fffffff)
   end
+
   it ":long (-0x80000000) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLrV(-0x80000000) { |i| v = i }
-    v.should == -0x80000000
+    expect(v).to eq(-0x80000000)
   end
+
   it ":long (-1) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLrV(-1) { |i| v = i }
-    v.should == -1
+    expect(v).to eq(-1)
   end
+
   it ":ulong (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackULrV(0) { |i| v = i }
-    v.should == 0
+    expect(v).to eq(0)
   end
+
   it ":ulong (0x7fffffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackULrV(0x7fffffff) { |i| v = i }
-    v.should == 0x7fffffff
+    expect(v).to eq(0x7fffffff)
   end
+
   it ":ulong (0x80000000) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackULrV(0x80000000) { |i| v = i }
-    v.should == 0x80000000
+    expect(v).to eq(0x80000000)
   end
+
   it ":ulong (0xffffffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackULrV(0xffffffff) { |i| v = i }
-    v.should == 0xffffffff
+    expect(v).to eq(0xffffffff)
   end
+
   it ":long_long (0) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLLrV(0) { |i| v = i }
-    v.should == 0
+    expect(v).to eq(0)
   end
+
   it ":long_long (0x7fffffffffffffff) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLLrV(0x7fffffffffffffff) { |i| v = i }
-    v.should == 0x7fffffffffffffff
+    expect(v).to eq(0x7fffffffffffffff)
   end
+
   it ":long_long (-0x8000000000000000) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLLrV(-0x8000000000000000) { |i| v = i }
-    v.should == -0x8000000000000000
+    expect(v).to eq(-0x8000000000000000)
   end
+
   it ":long_long (-1) argument" do
     v = 0xdeadbeef
     LibTest.testCallbackLLrV(-1) { |i| v = i }
-    v.should == -1
+    expect(v).to eq(-1)
   end
+
   it ":string argument" do
     v = nil
     LibTest.testCallbackArV("Hello, World") { |i| v = i }
-    v.should == "Hello, World"
+    expect(v).to eq("Hello, World")
   end
+
   it ":string (nil) argument" do
     v = "Hello, World"
     LibTest.testCallbackArV(nil) { |i| v = i }
-    v.should be_nil
+    expect(v).to be_nil
   end
+
   it ":pointer argument" do
     v = nil
     magic = FFI::Pointer.new(0xdeadbeef)
     LibTest.testCallbackPrV(magic) { |i| v = i }
-    v.should == magic
+    expect(v).to eq(magic)
   end
+
   it ":pointer (nil) argument" do
     v = "Hello, World"
     LibTest.testCallbackPrV(nil) { |i| v = i }
-    v.should == FFI::Pointer::NULL
+    expect(v).to eq(FFI::Pointer::NULL)
   end
+
   it "struct by reference argument" do
     v = nil
     magic = LibTest::S8F32S32.new
     LibTest.testCallbackYrV(magic) { |i| v = i }
-    v.class.should == magic.class
-    v.pointer.should == magic.pointer
+    expect(v.class).to eq(magic.class)
+    expect(v.pointer).to eq(magic.pointer)
   end
 
   it "struct by reference argument with nil value" do
     v = LibTest::S8F32S32.new
     LibTest.testCallbackYrV(nil) { |i| v = i }
-    v.is_a?(FFI::Struct).should be_true
-    v.pointer.should == FFI::Pointer::NULL
+    expect(v.is_a?(FFI::Struct)).to be true
+    expect(v.pointer).to eq(FFI::Pointer::NULL)
   end
 
   it "varargs parameters are rejected" do
-    lambda {
+    expect {
       Module.new do
         extend FFI::Library
         ffi_lib TestLibrary::PATH
         callback :cbVrL, [ :varargs ], :long
       end
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
   #
@@ -687,8 +766,8 @@ describe "Callback with " do
       po = FFI::MemoryPointer.new :long
       pr = proc{|a,i| v = a,i; i }
       res = LibTestStdcall.testCallbackStdcall(po, pr, 0x7fffffff)
-      v.should == [po, 0x7fffffff]
-      res.should be_true
+      expect(v).to eq([po, 0x7fffffff])
+      expect(res).to be true
     end
   end
 end