ffi 1.0.10 → 1.0.11

data/spec/ffi/rbx/struct_spec.rb

@@ -8,6 +8,6 @@ describe FFI::Struct do
   it "allows setting fields" do
     t = Timeval.new
     t[:tv_sec] = 12
-    t[:tv_sec].should == 12
+    t[:tv_sec].should eq 12
   end
-end
+end

data/spec/ffi/spec_helper.rb

@@ -21,7 +21,7 @@ if RUBY_PLATFORM =~/java/
   $:.reject! { |p| p == libdir }
 else
   $:.unshift File.join(File.dirname(__FILE__), "..", "..", "lib"),
-    File.join(File.dirname(__FILE__), "..", "..", "build", "#{Config::CONFIG['host_cpu''arch']}", "ffi_c", RUBY_VERSION)
+    File.join(File.dirname(__FILE__), "..", "..", "build", "#{RbConfig::CONFIG['host_cpu''arch']}", "ffi_c", RUBY_VERSION)
 end
 # puts "loadpath=#{$:.join(':')}"
 require "ffi"

data/spec/ffi/string_spec.rb

@@ -29,7 +29,7 @@ describe "String tests" do
     mp = FFI::MemoryPointer.new 1024
     mp.put_string(0, "test\0")
     str = mp.get_string(0)
-    str.tainted?.should == true
+    str.tainted?.should eq true
   end
   it "String returned by a method is tainted" do
     mp = FFI::MemoryPointer.new :pointer
@@ -37,8 +37,8 @@ describe "String tests" do
     sp.put_string(0, "test")
     mp.put_pointer(0, sp)
     str = StrLibTest.ptr_ret_pointer(mp, 0)
-    str.should == "test"
-    str.tainted?.should == true
+    str.should eq "test"
+    str.tainted?.should eq true
   end
   it "Poison null byte raises error" do
     s = "123\0abc"
@@ -49,15 +49,15 @@ describe "String tests" do
     str = "test"
     str.taint
     begin
-      LibTest.string_equals(str, str).should == false
-    rescue SecurityError => e
+      LibTest.string_equals(str, str).should eq false
+    rescue SecurityError
     end
   end if false
   it "casts nil as NULL pointer" do
     StrLibTest.string_dummy(nil)
   end
   it "return nil for NULL char*" do
-    StrLibTest.string_null.should == nil
+    StrLibTest.string_null.should eq nil
   end
   it "reads an array of strings until encountering a NULL pointer" do
     strings = ["foo", "bar", "baz", "testing", "ffi"]
@@ -69,7 +69,7 @@ describe "String tests" do
     end
     ary.insert(3, nil)
     ptrary.write_array_of_pointer(ary)
-    ptrary.get_array_of_string(0).should == ["foo", "bar", "baz"]
+    ptrary.get_array_of_string(0).should eq ["foo", "bar", "baz"]
   end
   it "reads an array of strings of the size specified, substituting nil when a pointer is NULL" do
     strings = ["foo", "bar", "baz", "testing", "ffi"]
@@ -81,7 +81,7 @@ describe "String tests" do
     end
     ary.insert(2, nil)
     ptrary.write_array_of_pointer(ary)
-    ptrary.get_array_of_string(0, 4).should == ["foo", "bar", nil, "baz"]
+    ptrary.get_array_of_string(0, 4).should eq ["foo", "bar", nil, "baz"]
   end
   it "reads an array of strings, taking a memory offset parameter" do
     strings = ["foo", "bar", "baz", "testing", "ffi"]
@@ -92,7 +92,7 @@ describe "String tests" do
       a << f
     end
     ptrary.write_array_of_pointer(ary)
-    ptrary.get_array_of_string(2 * FFI.type_size(:pointer), 3).should == ["baz", "testing", "ffi"]
+    ptrary.get_array_of_string(2 * FFI.type_size(:pointer), 3).should eq ["baz", "testing", "ffi"]
   end
   it "raises an IndexError when trying to read an array of strings out of bounds" do
     strings = ["foo", "bar", "baz", "testing", "ffi"]

data/spec/ffi/strptr_spec.rb

@@ -20,7 +20,7 @@ describe "functions returning :strptr" do
 
   it "can attach function with :strptr return type" do
     lambda do
-      m = Module.new do
+      Module.new do
         extend FFI::Library
         ffi_lib FFI::Library::LIBC
         if !FFI::Platform.windows?
@@ -51,11 +51,11 @@ describe "functions returning :strptr" do
 
   it "should return the correct value" do
     result = StrPtr.strdup("test")
-    result[0].should == "test"
+    result[0].should eq "test"
   end
 
   it "should return non-NULL pointer" do
     result = StrPtr.strdup("test")
     result[1].null?.should be_false
   end
-end
+end

data/spec/ffi/struct_callback_spec.rb

@@ -18,7 +18,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
 
 describe FFI::Struct, ' with inline callback functions' do
   it 'should be able to define inline callback field' do
-    module CallbackMember
+    module CallbackMember1
       extend FFI::Library
       ffi_lib TestLibrary::PATH
       DUMMY_CB = callback :dummy_cb, [ :int ], :int
@@ -33,7 +33,7 @@ describe FFI::Struct, ' with inline callback functions' do
     end
   end
   it 'should take methods as callbacks' do
-    module CallbackMember
+    module CallbackMember2
       extend FFI::Library
       ffi_lib TestLibrary::PATH
       class TestStruct < FFI::Struct
@@ -50,14 +50,14 @@ describe FFI::Struct, ' with inline callback functions' do
       end
     end
 
-    ts = CallbackMember::TestStruct.new
+    ts = CallbackMember2::TestStruct.new
     ts[:add] = StructCallbacks.method(:add)
 
-    CallbackMember.struct_call_add_cb(ts, 1, 2).should == 3
+    CallbackMember2.struct_call_add_cb(ts, 1, 2).should eq 3
   end
 
   it 'should return callable object from []' do
-    module CallbackMember
+    module CallbackMember3
       extend FFI::Library
       ffi_lib TestLibrary::PATH
       class TestStruct < FFI::Struct
@@ -69,12 +69,12 @@ describe FFI::Struct, ' with inline callback functions' do
       attach_function :struct_call_sub_cb, [TestStruct, :int, :int], :int
     end
 
-    s = CallbackMember::TestStruct.new
+    s = CallbackMember3::TestStruct.new
     add = Proc.new { |a,b| a+b}
     s[:add] = add
     fn = s[:add]
     fn.respond_to?(:call).should be_true
-    fn.call(1, 2).should == 3
+    fn.call(1, 2).should eq 3
   end
 end
 

data/spec/ffi/struct_initialize_spec.rb

@@ -26,7 +26,7 @@ describe FFI::Struct, ' with an initialize function' do
         self.magic = 42
       end
     end
-    StructWithInitialize.new.magic.should == 42
+    StructWithInitialize.new.magic.should eq 42
   end
 end
 
@@ -41,6 +41,6 @@ describe FFI::ManagedStruct, ' with an initialize function' do
       end
       def self.release;end
     end
-    ManagedStructWithInitialize.new.magic.should == 42
+    ManagedStructWithInitialize.new.magic.should eq 42
   end
 end

data/spec/ffi/struct_packed_spec.rb

@@ -21,42 +21,42 @@ describe FFI::Struct do
     Class.new(FFI::Struct) do
       packed
       layout :c, :char, :i, :int
-    end.size.should == 5
+    end.size.should eq 5
   end
 
   it "packed :char followed by :int should have alignment of 1" do
     Class.new(FFI::Struct) do
       packed
       layout :c, :char, :i, :int
-    end.alignment.should == 1
+    end.alignment.should eq 1
   end
 
   it "packed(2) :char followed by :int should have size of 6" do
     Class.new(FFI::Struct) do
       packed 2
       layout :c, :char, :i, :int
-    end.size.should == 6
+    end.size.should eq 6
   end
 
   it "packed(2)  :char followed by :int should have alignment of 2" do
     Class.new(FFI::Struct) do
       packed 2
       layout :c, :char, :i, :int
-    end.alignment.should == 2
+    end.alignment.should eq 2
   end
 
   it "packed :short followed by int should have size of 6" do
     Class.new(FFI::Struct) do
       packed
       layout :s, :short, :i, :int
-    end.size.should == 6
+    end.size.should eq 6
   end
 
   it "packed :short followed by int should have alignment of 1" do
     Class.new(FFI::Struct) do
       packed
       layout :s, :short, :i, :int
-    end.alignment.should == 1
+    end.alignment.should eq 1
   end
 
 end

data/spec/ffi/struct_spec.rb

@@ -49,7 +49,7 @@ describe "Struct tests" do
     smp = FFI::MemoryPointer.new :pointer
     smp.put_pointer(0, mp)
     s = PointerMember.new smp
-    s[:pointer].should == mp
+    s[:pointer].should eq mp
   end
   it "Struct#[:pointer].nil? for NULL value" do
     magic = 0x12345678
@@ -58,7 +58,7 @@ describe "Struct tests" do
     smp = FFI::MemoryPointer.new :pointer
     smp.put_pointer(0, nil)
     s = PointerMember.new smp
-    s[:pointer].null?.should == true
+    s[:pointer].null?.should eq true
   end
   it "Struct#[:pointer]=" do
     magic = 0x12345678
@@ -67,10 +67,9 @@ describe "Struct tests" do
     smp = FFI::MemoryPointer.new :pointer
     s = PointerMember.new smp
     s[:pointer] = mp
-    smp.get_pointer(0).should == mp
+    smp.get_pointer(0).should eq mp
   end
   it "Struct#[:pointer]=struct" do
-    magic = 0x12345678
     smp = FFI::MemoryPointer.new :pointer
     s = PointerMember.new smp
     lambda { s[:pointer] = s }.should_not raise_error
@@ -79,7 +78,7 @@ describe "Struct tests" do
     smp = FFI::MemoryPointer.new :pointer
     s = PointerMember.new smp
     s[:pointer] = nil
-    smp.get_pointer(0).null?.should == true
+    smp.get_pointer(0).null?.should eq true
   end
   it "Struct#[:string]" do
     magic = "test"
@@ -88,50 +87,50 @@ describe "Struct tests" do
     smp = FFI::MemoryPointer.new :pointer
     smp.put_pointer(0, mp)
     s = StringMember.new smp
-    s[:string].should == magic
+    s[:string].should eq magic
   end
   it "Struct#[:string].nil? for NULL value" do
     smp = FFI::MemoryPointer.new :pointer
     smp.put_pointer(0, nil)
     s = StringMember.new smp
-    s[:string].nil?.should == true
+    s[:string].nil?.should eq true
   end
   it "Struct#layout works with :name, :type pairs" do
     class PairLayout < FFI::Struct
       layout :a, :int, :b, :long_long
     end
     ll_off = (FFI::TYPE_UINT64.alignment == 4 ? 4 : 8)
-    PairLayout.size.should == (ll_off + 8)
+    PairLayout.size.should eq(ll_off + 8)
     mp = FFI::MemoryPointer.new(PairLayout.size)
     s = PairLayout.new mp
     s[:a] = 0x12345678
-    mp.get_int(0).should == 0x12345678
+    mp.get_int(0).should eq 0x12345678
     s[:b] = 0xfee1deadbeef
-    mp.get_int64(ll_off).should == 0xfee1deadbeef
+    mp.get_int64(ll_off).should eq 0xfee1deadbeef
   end
   it "Struct#layout works with :name, :type, offset tuples" do
     class PairLayout < FFI::Struct
       layout :a, :int, 0, :b, :long_long, 4
     end
-    PairLayout.size.should == (FFI::TYPE_UINT64.alignment == 4 ? 12 : 16)
+    PairLayout.size.should eq(FFI::TYPE_UINT64.alignment == 4 ? 12 : 16)
     mp = FFI::MemoryPointer.new(PairLayout.size)
     s = PairLayout.new mp
     s[:a] = 0x12345678
-    mp.get_int(0).should == 0x12345678
+    mp.get_int(0).should eq 0x12345678
     s[:b] = 0xfee1deadbeef
-    mp.get_int64(4).should == 0xfee1deadbeef
+    mp.get_int64(4).should eq 0xfee1deadbeef
   end
   it "Struct#layout works with mixed :name,:type and :name,:type,offset" do
     class MixedLayout < FFI::Struct
       layout :a, :int, :b, :long_long, 4
     end
-    MixedLayout.size.should == (FFI::TYPE_UINT64.alignment == 4 ? 12 : 16)
+    MixedLayout.size.should eq(FFI::TYPE_UINT64.alignment == 4 ? 12 : 16)
     mp = FFI::MemoryPointer.new(MixedLayout.size)
     s = MixedLayout.new mp
     s[:a] = 0x12345678
-    mp.get_int(0).should == 0x12345678
+    mp.get_int(0).should eq 0x12345678
     s[:b] = 0xfee1deadbeef
-    mp.get_int64(4).should == 0xfee1deadbeef
+    mp.get_int64(4).should eq 0xfee1deadbeef
   end
   rb_maj, rb_min = RUBY_VERSION.split('.')
   if rb_maj.to_i >= 1 && rb_min.to_i >= 9 || RUBY_PLATFORM =~ /java/
@@ -140,13 +139,13 @@ describe "Struct tests" do
         layout :a => :int, :b => :long_long
       end
       ll_off = (FFI::TYPE_UINT64.alignment == 4? 4 : 8)
-      HashLayout.size.should == (ll_off + 8)
+      HashLayout.size.should eq(ll_off + 8)
       mp = FFI::MemoryPointer.new(HashLayout.size)
       s = HashLayout.new mp
       s[:a] = 0x12345678
-      mp.get_int(0).should == 0x12345678
+      mp.get_int(0).should eq 0x12345678
       s[:b] = 0xfee1deadbeef
-      mp.get_int64(ll_off).should == 0xfee1deadbeef
+      mp.get_int64(ll_off).should eq 0xfee1deadbeef
       end
   end
 
@@ -163,8 +162,8 @@ describe "Struct tests" do
 
     end
     s = InitializeWithoutSuper.new(0x1eefbeef, 0xdeadcafebabe)
-    s[:a].should == 0x1eefbeef
-    s[:b].should == 0xdeadcafebabe
+    s[:a].should eq 0x1eefbeef
+    s[:b].should eq 0xdeadcafebabe
   end
 
   it "Can use Struct subclass as parameter type" do
@@ -178,7 +177,7 @@ describe "Struct tests" do
     end
   end
   it "Can use Struct subclass as IN parameter type" do
-    module StructParam
+    module StructParam2
       extend FFI::Library
       ffi_lib TestLibrary::PATH
       class TestStruct < FFI::Struct
@@ -188,7 +187,7 @@ describe "Struct tests" do
     end
   end
   it "Can use Struct subclass as OUT parameter type" do
-    module StructParam
+    module StructParam3
       extend FFI::Library
       ffi_lib TestLibrary::PATH
       class TestStruct < FFI::Struct
@@ -203,7 +202,7 @@ describe "Struct tests" do
     end
     s = TestStruct.new
     s[:i] = 0x12
-    LibTest.ptr_ret_int32_t(s, 0).should == 0x12
+    LibTest.ptr_ret_int32_t(s, 0).should eq 0x12
   end
   it ":char member aligned correctly" do
     class AlignChar < FFI::Struct
@@ -211,7 +210,7 @@ describe "Struct tests" do
     end
     s = AlignChar.new
     s[:v] = 0x12
-    LibTest.struct_align_s8(s.pointer).should == 0x12
+    LibTest.struct_align_s8(s.pointer).should eq 0x12
   end
   it ":short member aligned correctly" do
     class AlignShort < FFI::Struct
@@ -219,7 +218,7 @@ describe "Struct tests" do
     end
     s = AlignShort.alloc_in
     s[:v] = 0x1234
-    LibTest.struct_align_s16(s.pointer).should == 0x1234
+    LibTest.struct_align_s16(s.pointer).should eq 0x1234
   end
   it ":int member aligned correctly" do
     class AlignInt < FFI::Struct
@@ -227,7 +226,7 @@ describe "Struct tests" do
     end
     s = AlignInt.alloc_in
     s[:v] = 0x12345678
-    LibTest.struct_align_s32(s.pointer).should == 0x12345678
+    LibTest.struct_align_s32(s.pointer).should eq 0x12345678
   end
   it ":long_long member aligned correctly" do
     class AlignLongLong < FFI::Struct
@@ -235,7 +234,7 @@ describe "Struct tests" do
     end
     s = AlignLongLong.alloc_in
     s[:v] = 0x123456789abcdef0
-    LibTest.struct_align_s64(s.pointer).should == 0x123456789abcdef0
+    LibTest.struct_align_s64(s.pointer).should eq 0x123456789abcdef0
   end
   it ":long member aligned correctly" do
     class AlignLong < FFI::Struct
@@ -243,7 +242,7 @@ describe "Struct tests" do
     end
     s = AlignLong.alloc_in
     s[:v] = 0x12345678
-    LibTest.struct_align_long(s.pointer).should == 0x12345678
+    LibTest.struct_align_long(s.pointer).should eq 0x12345678
   end
   it ":float member aligned correctly" do
     class AlignFloat < FFI::Struct
@@ -268,7 +267,7 @@ describe "Struct tests" do
     s = ULPStruct.alloc_in
     s[:ul] = 0xdeadbeef
     s[:p] = LibTest.ptr_from_address(0x12345678)
-    s.pointer.get_ulong(0).should == 0xdeadbeef
+    s.pointer.get_ulong(0).should eq 0xdeadbeef
   end
   def test_num_field(type, v)
     klass = Class.new(FFI::Struct)
@@ -276,9 +275,9 @@ describe "Struct tests" do
     
     s = klass.new
     s[:v] = v
-    s.pointer.send("get_#{type.to_s}", 0).should == v
+    s.pointer.send("get_#{type.to_s}", 0).should eq v
     s.pointer.send("put_#{type.to_s}", 0, 0)
-    s[:v].should == 0
+    s[:v].should eq 0
   end
   def self.int_field_test(type, values)
     values.each do |v|
@@ -333,8 +332,8 @@ describe "Struct tests" do
     s = EnumFields::TestStruct.new
     s[:c] = :c3
 
-    s.pointer.get_uint(FFI::Type::INT32.size).should == 30
-    s[:c].should == :c3
+    s.pointer.get_uint(FFI::Type::INT32.size).should eq 30
+    s[:c].should eq :c3
   end
   
   it "array of :enum field" do
@@ -344,11 +343,11 @@ describe "Struct tests" do
     end
     
     EnumFields::TestEnum.symbols.each_with_index do |val, i|
-      s.pointer.get_uint(FFI::Type::INT32.size * (2 + i)).should == EnumFields::TestEnum[val]
+      s.pointer.get_uint(FFI::Type::INT32.size * (2 + i)).should eq EnumFields::TestEnum[val]
     end
     
     s[:d].each_with_index do |val, i|
-      val.should == EnumFields::TestEnum.symbols[i]
+      val.should eq EnumFields::TestEnum.symbols[i]
     end
   end
   
@@ -370,8 +369,8 @@ describe "Struct tests" do
       sub_proc = lambda { |a, b| a-b }
       s[:add] = add_proc
       s[:sub] = sub_proc
-      CallbackMember.struct_call_add_cb(s, 40, 2).should == 42
-      CallbackMember.struct_call_sub_cb(s, 44, 2).should == 42
+      CallbackMember.struct_call_add_cb(s, 40, 2).should eq 42
+      CallbackMember.struct_call_sub_cb(s, 44, 2).should eq 42
   end
   it "Can return its members as a list" do
     class TestStruct < FFI::Struct
@@ -395,16 +394,16 @@ describe "Struct tests" do
       layout :a, :int, :b, :int, :c, :int
     end
     s = TestStruct.new
-    s.offsets.should == [[:a, 0], [:b, 4], [:c, 8]]
-    TestStruct.offsets.should == [[:a, 0], [:b, 4], [:c, 8]]
+    s.offsets.should eq [[:a, 0], [:b, 4], [:c, 8]]
+    TestStruct.offsets.should eq [[:a, 0], [:b, 4], [:c, 8]]
   end
   it "Struct#offset_of returns offset of field within struct" do
     class TestStruct < FFI::Struct
       layout :a, :int, :b, :int, :c, :int
     end
-    TestStruct.offset_of(:a).should == 0
-    TestStruct.offset_of(:b).should == 4
-    TestStruct.offset_of(:c).should == 8
+    TestStruct.offset_of(:a).should eq 0
+    TestStruct.offset_of(:b).should eq 4
+    TestStruct.offset_of(:c).should eq 8
   end
 end
 
@@ -426,22 +425,22 @@ describe FFI::Struct, ' with a nested struct field'  do
   end
   it 'should align correctly nested struct field' do
     @cs[:ns][:i] = 123
-    LibTest.struct_align_nested_struct(@cs.to_ptr).should == 123
+    LibTest.struct_align_nested_struct(@cs.to_ptr).should eq 123
   end
   it 'should correctly calculate Container size (in bytes)' do
-    LibTest::ContainerStruct.size.should == 8
+    LibTest::ContainerStruct.size.should eq 8
   end
   it 'should return a Struct object when the field is accessed' do
     @cs[:ns].is_a?(FFI::Struct).should be_true 
   end
   it 'should read a value from memory' do
     @cs = LibTest::ContainerStruct.new(LibTest.struct_make_container_struct(123))
-    @cs[:ns][:i].should == 123
+    @cs[:ns][:i].should eq 123
   end
   it 'should write a value to memory' do
     @cs = LibTest::ContainerStruct.new(LibTest.struct_make_container_struct(123))
     @cs[:ns][:i] = 456
-    LibTest.struct_align_nested_struct(@cs.to_ptr).should == 456
+    LibTest.struct_align_nested_struct(@cs.to_ptr).should eq 456
   end
 end
 
@@ -465,11 +464,11 @@ describe FFI::Struct, ' with a nested array of structs'  do
 
   it 'should align correctly nested struct field' do
     @cs[:ns][0][:i] = 123
-    InlineArrayOfStructs.struct_align_nested_struct(@cs.to_ptr).should == 123
+    InlineArrayOfStructs.struct_align_nested_struct(@cs.to_ptr).should eq 123
   end
 
   it 'should correctly calculate Container size (in bytes)' do
-    InlineArrayOfStructs::ContainerStruct.size.should == 8
+    InlineArrayOfStructs::ContainerStruct.size.should eq 8
   end
 
   it 'should return a Struct object when the field is accessed' do
@@ -478,20 +477,20 @@ describe FFI::Struct, ' with a nested array of structs'  do
 
   it 'should read a value from memory' do
     @cs = InlineArrayOfStructs::ContainerStruct.new(InlineArrayOfStructs.struct_make_container_struct(123))
-    @cs[:ns][0][:i].should == 123
+    @cs[:ns][0][:i].should eq 123
   end
 
   it 'should write a value to memory' do
     @cs = InlineArrayOfStructs::ContainerStruct.new(InlineArrayOfStructs.struct_make_container_struct(123))
     @cs[:ns][0][:i] = 456
-    InlineArrayOfStructs.struct_align_nested_struct(@cs.to_ptr).should == 456
+    InlineArrayOfStructs.struct_align_nested_struct(@cs.to_ptr).should eq 456
   end
 
   it 'should support Enumerable#each' do
     @cs = InlineArrayOfStructs::ContainerStruct.new(InlineArrayOfStructs.struct_make_container_struct(123))
     ints = []
     @cs[:ns].each { |s| ints << s[:i] }
-    ints[0].should == 123
+    ints[0].should eq 123
   end
 end
 
@@ -519,22 +518,22 @@ describe FFI::Struct, ' by value'  do
 
   it 'return using pre-set values' do
     s = LibTest.struct_return_s8s32
-    s[:s8].should == 0x7f
-    s[:s32].should == 0x12345678
+    s[:s8].should eq 0x7f
+    s[:s32].should eq 0x12345678
   end
 
   it 'return using passed in values' do
     s = LibTest.struct_s8s32_set(123, 456789)
-    s[:s8].should == 123
-    s[:s32].should == 456789
+    s[:s8].should eq 123
+    s[:s32].should eq 456789
   end
 
   it 'parameter' do
     s = LibTest::S8S32.new
     s[:s8] = 0x12
     s[:s32] = 0x34567890
-    LibTest.struct_s8s32_get_s8(s).should == 0x12
-    LibTest.struct_s8s32_get_s32(s).should == 0x34567890
+    LibTest.struct_s8s32_get_s8(s).should eq 0x12
+    LibTest.struct_s8s32_get_s32(s).should eq 0x34567890
   end
 
   it 'parameter with following s32' do
@@ -542,7 +541,7 @@ describe FFI::Struct, ' by value'  do
     s[:s8] = 0x12
     s[:s32] = 0x34567890
     
-    LibTest.struct_s8s32_s32_ret_s32(s, 0x1eefdead).should == 0x1eefdead
+    LibTest.struct_s8s32_s32_ret_s32(s, 0x1eefdead).should eq 0x1eefdead
   end
 
   it 'parameter with following s64' do
@@ -550,14 +549,14 @@ describe FFI::Struct, ' by value'  do
     s[:s8] = 0x12
     s[:s32] = 0x34567890
 
-    LibTest.struct_s8s32_s64_ret_s64(s, 0xdeadcafebabe).should == 0xdeadcafebabe
+    LibTest.struct_s8s32_s64_ret_s64(s, 0xdeadcafebabe).should eq 0xdeadcafebabe
   end
 
   it 'varargs returning a struct' do
     string = "test"
     s = LibTest.struct_varargs_ret_struct_string(4, :string, string)
-    s[:len].should == string.length
-    s[:bytes].should == string
+    s[:len].should eq string.length
+    s[:bytes].should eq string
   end
 end
 
@@ -575,26 +574,26 @@ describe FFI::Struct, ' with an array field'  do
     @s = LibTest::StructWithArray.new
   end
   it 'should correctly calculate StructWithArray size (in bytes)' do
-    LibTest::StructWithArray.size.should == 24
+    LibTest::StructWithArray.size.should eq 24
   end
   it 'should read values from memory' do
     @s = LibTest::StructWithArray.new(LibTest.struct_make_struct_with_array(0, 1, 2, 3, 4))
-    @s[:a].to_a.should == [0, 1, 2, 3, 4]
+    @s[:a].to_a.should eq [0, 1, 2, 3, 4]
   end
 #  it 'should cache array object for successive calls' do
-#    @s[:a].object_id.should == @s[:a].object_id
+#    @s[:a].object_id.should eq @s[:a].object_id
 #  end
   it 'should return the number of elements in the array field' do
     @s = LibTest::StructWithArray.new(LibTest.struct_make_struct_with_array(0, 1, 2, 3, 4))
-    @s[:a].size.should == 5
+    @s[:a].size.should eq 5
   end
   it 'should allow iteration through the array elements' do
     @s = LibTest::StructWithArray.new(LibTest.struct_make_struct_with_array(0, 1, 2, 3, 4))
-    @s[:a].each_with_index { |elem, i| elem.should == i }  
+    @s[:a].each_with_index { |elem, i| elem.should eq i }  
   end
   it 'should return the pointer to the array' do
     @s = LibTest::StructWithArray.new(LibTest.struct_make_struct_with_array(0, 1, 2, 3, 4))
-    @s[:a].to_ptr.should == LibTest::struct_field_array(@s.to_ptr)
+    @s[:a].to_ptr.should eq LibTest::struct_field_array(@s.to_ptr)
   end
 end
 
@@ -614,21 +613,21 @@ describe 'BuggedStruct' do
     attach_function :bugged_struct_size, [], :uint
   end
   it 'should return its correct size' do
-    LibTest::BuggedStruct.size.should == LibTest.bugged_struct_size
+    LibTest::BuggedStruct.size.should eq LibTest.bugged_struct_size
   end
   it "offsets within struct should be correct" do
-    LibTest::BuggedStruct.offset_of(:visible).should == 0
-    LibTest::BuggedStruct.offset_of(:x).should == 4
-    LibTest::BuggedStruct.offset_of(:y).should == 8
-    LibTest::BuggedStruct.offset_of(:rx).should == 12
-    LibTest::BuggedStruct.offset_of(:ry).should == 14
-    LibTest::BuggedStruct.offset_of(:order).should == 16
-    LibTest::BuggedStruct.offset_of(:size).should == 17
+    LibTest::BuggedStruct.offset_of(:visible).should eq 0
+    LibTest::BuggedStruct.offset_of(:x).should eq 4
+    LibTest::BuggedStruct.offset_of(:y).should eq 8
+    LibTest::BuggedStruct.offset_of(:rx).should eq 12
+    LibTest::BuggedStruct.offset_of(:ry).should eq 14
+    LibTest::BuggedStruct.offset_of(:order).should eq 16
+    LibTest::BuggedStruct.offset_of(:size).should eq 17
   end
   it 'should return correct field/offset pairs' do
     LibTest::BuggedStruct.offsets.sort do |a, b|
       a[1] <=> b[1] 
-    end.should == [[:visible, 0], [:x, 4], [:y, 8], [:rx, 12], [:ry, 14], [:order, 16], [:size, 17]]
+    end.should eq [[:visible, 0], [:x, 4], [:y, 8], [:rx, 12], [:ry, 14], [:order, 16], [:size, 17]]
   end
 end
 
@@ -638,11 +637,11 @@ describe "Struct allocation" do
       layout :i, :uint
     end
     p = FFI::MemoryPointer.new(S, 2)
-    p.total.should == 8
-    p.type_size.should == 4
+    p.total.should eq 8
+    p.type_size.should eq 4
     p.put_uint(4, 0xdeadbeef)
-    S.new(p[1])[:i].should == 0xdeadbeef
-    p[1].address.should == (p[0].address + 4)
+    S.new(p[1])[:i].should eq 0xdeadbeef
+    p[1].address.should eq(p[0].address + 4)
   end
 
   it "Buffer.new(Struct, 2)" do
@@ -650,10 +649,10 @@ describe "Struct allocation" do
       layout :i, :uint
     end
     p = FFI::Buffer.new(S, 2)
-    p.total.should == 8
-    p.type_size.should == 4
+    p.total.should eq 8
+    p.type_size.should eq 4
     p.put_uint(4, 0xdeadbeef)
-    S.new(p[1])[:i].should == 0xdeadbeef
+    S.new(p[1])[:i].should eq 0xdeadbeef
   end
 
   it "null? should be true when initialized with NULL pointer" do
@@ -675,7 +674,8 @@ describe "Struct allocation" do
       c = Class.new(FFI::Struct) do
         layout :b, :bool
       end
-      c.new
+      struct = c.new
+      struct[:b] = ! struct[:b]
     end.should_not raise_error
   end