gir_ffi 0.7.8 → 0.7.9

data/test/gir_ffi/class_base_test.rb

@@ -55,14 +55,14 @@ describe GirFFI::ClassBase do
       end
 
       it 'returns false when comparing to an object of a different class and same pointer' do
-        stub(other = Object.new).to_ptr { object.to_ptr }
+        allow(other = Object.new).to receive(:to_ptr).and_return object.to_ptr
 
         object.wont_be :==, other
         other.wont_be :==, object
       end
 
       it 'returns false when comparing to an object of a different class and different pointer' do
-        stub(other = Object.new).to_ptr { FFI::MemoryPointer.new(:int32) }
+        allow(other = Object.new).to receive(:to_ptr).and_return FFI::MemoryPointer.new(:int32)
 
         object.wont_be :==, other
         other.wont_be :==, object
@@ -72,11 +72,11 @@ describe GirFFI::ClassBase do
 
   describe '.setup_and_call' do
     it 'looks up class methods in all builders' do
-      mock(builder = Object.new).setup_method('foo') { 'foo' }
+      expect(builder = Object.new).to receive(:setup_method).with('foo').and_return 'foo'
       klass = Class.new GirFFI::ClassBase
       klass.const_set :GIR_FFI_BUILDER, builder
 
-      mock(sub_builder = Object.new).setup_method('foo') { nil }
+      expect(sub_builder = Object.new).to receive(:setup_method).with('foo').and_return nil
       sub_klass = Class.new klass do
         def self.foo; end
       end
@@ -86,7 +86,7 @@ describe GirFFI::ClassBase do
     end
 
     it 'calls the method given by the result of .setup_method' do
-      mock(builder = Object.new).setup_method('foo') { 'bar' }
+      expect(builder = Object.new).to receive(:setup_method).with('foo').and_return 'bar'
       klass = Class.new GirFFI::ClassBase do
         def self.bar
           'correct-result'
@@ -104,11 +104,11 @@ describe GirFFI::ClassBase do
 
   describe '#setup_and_call' do
     it 'looks up instance methods in all builders' do
-      mock(builder = Object.new).setup_instance_method('foo') { 'foo' }
+      expect(builder = Object.new).to receive(:setup_instance_method).with('foo').and_return 'foo'
       klass = Class.new GirFFI::ClassBase
       klass.const_set :GIR_FFI_BUILDER, builder
 
-      mock(sub_builder = Object.new).setup_instance_method('foo') { nil }
+      expect(sub_builder = Object.new).to receive(:setup_instance_method).with('foo').and_return nil
       sub_klass = Class.new klass do
         def foo; end
 
@@ -125,7 +125,7 @@ describe GirFFI::ClassBase do
     end
 
     it 'calls the method given by the result of .setup_instance_method' do
-      mock(builder = Object.new).setup_instance_method('foo') { 'bar' }
+      expect(builder = Object.new).to receive(:setup_instance_method).with('foo').and_return 'bar'
       klass = Class.new GirFFI::ClassBase do
         def bar
           'correct-result'

data/test/gir_ffi/ffi_ext/pointer_test.rb

@@ -5,12 +5,12 @@ describe GirFFI::FFIExt::Pointer do
   describe '#to_object' do
     it 'finds the wrapping class by gtype and wraps the pointer in it' do
       ptr = klass.new
-      mock(ptr).null? { false }
+      expect(ptr).to receive(:null?).and_return false
       object_class = Class.new
 
-      mock(GObject).type_from_instance_pointer(ptr) { 0xdeadbeef }
-      mock(GirFFI::Builder).build_by_gtype(0xdeadbeef) { object_class }
-      mock(object_class).direct_wrap(ptr) { 'good-result' }
+      expect(GObject).to receive(:type_from_instance_pointer).with(ptr).and_return 0xdeadbeef
+      expect(GirFFI::Builder).to receive(:build_by_gtype).with(0xdeadbeef).and_return object_class
+      expect(object_class).to receive(:direct_wrap).with(ptr).and_return 'good-result'
 
       ptr.to_object.must_equal 'good-result'
     end

data/test/gir_ffi/g_type_test.rb

@@ -3,7 +3,7 @@ require 'gir_ffi_test_helper'
 require 'gir_ffi/g_type'
 
 describe GirFFI::GType do
-  let(:gobject_gtype) { GObject::Object.get_gtype }
+  let(:gobject_gtype) { GObject::Object.gtype }
   let(:gobject_type_query) { GObject.type_query gobject_gtype }
 
   describe '#to_i' do

data/test/gir_ffi/in_pointer_test.rb

@@ -16,7 +16,7 @@ describe GirFFI::InPointer do
     it 'handles enum types' do
       e = Module.new do
         extend GirFFI::EnumBase
-        self::Enum = FFI::Enum.new [:foo, :bar, :baz]
+        self::Enum = FFI::Enum.new [:foo, :bar, :baz], :qux
       end
       ptr = GirFFI::InPointer.from_array e, [:bar, :foo, :baz]
       ptr.read_array_of_int32(3).must_equal [1, 0, 2]
@@ -146,7 +146,7 @@ describe GirFFI::InPointer do
 
     it 'handles enum types' do
       e = Module.new do
-        self::Enum = FFI::Enum.new [:foo, :bar, :baz]
+        self::Enum = FFI::Enum.new [:foo, :bar, :baz], :qux
         def self.[] val
           self::Enum[val]
         end

data/test/gir_ffi/info_ext/i_callable_info_test.rb

@@ -11,9 +11,9 @@ describe GirFFI::InfoExt::ICallableInfo do
   describe '#argument_ffi_types' do
     describe 'for a simple callable with several arguments' do
       before do
-        stub(arg_info1 = Object.new).to_ffitype { :type1 }
-        stub(arg_info2 = Object.new).to_ffitype { :type2 }
-        stub(callable_info).args { [arg_info1, arg_info2] }
+        allow(arg_info1 = Object.new).to receive(:to_ffi_type).and_return :type1
+        allow(arg_info2 = Object.new).to receive(:to_ffi_type).and_return :type2
+        allow(callable_info).to receive(:args).and_return [arg_info1, arg_info2]
       end
 
       it 'returns the ffi types of the arguments' do

data/test/gir_ffi/info_ext/i_callback_info_test.rb

@@ -10,8 +10,8 @@ describe GirFFI::InfoExt::ICallbackInfo do
 
   describe '#return_ffi_type' do
     it 'returns the callback ffi type of the return type' do
-      stub(return_type_info = Object.new).to_callback_ffitype { :some_type }
-      stub(callback_info).return_type { return_type_info }
+      allow(return_type_info = Object.new).to receive(:to_callback_ffi_type).and_return :some_type
+      allow(callback_info).to receive(:return_type).and_return return_type_info
 
       callback_info.return_ffi_type.must_equal :some_type
     end

data/test/gir_ffi/info_ext/i_field_info_test.rb

@@ -9,11 +9,11 @@ describe GirFFI::InfoExt::IFieldInfo do
   let(:field_info) { klass.new }
   describe '#layout_specification' do
     it 'returns an array of name, typespec and offset' do
-      mock(type = Object.new).to_ffitype { :bar }
+      expect(type = Object.new).to receive(:to_ffi_type).and_return :bar
 
-      mock(field_info).name { 'foo' }
-      mock(field_info).field_type { type }
-      mock(field_info).offset { 0 }
+      expect(field_info).to receive(:name).and_return 'foo'
+      expect(field_info).to receive(:field_type).and_return type
+      expect(field_info).to receive(:offset).and_return 0
 
       result = field_info.layout_specification
 
@@ -21,11 +21,11 @@ describe GirFFI::InfoExt::IFieldInfo do
     end
 
     it 'keeps a complex typespec intact' do
-      mock(type = Object.new).to_ffitype { [:bar, 2] }
+      expect(type = Object.new).to receive(:to_ffi_type).and_return [:bar, 2]
 
-      mock(field_info).name { 'foo' }
-      mock(field_info).field_type { type }
-      mock(field_info).offset { 0 }
+      expect(field_info).to receive(:name).and_return 'foo'
+      expect(field_info).to receive(:field_type).and_return type
+      expect(field_info).to receive(:offset).and_return 0
 
       result = field_info.layout_specification
 

data/test/gir_ffi/info_ext/i_function_info_test.rb

@@ -11,15 +11,15 @@ describe GirFFI::InfoExt::IFunctionInfo do
 
   describe '#argument_ffi_types' do
     before do
-      stub(arg_info1 = Object.new).to_ffitype { :type1 }
-      stub(arg_info2 = Object.new).to_ffitype { :type2 }
-      stub(function_info).args { [arg_info1, arg_info2] }
+      allow(arg_info1 = Object.new).to receive(:to_ffi_type).and_return :type1
+      allow(arg_info2 = Object.new).to receive(:to_ffi_type).and_return :type2
+      allow(function_info).to receive(:args).and_return [arg_info1, arg_info2]
     end
 
     describe 'for a simple function with several arguments' do
       before do
-        stub(function_info).method? { false }
-        stub(function_info).throws? { false }
+        allow(function_info).to receive(:method?).and_return false
+        allow(function_info).to receive(:throws?).and_return false
       end
 
       it 'returns the ffi types of the arguments' do
@@ -29,8 +29,8 @@ describe GirFFI::InfoExt::IFunctionInfo do
 
     describe 'for a throwing function with several arguments' do
       before do
-        stub(function_info).method? { false }
-        stub(function_info).throws? { true }
+        allow(function_info).to receive(:method?).and_return false
+        allow(function_info).to receive(:throws?).and_return true
       end
 
       it 'appends :pointer to represent the error argument' do
@@ -40,8 +40,8 @@ describe GirFFI::InfoExt::IFunctionInfo do
 
     describe 'for a method with several arguments' do
       before do
-        stub(function_info).method? { true }
-        stub(function_info).throws? { false }
+        allow(function_info).to receive(:method?).and_return true
+        allow(function_info).to receive(:throws?).and_return false
       end
 
       it 'prepends :pointer to represent the method reciever' do
@@ -51,8 +51,8 @@ describe GirFFI::InfoExt::IFunctionInfo do
 
     describe 'for a throwing method with several arguments' do
       before do
-        stub(function_info).method? { true }
-        stub(function_info).throws? { true }
+        allow(function_info).to receive(:method?).and_return true
+        allow(function_info).to receive(:throws?).and_return true
       end
 
       it 'adds :pointer for both the reciever and the error argument' do
@@ -63,8 +63,8 @@ describe GirFFI::InfoExt::IFunctionInfo do
 
   describe '#return_ffi_type' do
     it 'returns the ffi type of the return type' do
-      stub(return_type_info = Object.new).to_ffitype { :some_type }
-      stub(function_info).return_type { return_type_info }
+      allow(return_type_info = Object.new).to receive(:to_ffi_type).and_return :some_type
+      allow(function_info).to receive(:return_type).and_return return_type_info
 
       function_info.return_ffi_type.must_equal :some_type
     end

data/test/gir_ffi/info_ext/i_type_info_test.rb

@@ -21,72 +21,72 @@ describe GirFFI::InfoExt::ITypeInfo do
                            'test_ghash_nested_everything_return').return_type
   }
 
-  describe '#to_ffitype' do
+  describe '#to_ffi_type' do
     it 'returns an array with elements subtype and size for type :array' do
-      mock(type_info).pointer? { false }
-      stub(type_info).tag { :array }
-      mock(type_info).array_fixed_size { 2 }
+      expect(type_info).to receive(:pointer?).and_return false
+      allow(type_info).to receive(:tag).and_return :array
+      expect(type_info).to receive(:array_fixed_size).and_return 2
 
-      mock(elmtype_info).to_ffitype { :foo }
-      mock(type_info).param_type(0) { elmtype_info }
+      expect(elmtype_info).to receive(:to_ffi_type).and_return :foo
+      expect(type_info).to receive(:param_type).with(0).and_return elmtype_info
 
-      result = type_info.to_ffitype
+      result = type_info.to_ffi_type
       assert_equal [:foo, 2], result
     end
 
     describe 'for an :interface type' do
       before do
-        stub(type_info).interface { iface_info }
-        stub(type_info).tag { :interface }
-        stub(type_info).pointer? { false }
+        allow(type_info).to receive(:interface).and_return iface_info
+        allow(type_info).to receive(:tag).and_return :interface
+        allow(type_info).to receive(:pointer?).and_return false
       end
 
-      it "maps a the interface's ffitype" do
-        stub(iface_info).to_ffitype { :foo }
+      it "maps a the interface's ffi_type" do
+        allow(iface_info).to receive(:to_ffi_type).and_return :foo
 
-        type_info.to_ffitype.must_equal :foo
+        type_info.to_ffi_type.must_equal :foo
       end
     end
   end
 
   describe '#element_type' do
     it 'returns the element type for lists' do
-      stub(elmtype_info).tag { :foo }
-      mock(elmtype_info).pointer? { false }
+      allow(elmtype_info).to receive(:tag).and_return :foo
+      expect(elmtype_info).to receive(:pointer?).and_return false
 
-      mock(type_info).tag { :glist }
-      mock(type_info).param_type(0) { elmtype_info }
+      expect(type_info).to receive(:tag).and_return :glist
+      expect(type_info).to receive(:param_type).with(0).and_return elmtype_info
 
       result = type_info.element_type
       result.must_equal :foo
     end
 
     it 'returns the key and value types for ghashes' do
-      stub(keytype_info).tag { :foo }
-      mock(keytype_info).pointer? { false }
-      stub(valtype_info).tag { :bar }
-      mock(valtype_info).pointer? { false }
+      allow(keytype_info).to receive(:tag).and_return :foo
+      expect(keytype_info).to receive(:pointer?).and_return false
+      allow(valtype_info).to receive(:tag).and_return :bar
+      expect(valtype_info).to receive(:pointer?).and_return false
 
-      mock(type_info).tag { :ghash }
-      mock(type_info).param_type(0) { keytype_info }
-      mock(type_info).param_type(1) { valtype_info }
+      expect(type_info).to receive(:tag).and_return :ghash
+      expect(type_info).to receive(:param_type).with(0).and_return keytype_info
+      expect(type_info).to receive(:param_type).with(1).and_return valtype_info
 
       result = type_info.element_type
       result.must_equal [:foo, :bar]
     end
 
     it 'returns nil for other types' do
-      mock(type_info).tag { :foo }
+      expect(type_info).to receive(:tag).and_return :foo
 
       result = type_info.element_type
       result.must_be_nil
     end
 
     it 'returns [:pointer, :void] if the element type is a pointer with tag :void' do
-      stub(elmtype_info).tag_or_class { [:pointer, :void] }
+      allow(elmtype_info).to receive(:tag_or_class).and_return [:pointer, :void]
 
-      mock(type_info).tag { :glist }
-      mock(type_info).param_type(0) { elmtype_info }
+      expect(type_info).to receive(:tag).and_return :glist
+      expect(type_info).to receive(:param_type).with(0).and_return elmtype_info
 
       assert_equal [:pointer, :void], type_info.element_type
     end
@@ -95,7 +95,7 @@ describe GirFFI::InfoExt::ITypeInfo do
   describe '#flattened_tag' do
     describe 'for a simple type' do
       it 'returns the type tag' do
-        stub(type_info).tag { :uint32 }
+        allow(type_info).to receive(:tag).and_return :uint32
 
         type_info.flattened_tag.must_equal :uint32
       end
@@ -103,15 +103,15 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for a zero-terminated array' do
       before do
-        stub(type_info).tag { :array }
-        stub(type_info).param_type(0) { elmtype_info }
-        stub(type_info).zero_terminated? { true }
+        allow(type_info).to receive(:tag).and_return :array
+        allow(type_info).to receive(:param_type).with(0).and_return elmtype_info
+        allow(type_info).to receive(:zero_terminated?).and_return true
       end
 
       describe 'of utf8' do
         it 'returns :strv' do
-          stub(elmtype_info).tag { :utf8 }
-          stub(elmtype_info).pointer? { true }
+          allow(elmtype_info).to receive(:tag).and_return :utf8
+          allow(elmtype_info).to receive(:pointer?).and_return true
 
           type_info.flattened_tag.must_equal :strv
         end
@@ -119,8 +119,8 @@ describe GirFFI::InfoExt::ITypeInfo do
 
       describe 'of filename' do
         it 'returns :strv' do
-          stub(elmtype_info).tag { :filename }
-          stub(elmtype_info).pointer? { true }
+          allow(elmtype_info).to receive(:tag).and_return :filename
+          allow(elmtype_info).to receive(:pointer?).and_return true
 
           type_info.flattened_tag.must_equal :strv
         end
@@ -128,8 +128,8 @@ describe GirFFI::InfoExt::ITypeInfo do
 
       describe 'of another type' do
         it 'returns :zero_terminated' do
-          stub(elmtype_info).tag { :foo }
-          stub(elmtype_info).pointer? { false }
+          allow(elmtype_info).to receive(:tag).and_return :foo
+          allow(elmtype_info).to receive(:pointer?).and_return false
 
           type_info.flattened_tag.must_equal :zero_terminated
         end
@@ -138,9 +138,9 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for a fixed length c-like array' do
       it 'returns :c' do
-        mock(type_info).tag { :array }
-        mock(type_info).zero_terminated? { false }
-        mock(type_info).array_type { :c }
+        expect(type_info).to receive(:tag).and_return :array
+        expect(type_info).to receive(:zero_terminated?).and_return false
+        expect(type_info).to receive(:array_type).and_return :c
 
         type_info.flattened_tag.must_equal :c
       end
@@ -148,9 +148,9 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for a GLib array' do
       it 'returns :c' do
-        mock(type_info).tag { :array }
-        mock(type_info).zero_terminated? { false }
-        mock(type_info).array_type { :array }
+        expect(type_info).to receive(:tag).and_return :array
+        expect(type_info).to receive(:zero_terminated?).and_return false
+        expect(type_info).to receive(:array_type).and_return :array
 
         type_info.flattened_tag.must_equal :array
       end
@@ -160,8 +160,8 @@ describe GirFFI::InfoExt::ITypeInfo do
   describe '#tag_or_class' do
     describe 'for a simple type' do
       it "returns the type's tag" do
-        stub(type_info).tag { :foo }
-        mock(type_info).pointer? { false }
+        allow(type_info).to receive(:tag).and_return :foo
+        expect(type_info).to receive(:pointer?).and_return false
 
         type_info.tag_or_class.must_equal :foo
       end
@@ -169,8 +169,8 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for utf8 strings' do
       it 'returns the tag :utf8' do
-        stub(type_info).tag { :utf8 }
-        mock(type_info).pointer? { true }
+        allow(type_info).to receive(:tag).and_return :utf8
+        expect(type_info).to receive(:pointer?).and_return true
 
         type_info.tag_or_class.must_equal :utf8
       end
@@ -178,8 +178,8 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for filename strings' do
       it 'returns the tag :filename' do
-        stub(type_info).tag { :filename }
-        mock(type_info).pointer? { true }
+        allow(type_info).to receive(:tag).and_return :filename
+        expect(type_info).to receive(:pointer?).and_return true
 
         type_info.tag_or_class.must_equal :filename
       end
@@ -189,16 +189,16 @@ describe GirFFI::InfoExt::ITypeInfo do
       let(:interface) { Object.new }
 
       before do
-        stub(type_info).tag { :interface }
-        stub(type_info).interface { iface_info }
-        mock(type_info).pointer? { false }
+        allow(type_info).to receive(:tag).and_return :interface
+        allow(type_info).to receive(:interface).and_return iface_info
+        expect(type_info).to receive(:pointer?).and_return false
 
-        mock(GirFFI::Builder).build_class(iface_info) { interface }
+        expect(GirFFI::Builder).to receive(:build_class).with(iface_info).and_return interface
       end
 
       describe 'when the interface type is :enum' do
         it 'returns the built interface module' do
-          stub(iface_info).info_type { :enum }
+          allow(iface_info).to receive(:info_type).and_return :enum
 
           type_info.tag_or_class.must_equal interface
         end
@@ -206,7 +206,7 @@ describe GirFFI::InfoExt::ITypeInfo do
 
       describe 'when the interface type is :object' do
         it 'returns the built interface class' do
-          stub(iface_info).info_type { :object }
+          allow(iface_info).to receive(:info_type).and_return :object
 
           type_info.tag_or_class.must_equal interface
         end
@@ -214,12 +214,11 @@ describe GirFFI::InfoExt::ITypeInfo do
 
       describe 'when the interface type is :struct' do
         it 'returns the built interface class' do
-          stub(iface_info).info_type { :struct }
+          allow(iface_info).to receive(:info_type).and_return :struct
 
           type_info.tag_or_class.must_equal interface
         end
       end
-
     end
 
     describe 'for a callback' do
@@ -230,8 +229,8 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for a pointer to simple type :foo' do
       it 'returns [:pointer, :foo]' do
-        stub(type_info).tag { :foo }
-        mock(type_info).pointer? { true }
+        allow(type_info).to receive(:tag).and_return :foo
+        expect(type_info).to receive(:pointer?).and_return true
 
         type_info.tag_or_class.must_equal [:pointer, :foo]
       end
@@ -239,8 +238,8 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for a pointer to :void' do
       it 'returns [:pointer, :void]' do
-        stub(type_info).tag { :void }
-        stub(type_info).pointer? { true }
+        allow(type_info).to receive(:tag).and_return :void
+        allow(type_info).to receive(:pointer?).and_return true
 
         type_info.tag_or_class.must_equal [:pointer, :void]
       end
@@ -258,24 +257,24 @@ describe GirFFI::InfoExt::ITypeInfo do
     end
   end
 
-  describe '#to_callback_ffitype' do
+  describe '#to_callback_ffi_type' do
     describe 'for an :interface argument' do
       before do
-        stub(type_info).interface { iface_info }
-        stub(type_info).tag { :interface }
-        stub(type_info).pointer? { false }
+        allow(type_info).to receive(:interface).and_return iface_info
+        allow(type_info).to receive(:tag).and_return :interface
+        allow(type_info).to receive(:pointer?).and_return false
       end
 
       it 'correctly maps a :union argument to :pointer' do
-        stub(iface_info).info_type { :union }
+        allow(iface_info).to receive(:info_type).and_return :union
 
-        type_info.to_callback_ffitype.must_equal :pointer
+        type_info.to_callback_ffi_type.must_equal :pointer
       end
 
       it 'correctly maps a :flags argument to :int32' do
-        stub(iface_info).info_type { :flags }
+        allow(iface_info).to receive(:info_type).and_return :flags
 
-        type_info.to_callback_ffitype.must_equal :int32
+        type_info.to_callback_ffi_type.must_equal :int32
       end
     end
   end
@@ -283,7 +282,7 @@ describe GirFFI::InfoExt::ITypeInfo do
   describe '#extra_conversion_arguments' do
     describe 'for normal types' do
       before do
-        stub(type_info).tag { :foo }
+        allow(type_info).to receive(:tag).and_return :foo
       end
 
       it 'returns an empty array' do
@@ -293,7 +292,7 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for a string' do
       before do
-        stub(type_info).tag { :utf8 }
+        allow(type_info).to receive(:tag).and_return :utf8
       end
 
       it 'returns an array containing :utf8' do
@@ -303,13 +302,13 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for a fixed-size array' do
       before do
-        stub(type_info).tag { :array }
-        stub(type_info).zero_terminated? { false }
-        stub(type_info).array_type { :c }
-        stub(type_info).array_fixed_size { 3 }
+        allow(type_info).to receive(:tag).and_return :array
+        allow(type_info).to receive(:zero_terminated?).and_return false
+        allow(type_info).to receive(:array_type).and_return :c
+        allow(type_info).to receive(:array_fixed_size).and_return 3
 
-        stub(type_info).param_type(0) { elmtype_info }
-        stub(elmtype_info).tag_or_class { :foo }
+        allow(type_info).to receive(:param_type).with(0).and_return elmtype_info
+        allow(elmtype_info).to receive(:tag_or_class).and_return :foo
       end
 
       it 'returns an array containing the element type' do
@@ -319,11 +318,11 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for a zero-terminated array' do
       before do
-        stub(type_info).tag { :array }
-        stub(type_info).zero_terminated? { true }
+        allow(type_info).to receive(:tag).and_return :array
+        allow(type_info).to receive(:zero_terminated?).and_return true
 
-        stub(type_info).param_type(0) { elmtype_info }
-        stub(elmtype_info).tag_or_class { :foo }
+        allow(type_info).to receive(:param_type).with(0).and_return elmtype_info
+        allow(elmtype_info).to receive(:tag_or_class).and_return :foo
       end
 
       it 'returns an array containing the element type' do
@@ -333,12 +332,12 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for a GArray' do
       before do
-        stub(type_info).tag { :array }
-        stub(type_info).zero_terminated? { false }
-        stub(type_info).array_type { :array }
+        allow(type_info).to receive(:tag).and_return :array
+        allow(type_info).to receive(:zero_terminated?).and_return false
+        allow(type_info).to receive(:array_type).and_return :array
 
-        stub(type_info).param_type(0) { elmtype_info }
-        stub(elmtype_info).tag_or_class { :foo }
+        allow(type_info).to receive(:param_type).with(0).and_return elmtype_info
+        allow(elmtype_info).to receive(:tag_or_class).and_return :foo
       end
 
       it 'returns an array containing the element type' do
@@ -348,12 +347,12 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for a GHashTable' do
       before do
-        stub(type_info).tag { :ghash }
-        stub(type_info).param_type(0) { keytype_info }
-        stub(type_info).param_type(1) { valtype_info }
+        allow(type_info).to receive(:tag).and_return :ghash
+        allow(type_info).to receive(:param_type).with(0).and_return keytype_info
+        allow(type_info).to receive(:param_type).with(1).and_return valtype_info
 
-        stub(keytype_info).tag_or_class { :foo }
-        stub(valtype_info).tag_or_class { :bar }
+        allow(keytype_info).to receive(:tag_or_class).and_return :foo
+        allow(valtype_info).to receive(:tag_or_class).and_return :bar
       end
 
       it 'returns an array containing the element type pair' do
@@ -363,10 +362,10 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for a GList' do
       before do
-        stub(type_info).tag { :glist }
+        allow(type_info).to receive(:tag).and_return :glist
 
-        stub(type_info).param_type(0) { elmtype_info }
-        stub(elmtype_info).tag_or_class { :foo }
+        allow(type_info).to receive(:param_type).with(0).and_return elmtype_info
+        allow(elmtype_info).to receive(:tag_or_class).and_return :foo
       end
 
       it 'returns an array containing the element type' do
@@ -376,10 +375,10 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for a GSList' do
       before do
-        stub(type_info).tag { :gslist }
+        allow(type_info).to receive(:tag).and_return :gslist
 
-        stub(type_info).param_type(0) { elmtype_info }
-        stub(elmtype_info).tag_or_class { :foo }
+        allow(type_info).to receive(:param_type).with(0).and_return elmtype_info
+        allow(elmtype_info).to receive(:tag_or_class).and_return :foo
       end
 
       it 'returns an array containing the element type' do
@@ -389,12 +388,12 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for a GPtrArray' do
       before do
-        stub(type_info).tag { :array }
-        stub(type_info).zero_terminated? { false }
-        stub(type_info).array_type { :ptr_array }
+        allow(type_info).to receive(:tag).and_return :array
+        allow(type_info).to receive(:zero_terminated?).and_return false
+        allow(type_info).to receive(:array_type).and_return :ptr_array
 
-        stub(type_info).param_type(0) { elmtype_info }
-        stub(elmtype_info).tag_or_class { :foo }
+        allow(type_info).to receive(:param_type).with(0).and_return elmtype_info
+        allow(elmtype_info).to receive(:tag_or_class).and_return :foo
       end
 
       it 'returns an array containing the element type' do
@@ -404,11 +403,11 @@ describe GirFFI::InfoExt::ITypeInfo do
 
     describe 'for a :callback' do
       before do
-        stub(interface_type_info = Object.new).namespace { 'Bar' }
-        stub(interface_type_info).name { 'Foo' }
+        allow(interface_type_info = Object.new).to receive(:namespace).and_return 'Bar'
+        allow(interface_type_info).to receive(:name).and_return 'Foo'
 
-        stub(type_info).tag { :callback }
-        stub(type_info).interface { interface_type_info }
+        allow(type_info).to receive(:tag).and_return :callback
+        allow(type_info).to receive(:interface).and_return interface_type_info
       end
 
       it 'returns an empty array' do
@@ -419,7 +418,7 @@ describe GirFFI::InfoExt::ITypeInfo do
 
   describe '#argument_class_name' do
     before do
-      stub(type_info).tag { tag }
+      allow(type_info).to receive(:tag).and_return tag
     end
 
     describe 'for :gint32' do
@@ -434,9 +433,9 @@ describe GirFFI::InfoExt::ITypeInfo do
       let(:tag) { :interface }
 
       before do
-        stub(type_info).interface { iface_info }
-        stub(iface_info).info_type { interface_type }
-        stub(iface_info).full_type_name { 'Bar::Foo' }
+        allow(type_info).to receive(:interface).and_return iface_info
+        allow(iface_info).to receive(:info_type).and_return interface_type
+        allow(iface_info).to receive(:full_type_name).and_return 'Bar::Foo'
       end
 
       describe 'for :struct' do
@@ -489,13 +488,13 @@ describe GirFFI::InfoExt::ITypeInfo do
     describe 'for arrays' do
       let(:tag) { :array }
       before do
-        stub(type_info).param_type(0) { elmtype_info }
-        stub(elmtype_info).tag_or_class { :foo }
+        allow(type_info).to receive(:param_type).with(0).and_return elmtype_info
+        allow(elmtype_info).to receive(:tag_or_class).and_return :foo
       end
 
       describe 'for :zero_terminated' do
         before do
-          stub(type_info).zero_terminated? { true }
+          allow(type_info).to receive(:zero_terminated?).and_return true
         end
 
         it 'equals GirFFI::ZeroTerminated' do
@@ -505,8 +504,8 @@ describe GirFFI::InfoExt::ITypeInfo do
 
       describe 'for :byte_array' do
         before do
-          stub(type_info).zero_terminated? { false }
-          stub(type_info).array_type { :byte_array }
+          allow(type_info).to receive(:zero_terminated?).and_return false
+          allow(type_info).to receive(:array_type).and_return :byte_array
         end
 
         it 'equals GLib::ByteArray' do
@@ -516,8 +515,8 @@ describe GirFFI::InfoExt::ITypeInfo do
 
       describe 'for :ptr_array' do
         before do
-          stub(type_info).zero_terminated? { false }
-          stub(type_info).array_type { :ptr_array }
+          allow(type_info).to receive(:zero_terminated?).and_return false
+          allow(type_info).to receive(:array_type).and_return :ptr_array
         end
 
         it 'equals GLib::PtrArray' do
@@ -527,8 +526,8 @@ describe GirFFI::InfoExt::ITypeInfo do
 
       describe 'for :array' do
         before do
-          stub(type_info).zero_terminated? { false }
-          stub(type_info).array_type { :array }
+          allow(type_info).to receive(:zero_terminated?).and_return false
+          allow(type_info).to receive(:array_type).and_return :array
         end
 
         it 'equals GLib::Array' do
@@ -572,8 +571,8 @@ describe GirFFI::InfoExt::ITypeInfo do
 
   describe '#g_type' do
     before do
-      stub(type_info).tag { tag }
-      stub(type_info).pointer? { pointer? }
+      allow(type_info).to receive(:tag).and_return tag
+      allow(type_info).to receive(:pointer?).and_return pointer?
     end
 
     describe 'for :void' do
@@ -645,8 +644,8 @@ describe GirFFI::InfoExt::ITypeInfo do
 
       describe 'for pointer to GArray' do
         before do
-          stub(type_info).zero_terminated? { false }
-          stub(type_info).array_type { :array }
+          allow(type_info).to receive(:zero_terminated?).and_return false
+          allow(type_info).to receive(:array_type).and_return :array
         end
 
         it 'equals the GArray type' do
@@ -656,8 +655,8 @@ describe GirFFI::InfoExt::ITypeInfo do
 
       describe 'for a C array' do
         before do
-          stub(type_info).zero_terminated? { false }
-          stub(type_info).array_type { :c }
+          allow(type_info).to receive(:zero_terminated?).and_return false
+          allow(type_info).to receive(:array_type).and_return :c
         end
 
         it 'equals the gpointer type' do
@@ -667,14 +666,14 @@ describe GirFFI::InfoExt::ITypeInfo do
 
       describe 'for a zero-terminated array' do
         before do
-          stub(type_info).param_type(0) { elmtype_info }
-          stub(type_info).zero_terminated? { true }
+          allow(type_info).to receive(:param_type).with(0).and_return elmtype_info
+          allow(type_info).to receive(:zero_terminated?).and_return true
         end
 
         describe 'of utf8' do
           it 'equals the GStrv type' do
-            stub(elmtype_info).tag { :utf8 }
-            stub(elmtype_info).pointer? { true }
+            allow(elmtype_info).to receive(:tag).and_return :utf8
+            allow(elmtype_info).to receive(:pointer?).and_return true
 
             GObject.type_name(type_info.g_type).must_equal 'GStrv'
           end
@@ -682,8 +681,8 @@ describe GirFFI::InfoExt::ITypeInfo do
 
         describe 'of filename' do
           it 'equals the GStrv type' do
-            stub(elmtype_info).tag { :filename }
-            stub(elmtype_info).pointer? { true }
+            allow(elmtype_info).to receive(:tag).and_return :filename
+            allow(elmtype_info).to receive(:pointer?).and_return true
 
             GObject.type_name(type_info.g_type).must_equal 'GStrv'
           end