ffi 1.9.5 → 1.9.6

data/spec/ffi/memorypointer_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 MemoryPointer = FFI::MemoryPointer
 
@@ -12,15 +11,19 @@ describe "MemoryPointer#total" do
   it "MemoryPointer.new(:char, 1).total == 1" do
     expect(MemoryPointer.new(:char, 1).total).to eq 1
   end
+
   it "MemoryPointer.new(:short, 1).total == 2" do
     expect(MemoryPointer.new(:short, 1).total).to eq 2
   end
+
   it "MemoryPointer.new(:int, 1).total == 4" do
     expect(MemoryPointer.new(:int, 1).total).to eq 4
   end
+
   it "MemoryPointer.new(:long_long, 1).total == 8" do
     expect(MemoryPointer.new(:long_long, 1).total).to eq 8
   end
+
   it "MemoryPointer.new(1024).total == 1024" do
     expect(MemoryPointer.new(1024).total).to eq 1024
   end
@@ -42,11 +45,13 @@ describe "MemoryPointer argument" do
     attach_function :memset, [ :pointer, :int, :ulong ], :pointer
     attach_function :memcpy, [ :pointer, :pointer, :ulong ], :pointer
   end
+
   it "Pointer passed correctly" do
     p = MemoryPointer.new :int, 1
     ret = Ptr.memset(p, 0, p.total)
     expect(ret).to eq p
   end
+
   it "Data passed to native function" do
     p = MemoryPointer.new :int, 1
     p2 = MemoryPointer.new :int, 1
@@ -64,6 +69,7 @@ describe "MemoryPointer return value" do
     attach_function :fclose, [ :pointer ], :int
     attach_function :fwrite, [ :pointer, :ulong, :ulong, :string ], :ulong
   end
+
   it "fopen returns non-nil" do
     fp = Stdio.fopen("/dev/null", "w")
     expect(fp).to_not be_nil

data/spec/ffi/number_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe "Function with primitive integer arguments" do
   module LibTest
@@ -27,108 +26,118 @@ describe "Function with primitive integer arguments" do
     attach_function :set_double, [ :double ], :void
     attach_function :get_double, [ ], :double
   end
+
   it "int8.size" do
-    FFI::TYPE_INT8.size.should == 1
+    expect(FFI::TYPE_INT8.size).to eq(1)
   end
+
   it "uint8.size" do
-    FFI::TYPE_UINT8.size.should == 1
+    expect(FFI::TYPE_UINT8.size).to eq(1)
   end
+
   it "int16.size" do
-    FFI::TYPE_INT16.size.should == 2
+    expect(FFI::TYPE_INT16.size).to eq(2)
   end
+
   it "uint16.size" do
-    FFI::TYPE_UINT16.size.should == 2
+    expect(FFI::TYPE_UINT16.size).to eq(2)
   end
+
   it "int32.size" do
-    FFI::TYPE_INT32.size.should == 4
+    expect(FFI::TYPE_INT32.size).to eq(4)
   end
+
   it "uint32.size" do
-    FFI::TYPE_UINT32.size.should == 4
+    expect(FFI::TYPE_UINT32.size).to eq(4)
   end
+
   it "int64.size" do
-    FFI::TYPE_INT64.size.should == 8
+    expect(FFI::TYPE_INT64.size).to eq(8)
   end
+
   it "uint64.size" do
-    FFI::TYPE_UINT64.size.should == 8
+    expect(FFI::TYPE_UINT64.size).to eq(8)
   end
+
   it "float.size" do
-    FFI::TYPE_FLOAT32.size.should == 4
+    expect(FFI::TYPE_FLOAT32.size).to eq(4)
   end
+
   it "double.size" do
-    FFI::TYPE_FLOAT64.size.should == 8
+    expect(FFI::TYPE_FLOAT64.size).to eq(8)
   end
   [ 0, 127, -128, -1 ].each do |i|
     it ":char call(:char (#{i}))" do
-      LibTest.ret_s8(i).should == i
+      expect(LibTest.ret_s8(i)).to eq(i)
     end
   end
   [ 0, 0x7f, 0x80, 0xff ].each do |i|
     it ":uchar call(:uchar (#{i}))" do
-      LibTest.ret_u8(i).should == i
+      expect(LibTest.ret_u8(i)).to eq(i)
     end
   end
   [ 0, 0x7fff, -0x8000, -1 ].each do |i|
     it ":short call(:short (#{i}))" do
-      LibTest.ret_s16(i).should == i
+      expect(LibTest.ret_s16(i)).to eq(i)
     end
   end
   [ 0, 0x7fff, 0x8000, 0xffff ].each do |i|
     it ":ushort call(:ushort (#{i}))" do
-      LibTest.ret_u16(i).should == i
+      expect(LibTest.ret_u16(i)).to eq(i)
     end
   end
   [ 0, 0x7fffffff, -0x80000000, -1 ].each do |i|
     it ":int call(:int (#{i}))" do
-      LibTest.ret_s32(i).should == i
+      expect(LibTest.ret_s32(i)).to eq(i)
     end
   end
   [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
     it ":uint call(:uint (#{i}))" do
-      LibTest.ret_u32(i).should == i
+      expect(LibTest.ret_u32(i)).to 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
+      expect(LibTest.ret_s64(i)).to 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
+      expect(LibTest.ret_u64(i)).to 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
+        expect(LibTest.ret_long(i)).to eq(i)
       end
     end
     [ 0, 0x7fffffff, 0x80000000, 0xffffffff ].each do |i|
       it ":ulong call(:ulong (#{i}))" do
-        LibTest.ret_ulong(i).should == i
+        expect(LibTest.ret_ulong(i)).to eq(i)
       end
     end
   else
     [ 0, 0x7fffffffffffffff, -0x8000000000000000, -1 ].each do |i|
       it ":long call(:long (#{i}))" do
-        LibTest.ret_long(i).should == i
+        expect(LibTest.ret_long(i)).to eq(i)
       end
     end
     [ 0, 0x7fffffffffffffff, 0x8000000000000000, 0xffffffffffffffff ].each do |i|
       it ":ulong call(:ulong (#{i}))" do
-        LibTest.ret_ulong(i).should == i
+        expect(LibTest.ret_ulong(i)).to eq(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
+        expect((LibTest.get_float - f).abs).to be < 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
+        expect((LibTest.get_double - f).abs).to be < 0.001
       end
     end
   end
@@ -136,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
+      expect { expect(LibTest.ret_int8_t(i)).to eq(i) }.to 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
+      expect { expect(LibTest.ret_u_int8_t(i)).to eq(i) }.to 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
+      expect { expect(LibTest.ret_int16_t(i)).to eq(i) }.to 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
+      expect { expect(LibTest.ret_u_int16_t(i)).to eq(i) }.to 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
+      expect { expect(LibTest.ret_int32_t(i)).to eq(i) }.to 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
+      expect { expect(LibTest.ret_u_int32_t(i)).to eq(i) }.to raise_error
     end
   end
 end
@@ -208,11 +217,11 @@ describe "Three different size Integer arguments" do
 
   def verify(p, off, t, v)
     if t == 'f32'
-      p.get_float32(off).should == v
+      expect(p.get_float32(off)).to eq(v)
     elsif t == 'f64'
-      p.get_float64(off).should == v
+      expect(p.get_float64(off)).to eq(v)
     else
-      p.get_int64(off).should == v
+      expect(p.get_int64(off)).to eq(v)
     end
   end
 

data/spec/ffi/platform_spec.rb

@@ -4,94 +4,111 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 
 describe "FFI::Platform::LIBSUFFIX" do
-  it "returns 'so'", if: RbConfig::CONFIG['host_os'].match('linux') do
-    FFI::Platform::LIBSUFFIX.should == 'so'
-  end
-
-  it "returns 'dll'", if: RbConfig::CONFIG['host_os'].match('windows') do
-    FFI::Platform::LIBSUFFIX.should == 'dll'
-  end
-
-  it "returns 'dylib'", if: RbConfig::CONFIG['host_os'].match('darwin') do
-    FFI::Platform::LIBSUFFIX.should == 'dylib'
+  case OS
+  when "linux"
+    it "returns 'so'" do
+      expect(FFI::Platform::LIBSUFFIX).to eq('so')
+    end
+  when "windows"
+    it "returns 'dll'" do
+      expect(FFI::Platform::LIBSUFFIX).to eq('dll')
+    end
+  when "darwin"
+    it "returns 'dylib'" do
+      expect(FFI::Platform::LIBSUFFIX).to eq('dylib')
+    end
   end
 end
 
 describe "FFI::Platform::IS_WINDOWS" do
-  it "returns false", if: RbConfig::CONFIG['host_os'].match('linux') do
-    FFI::Platform::IS_WINDOWS.should == false
-  end
-
-  it "returns true", if: RbConfig::CONFIG['host_os'].match('windows') do
-    FFI::Platform::IS_WINDOWS.should == true
-  end
-
-  it "returns false", if: RbConfig::CONFIG['host_os'].match('darwin') do
-    FFI::Platform::IS_WINDOWS.should == false
+  case OS
+  when "linux"
+    it "returns false" do
+      expect(FFI::Platform::IS_WINDOWS).to be false
+    end
+  when "windows"
+    it "returns true" do
+      expect(FFI::Platform::IS_WINDOWS).to be true
+    end
+  when "darwin"
+    it "returns false" do
+      expect(FFI::Platform::IS_WINDOWS).to be false
+    end
   end
 end
 
 describe "FFI::Platform::ARCH" do
   it "returns the architecture type" do
-    FFI::Platform::ARCH.should == RbConfig::CONFIG["target_cpu"]
+    expect(FFI::Platform::ARCH).to eq(CPU)
   end
 end
 
 describe "FFI::Platform::OS" do
-  it "returns 'linux' as a string", if: RbConfig::CONFIG['host_os'].match('linux') do
-    FFI::Platform::OS.should == 'linux'
-  end
-
-  it "returns 'windows' as a string", if: RbConfig::CONFIG['host_os'].match('windows') do
-    FFI::Platform::OS.should == 'windows'
-  end
-
-  it "returns 'darwin' as a string", if: RbConfig::CONFIG['host_os'].match('darwin') do
-    FFI::Platform::OS.should == 'darwin'
+  case OS
+  when "linux"
+    it "returns 'linux' as a string" do
+      expect(FFI::Platform::OS).to eq('linux')
+    end
+  when "windows"
+    it "returns 'windows' as a string" do
+      expect(FFI::Platform::OS).to eq('windows')
+    end
+  when "darwin"
+    it "returns 'darwin' as a string" do
+      expect(FFI::Platform::OS).to eq('darwin')
+    end
   end
+end
 
-  describe "FFI::Platform.windows?" do
-    it "returns false", if: RbConfig::CONFIG['host_os'].match('linux') do
-      FFI::Platform.windows?.should == false
+describe "FFI::Platform.windows?" do
+  case OS
+  when "linux"
+    it "returns false" do
+      expect(FFI::Platform.windows?).to be false
     end
-
-    it "returns true", if: RbConfig::CONFIG['host_os'].match('windows') do
-      FFI::Platform.windows?.should == true
+  when "windows"
+    it "returns true" do
+      expect(FFI::Platform.windows?).to be true
     end
-
-    it "returns false", if: RbConfig::CONFIG['host_os'].match('darwin') do
-      FFI::Platform.windows?.should == false
+  when "darwin"
+    it "returns false" do
+      expect(FFI::Platform.windows?).to be false
     end
   end
+end
 
-  describe "FFI::Platform.mac?" do
-    it "returns false", if: RbConfig::CONFIG['host_os'].match('linux') do
-      FFI::Platform.mac?.should == false
+describe "FFI::Platform.mac?" do
+  case OS
+  when "linux"
+    it "returns false" do
+      expect(FFI::Platform.mac?).to be false
     end
-
-    it "returns false", if: RbConfig::CONFIG['host_os'].match('windows') do
-      FFI::Platform.mac?.should == false
+  when "windows"
+    it "returns false" do
+      expect(FFI::Platform.mac?).to be false
     end
-
-    it "returns true", if: RbConfig::CONFIG['host_os'].match('darwin') do
-      FFI::Platform.mac?.should == true
+  when "darwin"
+    it "returns true" do
+      expect(FFI::Platform.mac?).to be true
     end
   end
+end
 
-  describe "FFI::Platform.unix?" do
-    it "returns true", if: RbConfig::CONFIG['host_os'].match('linux') do
-      FFI::Platform.unix?.should == true
+describe "FFI::Platform.unix?" do
+  case OS
+  when "linux"
+    it "returns true" do
+      expect(FFI::Platform.unix?).to be true
     end
-
-    it "returns false", if: RbConfig::CONFIG['host_os'].match('windows') do
-      FFI::Platform.unix?.should == false
+  when "windows"
+    it "returns false" do
+      expect(FFI::Platform.unix?).to be false
     end
-
-    it "returns true", if: RbConfig::CONFIG['host_os'].match('darwin') do
-      FFI::Platform.unix?.should == true
+  when "darwin"
+    it "returns true" do
+      expect(FFI::Platform.unix?).to be true
     end
   end
 end

data/spec/ffi/pointer_spec.rb

@@ -4,7 +4,6 @@
 #
 
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-require 'ffi'
 require 'delegate'
 
 module PointerTestLib
@@ -30,12 +29,13 @@ describe "Pointer" do
       @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)
-    PointerTestLib.ptr_ret_int32_t(tp, 0).should == magic
+    expect(PointerTestLib.ptr_ret_int32_t(tp, 0)).to eq(magic)
   end
   class PointerDelegate < DelegateClass(FFI::Pointer)
     def initialize(ptr)
@@ -45,18 +45,21 @@ describe "Pointer" do
       @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)
-    PointerTestLib.ptr_ret_int32_t(ptr, 0).should == magic
+    expect(PointerTestLib.ptr_ret_int32_t(ptr, 0)).to eq(magic)
   end
+
   it "Fixnum cannot be used as a Pointer argument" do
-    lambda { PointerTestLib.ptr_ret_int32(0, 0) }.should raise_error
+    expect { PointerTestLib.ptr_ret_int32(0, 0) }.to raise_error
   end
+
   it "Bignum cannot be used as a Pointer argument" do
-    lambda { PointerTestLib.ptr_ret_int32(0xfee1deadbeefcafebabe, 0) }.should raise_error
+    expect { PointerTestLib.ptr_ret_int32(0xfee1deadbeefcafebabe, 0) }.to raise_error
   end
 
   describe "pointer type methods" do
@@ -64,13 +67,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
+      expect(memory.read_pointer.address).to 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
+      expect(PointerTestLib.ptr_ret_pointer(memory, 0).address).to eq(0xdeadbeef)
     end
 
     it "#read_array_of_pointer" do
@@ -81,7 +84,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
+        expect(array[j].address).to eq(address)
       end
     end
     
@@ -90,23 +93,23 @@ describe "Pointer" do
   describe 'NULL' do
     it 'should be obtained using Pointer::NULL constant' do
       null_ptr = FFI::Pointer::NULL
-      null_ptr.null?.should be_true
+      expect(null_ptr).to be_null
     end
     it 'should be obtained passing address 0 to constructor' do
-      FFI::Pointer.new(0).null?.should be_true
+      expect(FFI::Pointer.new(0)).to be_null
     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)
+      expect { null_ptr.read_int }.to raise_error(FFI::NullPointerError)
+      expect { null_ptr.write_int(0xff1) }.to raise_error(FFI::NullPointerError)
     end
     it 'returns true when compared with nil' do
-      (FFI::Pointer::NULL == nil).should be_true
+      expect((FFI::Pointer::NULL == nil)).to be true
     end
   end
 
   it "Pointer.size returns sizeof pointer on platform" do
-    FFI::Pointer.size.should == (FFI::Platform::ADDRESS_SIZE / 8)
+    expect(FFI::Pointer.size).to eq((FFI::Platform::ADDRESS_SIZE / 8))
   end
 
   describe "#slice" do
@@ -117,22 +120,22 @@ describe "Pointer" do
     end
 
     it "contents of sliced pointer matches original pointer at offset" do
-      @mptr.slice(4, 4).get_uint(0).should == 0xdeadbeef
+      expect(@mptr.slice(4, 4).get_uint(0)).to eq(0xdeadbeef)
     end
 
     it "modifying sliced pointer is reflected in original pointer" do
       @mptr.slice(4, 4).put_uint(0, 0xfee1dead)
-      @mptr.get_uint(4).should == 0xfee1dead
+      expect(@mptr.get_uint(4)).to eq(0xfee1dead)
     end
 
     it "access beyond bounds should raise IndexError" do
-      lambda { @mptr.slice(4, 4).get_int(4) }.should raise_error(IndexError)
+      expect { @mptr.slice(4, 4).get_int(4) }.to raise_error(IndexError)
     end
   end
 
   describe "#type_size" do
     it "should be same as FFI.type_size(type)" do
-      FFI::MemoryPointer.new(:int, 1).type_size.should == FFI.type_size(:int)
+      expect(FFI::MemoryPointer.new(:int, 1).type_size).to eq(FFI.type_size(:int))
     end
   end
 end
@@ -166,8 +169,9 @@ describe "AutoPointer" do
   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
+    expect(AutoPointerSubclass).to receive(:release).at_least(loop_count-wiggle_room).times
     AutoPointerTestHelper.reset
     loop_count.times do
       # note that if we called
@@ -187,7 +191,7 @@ describe "AutoPointer" do
     #
     #  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
+    expect(AutoPointerTestHelper).to receive(:release).at_least(loop_count-wiggle_room).times
     AutoPointerTestHelper.reset
     loop_count.times do
       FFI::AutoPointer.new(PointerTestLib.ptr_from_address(magic),
@@ -197,7 +201,7 @@ describe "AutoPointer" do
   end
 
   it "cleanup when passed a method" do
-    AutoPointerTestHelper.should_receive(:release).at_least(loop_count-wiggle_room).times
+    expect(AutoPointerTestHelper).to receive(:release).at_least(loop_count-wiggle_room).times
     AutoPointerTestHelper.reset
     loop_count.times do
       FFI::AutoPointer.new(PointerTestLib.ptr_from_address(magic),
@@ -207,7 +211,7 @@ describe "AutoPointer" do
   end
 
   it "can be used as the return type of a function" do
-    lambda do
+    expect do
       Module.new do
         extend FFI::Library
         ffi_lib TestLibrary::PATH
@@ -216,18 +220,18 @@ describe "AutoPointer" do
         end
         attach_function :ptr_from_address, [ FFI::Platform::ADDRESS_SIZE == 32 ? :uint : :ulong_long ], CustomAutoPointer
       end
-    end.should_not raise_error
+    end.not_to raise_error
   end
 
   describe "#new" do
     it "MemoryPointer argument raises TypeError" do
-      lambda { FFI::AutoPointer.new(FFI::MemoryPointer.new(:int))}.should raise_error(::TypeError)
+      expect { FFI::AutoPointer.new(FFI::MemoryPointer.new(:int))}.to raise_error(::TypeError)
     end
     it "AutoPointer argument raises TypeError" do
-      lambda { AutoPointerSubclass.new(AutoPointerSubclass.new(PointerTestLib.ptr_from_address(0))) }.should raise_error(::TypeError)
+      expect { AutoPointerSubclass.new(AutoPointerSubclass.new(PointerTestLib.ptr_from_address(0))) }.to raise_error(::TypeError)
     end
     it "Buffer argument raises TypeError" do
-      lambda { FFI::AutoPointer.new(FFI::Buffer.new(:int))}.should raise_error(::TypeError)
+      expect { FFI::AutoPointer.new(FFI::Buffer.new(:int))}.to raise_error(::TypeError)
     end
 
   end
@@ -238,13 +242,13 @@ describe "AutoPointer" do
     end
 
     it "should be true by default" do
-      ptr_class.new(FFI::Pointer.new(0xdeadbeef)).autorelease?.should be_true
+      expect(ptr_class.new(FFI::Pointer.new(0xdeadbeef)).autorelease?).to be true
     end
 
     it "should return false when autorelease=(false)" do
       ptr = ptr_class.new(FFI::Pointer.new(0xdeadbeef))
       ptr.autorelease = false
-      ptr.autorelease?.should be_false
+      expect(ptr.autorelease?).to be false
     end
   end
 
@@ -255,7 +259,7 @@ describe "AutoPointer" do
 
     it "type_size of AutoPointer should match wrapped Pointer" do
       aptr = ptr_class.new(FFI::Pointer.new(:int, 0xdeadbeef))
-      aptr.type_size.should == FFI.type_size(:int)
+      expect(aptr.type_size).to eq(FFI.type_size(:int))
     end
     
     it "[] offset should match wrapped Pointer" do
@@ -263,8 +267,8 @@ describe "AutoPointer" do
       aptr = ptr_class.new(FFI::Pointer.new(:int, mptr))
       aptr[0].write_uint(0xfee1dead)
       aptr[1].write_uint(0xcafebabe)
-      mptr[0].read_uint.should == 0xfee1dead
-      mptr[1].read_uint.should == 0xcafebabe
+      expect(mptr[0].read_uint).to eq(0xfee1dead)
+      expect(mptr[1].read_uint).to eq(0xcafebabe)
     end
   end
 end