gir_ffi 0.14.0 → 0.15.3

data/test/gir_ffi/info_ext/i_unresolved_info_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::InfoExt::IUnresolvedInfo do
   let(:info_class) do
@@ -11,9 +11,9 @@ describe GirFFI::InfoExt::IUnresolvedInfo do
 
   let(:unresolved_info) { info_class.new }
 
-  describe '#to_ffi_type' do
-    it 'returns the most generic type' do
-      unresolved_info.to_ffi_type.must_equal :pointer
+  describe "#to_ffi_type" do
+    it "returns the most generic type" do
+      _(unresolved_info.to_ffi_type).must_equal :pointer
     end
   end
 end

data/test/gir_ffi/info_ext/safe_constant_name_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::InfoExt::SafeConstantName do
   let(:info_class) do
@@ -10,17 +10,17 @@ describe GirFFI::InfoExt::SafeConstantName do
   end
   let(:info) { info_class.new }
 
-  describe '#safe_name' do
-    it 'makes names starting with an underscore safe' do
-      expect(info).to receive(:name).and_return '_foo'
+  describe "#safe_name" do
+    it "makes names starting with an underscore safe" do
+      expect(info).to receive(:name).and_return "_foo"
 
-      assert_equal 'Private___foo', info.safe_name
+      assert_equal "Private___foo", info.safe_name
     end
 
-    it 'makes names with dashes safe' do
-      expect(info).to receive(:name).and_return 'this-could-be-a-signal-name'
+    it "makes names with dashes safe" do
+      expect(info).to receive(:name).and_return "this-could-be-a-signal-name"
 
-      info.safe_name.must_equal 'This_could_be_a_signal_name'
+      _(info.safe_name).must_equal "This_could_be_a_signal_name"
     end
   end
 end

data/test/gir_ffi/info_ext/safe_function_name_test.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::InfoExt::SafeFunctionName do
   let(:info_class) do
@@ -10,17 +10,17 @@ describe GirFFI::InfoExt::SafeFunctionName do
   end
   let(:info) { info_class.new }
 
-  describe '#safe_name' do
-    it 'keeps lower case names lower case' do
-      expect(info).to receive(:name).and_return 'foo'
+  describe "#safe_name" do
+    it "keeps lower case names lower case" do
+      expect(info).to receive(:name).and_return "foo"
 
-      assert_equal 'foo', info.safe_name
+      assert_equal "foo", info.safe_name
     end
 
-    it 'returns a non-empty string if name is empty' do
-      expect(info).to receive(:name).and_return ''
+    it "returns a non-empty string if name is empty" do
+      expect(info).to receive(:name).and_return ""
 
-      assert_equal '_', info.safe_name
+      assert_equal "_", info.safe_name
     end
   end
 end

data/test/gir_ffi/interface_base_test.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::InterfaceBase do
   let(:interface) { Module.new { extend GirFFI::InterfaceBase } }
 
-  describe '#wrap' do
-    it 'delegates conversion to the wrapped pointer' do
-      expect(ptr = Object.new).to receive(:to_object).and_return 'good-result'
-      interface.wrap(ptr).must_equal 'good-result'
+  describe "#wrap" do
+    it "delegates conversion to the wrapped pointer" do
+      expect(ptr = Object.new).to receive(:to_object).and_return "good-result"
+      _(interface.wrap(ptr)).must_equal "good-result"
     end
   end
 
-  describe '.to_ffi_type' do
-    it 'returns :pointer' do
-      interface.to_ffi_type.must_equal :pointer
+  describe ".to_ffi_type" do
+    it "returns :pointer" do
+      _(interface.to_ffi_type).must_equal :pointer
     end
   end
 end

data/test/gir_ffi/method_stubber_test.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::MethodStubber do
-  describe '#method_stub' do
+  describe "#method_stub" do
     let(:stubber) { GirFFI::MethodStubber.new(method_info) }
     let(:result) { stubber.method_stub }
 
-    describe 'for a regular method' do
+    describe "for a regular method" do
       let(:method_info) do
-        get_method_introspection_data('Regress', 'TestObj', 'instance_method')
+        get_method_introspection_data("Regress", "TestObj", "instance_method")
       end
 
-      it 'creates a method stub' do
-        result.must_equal <<-STUB.reset_indentation
+      it "creates a method stub" do
+        _(result).must_equal <<~STUB
           def instance_method *args, &block
             setup_and_call "instance_method", args, &block
           end
@@ -21,13 +21,13 @@ describe GirFFI::MethodStubber do
       end
     end
 
-    describe 'for a static method' do
+    describe "for a static method" do
       let(:method_info) do
-        get_method_introspection_data('Regress', 'TestObj', 'static_method')
+        get_method_introspection_data("Regress", "TestObj", "static_method")
       end
 
-      it 'creates a class method stub' do
-        result.must_equal <<-STUB.reset_indentation
+      it "creates a class method stub" do
+        _(result).must_equal <<~STUB
           def self.static_method *args, &block
             setup_and_call "static_method", args, &block
           end
@@ -35,13 +35,13 @@ describe GirFFI::MethodStubber do
       end
     end
 
-    describe 'for a module function' do
+    describe "for a module function" do
       let(:method_info) do
-        get_introspection_data('Regress', 'test_int')
+        get_introspection_data("Regress", "test_int")
       end
 
-      it 'creates a module method stub' do
-        result.must_equal <<-STUB.reset_indentation
+      it "creates a module method stub" do
+        _(result).must_equal <<~STUB
           def self.test_int *args, &block
             setup_and_call "test_int", args, &block
           end
@@ -49,12 +49,14 @@ describe GirFFI::MethodStubber do
       end
     end
 
-    describe 'for a method with an empty name' do
-      let(:method_info) { get_method_introspection_data('Regress', 'TestObj', 'instance_method') }
+    describe "for a method with an empty name" do
+      let(:method_info) do
+        get_method_introspection_data("Regress", "TestObj", "instance_method")
+      end
 
-      it 'creates a method stub with a safe name that sets up the unsafe method' do
-        allow(method_info).to receive(:name).and_return ''
-        result.must_equal <<-STUB.reset_indentation
+      it "creates a method stub with a safe name that sets up the unsafe method" do
+        allow(method_info).to receive(:name).and_return ""
+        _(result).must_equal <<~STUB
           def _ *args, &block
             setup_and_call "", args, &block
           end

data/test/gir_ffi/object_base_test.rb

@@ -1,38 +1,38 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 GirFFI.setup :Regress
 
 describe GirFFI::ObjectBase do
   let(:derived_class) { Class.new GirFFI::ObjectBase }
 
-  describe '.wrap' do
-    it 'delegates conversion to the wrapped pointer' do
-      expect(ptr = Object.new).to receive(:to_object).and_return 'good-result'
-      derived_class.wrap(ptr).must_equal 'good-result'
+  describe ".wrap" do
+    it "delegates conversion to the wrapped pointer" do
+      expect(ptr = Object.new).to receive(:to_object).and_return "good-result"
+      _(derived_class.wrap(ptr)).must_equal "good-result"
     end
   end
 
-  describe '.to_ffi_type' do
-    it 'returns itself' do
-      derived_class.to_ffi_type.must_equal derived_class
+  describe ".to_ffi_type" do
+    it "returns itself" do
+      _(derived_class.to_ffi_type).must_equal derived_class
     end
   end
 
-  describe '.object_class' do
-    it 'returns an object of the class struct type' do
-      Regress::TestObj.object_class.must_be_instance_of Regress::TestObjClass
+  describe ".object_class" do
+    it "returns an object of the class struct type" do
+      _(Regress::TestObj.object_class).must_be_instance_of Regress::TestObjClass
     end
 
-    it 'caches its result' do
+    it "caches its result" do
       first = Regress::TestObj.object_class
       second = Regress::TestObj.object_class
-      second.must_be :eql?, first
+      _(second).must_be :eql?, first
     end
   end
 
-  describe '#included_interfaces' do
+  describe "#included_interfaces" do
     let(:base_class) { GIMarshallingTests::Object }
     let(:derived_class) { Class.new(base_class) }
 
@@ -40,12 +40,12 @@ describe GirFFI::ObjectBase do
       derived_class.class_eval { include GIMarshallingTests::Interface }
     end
 
-    it 'finds the included interface' do
-      derived_class.included_interfaces.must_equal [GIMarshallingTests::Interface]
+    it "finds the included interface" do
+      _(derived_class.included_interfaces).must_equal [GIMarshallingTests::Interface]
     end
   end
 
-  describe '#registered_ancestors' do
+  describe "#registered_ancestors" do
     let(:base_class) { GIMarshallingTests::Object }
     let(:derived_class) { Class.new(base_class) }
 
@@ -53,12 +53,12 @@ describe GirFFI::ObjectBase do
       derived_class.class_eval { include GIMarshallingTests::Interface }
     end
 
-    it 'finds the ancestor classes and included interface' do
-      derived_class.registered_ancestors.
-        must_equal [derived_class,
-                    GIMarshallingTests::Interface,
-                    GIMarshallingTests::Object,
-                    GObject::Object]
+    it "finds the ancestor classes and included interface" do
+      _(derived_class.registered_ancestors)
+        .must_equal [derived_class,
+                     GIMarshallingTests::Interface,
+                     GIMarshallingTests::Object,
+                     GObject::Object]
     end
   end
 end

data/test/gir_ffi/object_store_test.rb

@@ -1,41 +1,41 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::ObjectStore do
   let(:store) { GirFFI::ObjectStore.new }
 
-  describe '#store' do
-    it 'returns a non-null pointer when storing objects' do
+  describe "#store" do
+    it "returns a non-null pointer when storing objects" do
       obj = Object.new
       ptr = store.store obj
-      ptr.wont_be :null?
+      _(ptr).wont_be :null?
     end
 
-    it 'returns a null pointer when storing nil' do
+    it "returns a null pointer when storing nil" do
       ptr = store.store nil
-      ptr.must_be :null?
+      _(ptr).must_be :null?
     end
   end
 
-  describe '#fetch' do
-    it 'returns the stored object when passed the key pointer' do
+  describe "#fetch" do
+    it "returns the stored object when passed the key pointer" do
       obj = Object.new
       ptr = store.store obj
       result = store.fetch ptr
-      result.must_equal obj
+      _(result).must_equal obj
     end
 
-    it 'returns the nil object when passed a null pointer' do
+    it "returns the nil object when passed a null pointer" do
       ptr = FFI::Pointer.new(0)
       result = store.fetch ptr
-      result.must_be_nil
+      _(result).must_be_nil
     end
 
-    it 'returns the pointer itself when passed an unknown pointer' do
+    it "returns the pointer itself when passed an unknown pointer" do
       ptr = FFI::Pointer.new(42)
       result = store.fetch ptr
-      result.must_equal ptr
+      _(result).must_equal ptr
     end
   end
 end

data/test/gir_ffi/receiver_argument_info_test.rb

@@ -1,33 +1,33 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
-require 'gir_ffi/receiver_argument_info'
+require "gir_ffi_test_helper"
+require "gir_ffi/receiver_argument_info"
 
 describe GirFFI::ReceiverArgumentInfo do
-  let(:dummy_type) { 'foo' }
+  let(:dummy_type) { "foo" }
   let(:instance) { GirFFI::ReceiverArgumentInfo.new dummy_type }
 
-  describe '#argument_type' do
-    it 'returns the argument type' do
-      instance.argument_type.must_equal dummy_type
+  describe "#argument_type" do
+    it "returns the argument type" do
+      _(instance.argument_type).must_equal dummy_type
     end
   end
 
-  describe '#direction' do
-    it 'returns the correct value' do
-      instance.direction.must_equal :in
+  describe "#direction" do
+    it "returns the correct value" do
+      _(instance.direction).must_equal :in
     end
   end
 
-  describe '#ownership_transfer' do
-    it 'returns the correct value' do
-      instance.ownership_transfer.must_equal :everything
+  describe "#ownership_transfer" do
+    it "returns the correct value" do
+      _(instance.ownership_transfer).must_equal :everything
     end
   end
 
-  describe '#name' do
-    it 'returns the correct value' do
-      instance.name.must_equal '_instance'
+  describe "#name" do
+    it "returns the correct value" do
+      _(instance.name).must_equal "_instance"
     end
   end
 end

data/test/gir_ffi/sized_array_test.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::SizedArray do
-  describe '::wrap' do
-    it 'takes a type, size and pointer and returns a GirFFI::SizedArray wrapping them' do
+  describe "::wrap" do
+    it "takes a type, size and pointer and returns a GirFFI::SizedArray wrapping them" do
       expect(ptr = Object.new).to receive(:null?).and_return false
       sarr = GirFFI::SizedArray.wrap :gint32, 3, ptr
       assert_instance_of GirFFI::SizedArray, sarr
@@ -13,15 +13,15 @@ describe GirFFI::SizedArray do
       assert_equal :gint32, sarr.element_type
     end
 
-    it 'returns nil if the wrapped pointer is null' do
+    it "returns nil if the wrapped pointer is null" do
       expect(ptr = Object.new).to receive(:null?).and_return true
       sarr = GirFFI::SizedArray.wrap :gint32, 3, ptr
-      sarr.must_be_nil
+      _(sarr).must_be_nil
     end
   end
 
-  describe '#each' do
-    it 'yields each element' do
+  describe "#each" do
+    it "yields each element" do
       ary = %w(one two three)
       ptrs = ary.map { |a| FFI::MemoryPointer.from_string(a) }
       ptrs << nil
@@ -37,170 +37,170 @@ describe GirFFI::SizedArray do
     end
   end
 
-  describe '::from' do
-    describe 'from a Ruby array' do
-      it 'creates a GirFFI::SizedArray with the same elements' do
+  describe "::from" do
+    describe "from a Ruby array" do
+      it "creates a GirFFI::SizedArray with the same elements" do
         arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
-        arr.must_be_instance_of GirFFI::SizedArray
+        _(arr).must_be_instance_of GirFFI::SizedArray
         assert_equal [3, 2, 1], arr.to_a
       end
 
-      it 'raises an error if the array has the wrong number of elements' do
-        proc { GirFFI::SizedArray.from :gint32, 4, [3, 2, 1] }.must_raise ArgumentError
+      it "raises an error if the array has the wrong number of elements" do
+        _(proc { GirFFI::SizedArray.from :gint32, 4, [3, 2, 1] }).must_raise ArgumentError
       end
 
       it "uses the array's size if passed -1 as the size" do
         arr = GirFFI::SizedArray.from :gint32, -1, [3, 2, 1]
-        arr.size.must_equal 3
+        _(arr.size).must_equal 3
       end
     end
 
-    describe 'from a GirFFI::SizedArray' do
-      it 'return its argument' do
+    describe "from a GirFFI::SizedArray" do
+      it "return its argument" do
         arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
         arr2 = GirFFI::SizedArray.from :gint32, 3, arr
         assert_equal arr, arr2
       end
 
-      it 'raises an error if the argument has the wrong number of elements' do
+      it "raises an error if the argument has the wrong number of elements" do
         arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
-        proc { GirFFI::SizedArray.from :gint32, 4, arr }.must_raise ArgumentError
+        _(proc { GirFFI::SizedArray.from :gint32, 4, arr }).must_raise ArgumentError
       end
     end
 
-    it 'returns nil when passed nil' do
+    it "returns nil when passed nil" do
       arr = GirFFI::SizedArray.from :gint32, 0, nil
-      arr.must_be_nil
+      _(arr).must_be_nil
     end
 
-    it 'wraps its argument if given a pointer' do
+    it "wraps its argument if given a pointer" do
       arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
       arr2 = GirFFI::SizedArray.from :gint32, 3, arr.to_ptr
       assert_instance_of GirFFI::SizedArray, arr2
       refute arr2.equal? arr
-      arr2.to_ptr.must_equal arr.to_ptr
+      _(arr2.to_ptr).must_equal arr.to_ptr
     end
   end
 
-  describe '.copy_from' do
-    describe 'from a Ruby array' do
-      it 'creates an unowned GirFFI::SizedArray with the same elements' do
+  describe ".copy_from" do
+    describe "from a Ruby array" do
+      it "creates an unowned GirFFI::SizedArray with the same elements" do
         arr = GirFFI::SizedArray.copy_from :gint32, 3, [3, 2, 1]
-        arr.must_be_instance_of GirFFI::SizedArray
+        _(arr).must_be_instance_of GirFFI::SizedArray
         assert_equal [3, 2, 1], arr.to_a
-        arr.to_ptr.wont_be :autorelease?
+        _(arr.to_ptr).wont_be :autorelease?
       end
 
-      it 'creates unowned copies of struct pointer elements' do
+      it "creates unowned copies of struct pointer elements" do
         struct = GIMarshallingTests::BoxedStruct.new
         struct.long_ = 2342
-        struct.struct.must_be :owned?
+        _(struct.struct).must_be :owned?
 
         arr = GirFFI::SizedArray.copy_from([:pointer, GIMarshallingTests::BoxedStruct],
                                            1,
                                            [struct])
-        arr.must_be_instance_of GirFFI::SizedArray
-        arr.to_ptr.wont_be :autorelease?
+        _(arr).must_be_instance_of GirFFI::SizedArray
+        _(arr.to_ptr).wont_be :autorelease?
 
         struct_copy = arr.first
-        struct_copy.long_.must_equal struct.long_
-        struct_copy.to_ptr.wont_be :==, struct.to_ptr
-        struct_copy.struct.wont_be :owned?
+        _(struct_copy.long_).must_equal struct.long_
+        _(struct_copy.to_ptr).wont_be :==, struct.to_ptr
+        _(struct_copy.struct).wont_be :owned?
       end
 
-      it 'increases the ref count of object pointer elements' do
+      it "increases the ref count of object pointer elements" do
         obj = GIMarshallingTests::Object.new 42
         arr = GirFFI::SizedArray.copy_from([:pointer, GIMarshallingTests::Object],
                                            -1,
                                            [obj, nil])
-        arr.must_be_instance_of GirFFI::SizedArray
-        arr.to_ptr.wont_be :autorelease?
+        _(arr).must_be_instance_of GirFFI::SizedArray
+        _(arr.to_ptr).wont_be :autorelease?
 
-        arr.to_a.must_equal [obj, nil]
-        object_ref_count(obj).must_equal 2
+        _(arr.to_a).must_equal [obj, nil]
+        _(object_ref_count(obj)).must_equal 2
       end
     end
 
-    describe 'from a GirFFI::SizedArray' do
-      it 'return an unowned copy of its argument' do
+    describe "from a GirFFI::SizedArray" do
+      it "return an unowned copy of its argument" do
         arr = GirFFI::SizedArray.from :gint32, 3, [3, 2, 1]
         arr2 = GirFFI::SizedArray.copy_from :gint32, 3, arr
-        arr.to_ptr.wont_be :==, arr2.to_ptr
-        arr2.to_a.must_equal [3, 2, 1]
-        arr2.to_ptr.wont_be :autorelease?
+        _(arr.to_ptr).wont_be :==, arr2.to_ptr
+        _(arr2.to_a).must_equal [3, 2, 1]
+        _(arr2.to_ptr).wont_be :autorelease?
       end
     end
 
-    it 'returns nil when passed nil' do
+    it "returns nil when passed nil" do
       arr = GirFFI::SizedArray.copy_from :gint32, 0, nil
-      arr.must_be_nil
+      _(arr).must_be_nil
     end
   end
 
-  describe '#==' do
-    it 'returns true when comparing to an array with the same elements' do
+  describe "#==" do
+    it "returns true when comparing to an array with the same elements" do
       sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
 
-      sized.must_be :==, [1, 2, 3]
+      _(sized).must_be :==, [1, 2, 3]
     end
 
-    it 'returns false when comparing to an array with different elements' do
+    it "returns false when comparing to an array with different elements" do
       sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
 
-      sized.wont_be :==, [1, 2]
+      _(sized).wont_be :==, [1, 2]
     end
 
-    it 'returns true when comparing to a sized array with the same elements' do
+    it "returns true when comparing to a sized array with the same elements" do
       sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
       other = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
 
-      sized.must_be :==, other
+      _(sized).must_be :==, other
     end
 
-    it 'returns false when comparing to a sized array with different elements' do
+    it "returns false when comparing to a sized array with different elements" do
       sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
       other = GirFFI::SizedArray.from :int32, 2, [1, 2]
 
-      sized.wont_be :==, other
+      _(sized).wont_be :==, other
     end
   end
 
-  describe '#size_in_bytes' do
-    it 'returns the correct value' do
+  describe "#size_in_bytes" do
+    it "returns the correct value" do
       sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
 
-      sized.size_in_bytes.must_equal 12
+      _(sized.size_in_bytes).must_equal 12
     end
   end
 
-  describe '.get_value_from_pointer' do
-    it 'returns just a pointer' do
+  describe ".get_value_from_pointer" do
+    it "returns just a pointer" do
       sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
       ptr = sized.to_ptr
       result = GirFFI::SizedArray.get_value_from_pointer(ptr, 0)
-      result.must_be :==, ptr
+      _(result).must_be :==, ptr
     end
 
-    it 'offsets correctly' do
+    it "offsets correctly" do
       sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
       ptr = sized.to_ptr
       next_ptr = GirFFI::SizedArray.get_value_from_pointer(ptr, 4)
       tail = GirFFI::SizedArray.from(:int32, 2, next_ptr)
-      tail.must_be :==, [2, 3]
+      _(tail).must_be :==, [2, 3]
     end
   end
 
-  describe '.copy_value_to_pointer' do
-    it 'copies data correctly' do
+  describe ".copy_value_to_pointer" do
+    it "copies data correctly" do
       sized = GirFFI::SizedArray.from :int32, 3, [1, 2, 3]
       target = FFI::MemoryPointer.new sized.size_in_bytes
       GirFFI::SizedArray.copy_value_to_pointer(sized, target)
       result = GirFFI::SizedArray.from :int32, 3, target
-      result.must_be :==, [1, 2, 3]
+      _(result).must_be :==, [1, 2, 3]
     end
   end
 
-  it 'includes Enumerable' do
-    GirFFI::SizedArray.must_include Enumerable
+  it "includes Enumerable" do
+    _(GirFFI::SizedArray).must_include Enumerable
   end
 end