gir_ffi 0.14.0 → 0.15.3

data/test/gir_ffi/callback_base_test.rb

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::CallbackBase do
-  describe '.store_callback' do
-    it 'stores the passed in proc in CALLBACKS' do
-      dummy_proc = 'some-callback'
+  describe ".store_callback" do
+    it "stores the passed in proc in CALLBACKS" do
+      dummy_proc = "some-callback"
       GirFFI::CallbackBase.store_callback dummy_proc
-      GirFFI::CallbackBase::CALLBACKS[dummy_proc.object_id].must_equal dummy_proc
+      _(GirFFI::CallbackBase::CALLBACKS[dummy_proc.object_id]).must_equal dummy_proc
     end
   end
 
-  describe '.drop_callback' do
-    it 'removes the corresponding proc from CALLBACKS' do
-      dummy_proc = 'some-callback'
+  describe ".drop_callback" do
+    it "removes the corresponding proc from CALLBACKS" do
+      dummy_proc = "some-callback"
       GirFFI::CallbackBase.store_callback dummy_proc
       GirFFI::CallbackBase.drop_callback dummy_proc
-      GirFFI::CallbackBase::CALLBACKS[dummy_proc.object_id].must_be_nil
+      _(GirFFI::CallbackBase::CALLBACKS[dummy_proc.object_id]).must_be_nil
     end
   end
 end

data/test/gir_ffi/class_base_test.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::ClassBase do
-  describe 'a simple descendant' do
+  describe "a simple descendant" do
     let(:object_class) do
       Class.new(GirFFI::ClassBase) do
         self::Struct = Class.new(GirFFI::Struct) do
@@ -13,72 +13,73 @@ describe GirFFI::ClassBase do
     end
     let(:object) { object_class.wrap FFI::MemoryPointer.new(:int32) }
 
-    it 'has #from as a pass-through method' do
+    it "has #from as a pass-through method" do
       result = object_class.from :foo
-      result.must_equal :foo
+      _(result).must_equal :foo
     end
 
-    describe '#==' do
-      it 'returns true when comparing to an object of the same class and pointer' do
+    describe "#==" do
+      it "returns true for an object of the same class and pointer" do
         other = object_class.wrap object.to_ptr
 
-        object.must_be :==, other
-        other.must_be :==, object
+        _(object).must_be :==, other
+        _(other).must_be :==, object
       end
 
-      it 'returns true when comparing to an object of the same class and a pointer with the same address' do
+      it "returns true for an object of the same class and pointer with the same address" do
         ptr = FFI::Pointer.new object.to_ptr
         other = object_class.wrap ptr
 
-        object.must_be :==, other
-        other.must_be :==, object
+        _(object).must_be :==, other
+        _(other).must_be :==, object
       end
 
-      it 'returns false when comparing to an object of a sub/superclass and the same pointer' do
+      it "returns false for an object of a sub/superclass and the same pointer" do
         subclass = Class.new(object_class)
         other = subclass.wrap object.to_ptr
 
-        object.wont_be :==, other
-        other.wont_be :==, object
+        _(object).wont_be :==, other
+        _(other).wont_be :==, object
       end
 
-      it 'returns false when comparing to an object of the same class and different pointer' do
+      it "returns false for an object of the same class and different pointer" do
         other = object_class.wrap FFI::MemoryPointer.new(:int32)
 
-        object.wont_be :==, other
-        other.wont_be :==, object
+        _(object).wont_be :==, other
+        _(other).wont_be :==, object
       end
 
-      it "returns false when comparing to an object that doesn't respond to #to_ptr" do
+      it "returns false for an object that doesn't respond to #to_ptr" do
         other = Object.new
 
-        object.wont_be :==, other
-        other.wont_be :==, object
+        _(object).wont_be :==, other
+        _(other).wont_be :==, object
       end
 
-      it 'returns false when comparing to an object of a different class and same pointer' do
+      it "returns false for an object of a different class and same pointer" do
         allow(other = Object.new).to receive(:to_ptr).and_return object.to_ptr
 
-        object.wont_be :==, other
-        other.wont_be :==, object
+        _(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
-        allow(other = Object.new).to receive(:to_ptr).and_return FFI::MemoryPointer.new(:int32)
+      it "returns false for an object of a different class and different pointer" do
+        allow(other = Object.new)
+          .to receive(:to_ptr).and_return FFI::MemoryPointer.new(:int32)
 
-        object.wont_be :==, other
-        other.wont_be :==, object
+        _(object).wont_be :==, other
+        _(other).wont_be :==, object
       end
     end
   end
 
-  describe '.setup_and_call' do
-    it 'looks up class methods in all builders' do
-      expect(builder = Object.new).to receive(:setup_method).with('foo').and_return 'foo'
+  describe ".setup_and_call" do
+    it "looks up class methods in all builders" do
+      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
 
-      expect(sub_builder = Object.new).to receive(:setup_method).with('foo').and_return 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
@@ -87,11 +88,11 @@ describe GirFFI::ClassBase do
       sub_klass.setup_and_call :foo, []
     end
 
-    it 'calls the method given by the result of .setup_method' do
-      expect(builder = Object.new).to receive(:setup_method).with('foo').and_return 'bar'
+    it "calls the method given by the result of .setup_method" do
+      expect(builder = Object.new).to receive(:setup_method).with("foo").and_return "bar"
       klass = Class.new GirFFI::ClassBase do
         def self.bar
-          'correct-result'
+          "correct-result"
         end
 
         def initialize; end
@@ -99,29 +100,30 @@ describe GirFFI::ClassBase do
       klass.const_set :GIR_FFI_BUILDER, builder
 
       result = klass.setup_and_call :foo, []
-      result.must_equal 'correct-result'
+      _(result).must_equal "correct-result"
     end
 
-    it 'raises a sensible error if the method is not found' do
-      expect(builder = Object.new).to receive(:setup_method).with('foo').and_return nil
+    it "raises a sensible error if the method is not found" do
+      expect(builder = Object.new).to receive(:setup_method).with("foo").and_return nil
       klass = Class.new GirFFI::ClassBase do
         def initialize; end
       end
       klass.const_set :GIR_FFI_BUILDER, builder
 
-      proc { klass.setup_and_call :foo, [] }.
-        must_raise(NoMethodError).message.
-        must_match(/^undefined method `foo' for/)
+      exception = _(proc { klass.setup_and_call :foo, [] }).must_raise(NoMethodError)
+      _(exception.message).must_match(/^undefined method `foo' for/)
     end
   end
 
-  describe '#setup_and_call' do
-    it 'looks up instance methods in all builders' do
-      expect(builder = Object.new).to receive(:setup_instance_method).with('foo').and_return 'foo'
+  describe "#setup_and_call" do
+    it "looks up instance methods in all builders" do
+      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
 
-      expect(sub_builder = Object.new).to receive(:setup_instance_method).with('foo').and_return 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
 
@@ -134,11 +136,12 @@ describe GirFFI::ClassBase do
       obj.setup_and_call :foo, []
     end
 
-    it 'calls the method given by the result of .setup_instance_method' do
-      expect(builder = Object.new).to receive(:setup_instance_method).with('foo').and_return 'bar'
+    it "calls the method given by the result of .setup_instance_method" do
+      expect(builder = Object.new)
+        .to receive(:setup_instance_method).with("foo").and_return "bar"
       klass = Class.new GirFFI::ClassBase do
         def bar
-          'correct-result'
+          "correct-result"
         end
 
         def initialize; end
@@ -148,11 +151,12 @@ describe GirFFI::ClassBase do
       obj = klass.new
 
       result = obj.setup_and_call :foo, []
-      result.must_equal 'correct-result'
+      _(result).must_equal "correct-result"
     end
 
-    it 'raises a sensible error if the method is not found' do
-      expect(builder = Object.new).to receive(:setup_instance_method).with('foo').and_return nil
+    it "raises a sensible error if the method is not found" do
+      expect(builder = Object.new)
+        .to receive(:setup_instance_method).with("foo").and_return nil
       klass = Class.new GirFFI::ClassBase do
         def initialize; end
       end
@@ -160,9 +164,8 @@ describe GirFFI::ClassBase do
 
       obj = klass.new
 
-      proc { obj.setup_and_call :foo, [] }.
-        must_raise(NoMethodError).message.
-        must_match(/^undefined method `foo' for/)
+      exception = _(proc { obj.setup_and_call :foo, [] }).must_raise(NoMethodError)
+      _(exception.message).must_match(/^undefined method `foo' for/)
     end
   end
 end

data/test/gir_ffi/core_test.rb

@@ -1,97 +1,98 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 GirFFI.setup :GIMarshallingTests
 
 describe GirFFI::Core do
-  it 'sets up cairo as Cairo' do
+  it "sets up cairo as Cairo" do
     GirFFI.setup :cairo
     assert Object.const_defined?(:Cairo)
   end
 
-  it 'sets up xlib, which has no shared library' do
+  it "sets up xlib, which has no shared library" do
     gir = GObjectIntrospection::IRepository.default
-    gir.require 'xlib'
-    assert_nil gir.shared_library('xlib'), 'Precondition for test failed'
+    gir.require "xlib"
+    assert_nil gir.shared_library("xlib"), "Precondition for test failed"
     GirFFI.setup :xlib
   end
 
-  it 'sets up dependencies' do
-    save_module :GObject
+  it "sets up dependencies" do
+    save_module :Utility
     save_module :Regress
+    refute Object.const_defined?(:Utility)
     GirFFI.setup :Regress
-    assert Object.const_defined?(:GObject)
+    assert Object.const_defined?(:Utility)
     restore_module :Regress
-    restore_module :GObject
+    restore_module :Utility
   end
 
-  describe '.setup' do
-    it 'passes the desired version down to the module builder' do
-      expect(GirFFI::Builder).to receive(:build_module).with('Regress', '0.1')
-      GirFFI.setup :Regress, '0.1'
+  describe ".setup" do
+    it "passes the desired version down to the module builder" do
+      expect(GirFFI::Builder).to receive(:build_module).with("Regress", "0.1")
+      GirFFI.setup :Regress, "0.1"
     end
   end
 
-  describe '::define_type' do
-    describe 'without a block' do
+  describe "::define_type" do
+    describe "without a block" do
       before do
         @klass = Class.new GIMarshallingTests::OverridesObject
         Object.const_set "DerivedA#{Sequence.next}", @klass
         @gtype = GirFFI.define_type @klass
       end
 
-      it 'returns a GType for the derived class' do
+      it "returns a GType for the derived class" do
         parent_gtype = GIMarshallingTests::OverridesObject.gtype
-        @gtype.wont_equal parent_gtype
-        GObject.type_name(@gtype).must_equal @klass.name
+        _(@gtype).wont_equal parent_gtype
+        _(GObject.type_name(@gtype)).must_equal @klass.name
       end
 
-      it 'makes #gtype on the registered class return the new GType' do
-        @klass.gtype.must_equal @gtype
+      it "makes #gtype on the registered class return the new GType" do
+        _(@klass.gtype).must_equal @gtype
       end
 
-      it 'registers a type with the same size as the parent' do
+      it "registers a type with the same size as the parent" do
         q = GObject.type_query @gtype
-        q.instance_size.must_equal GIMarshallingTests::OverridesObject::Struct.size
+        _(q.instance_size).must_equal GIMarshallingTests::OverridesObject::Struct.size
       end
 
-      it 'creates a struct class for the derived class with just one member' do
-        @klass::Struct.members.must_equal [:parent]
+      it "creates a struct class for the derived class with just one member" do
+        _(@klass::Struct.members).must_equal [:parent]
       end
 
-      it 'allows the new class to be instantiated' do
+      it "allows the new class to be instantiated" do
         obj = @klass.new
         type = GObject.type_from_instance obj
-        type.must_equal @gtype
+        _(type).must_equal @gtype
       end
     end
 
-    describe 'with a block with a call to #install_property' do
+    describe "with a block with a call to #install_property" do
       before do
         @klass = Class.new GIMarshallingTests::OverridesObject
         Object.const_set "DerivedB#{Sequence.next}", @klass
         @gtype = GirFFI.define_type @klass do |info|
-          info.install_property GObject.param_spec_int('foo', 'foo bar',
-                                                       'The Foo Bar Property',
+          info.install_property GObject.param_spec_int("foo", "foo bar",
+                                                       "The Foo Bar Property",
                                                        10, 20, 15,
                                                        3)
         end
       end
 
-      it 'registers a type that is bigger than the parent' do
+      it "registers a type that is bigger than the parent" do
         q = GObject.type_query @gtype
-        q.instance_size.must_be :>, GIMarshallingTests::OverridesObject::Struct.size
+        _(q.instance_size).must_be :>, GIMarshallingTests::OverridesObject::Struct.size
       end
 
-      it 'gives the types Struct the fields :parent and :foo' do
-        @klass::Struct.members.must_equal [:parent, :foo]
+      it "gives the types Struct the fields :parent and :foo" do
+        _(@klass::Struct.members).must_equal [:parent, :foo]
       end
 
-      it 'creates accessor functions for the property' do
+      it "creates accessor functions for the property" do
         obj = @klass.new
         obj.foo = 13
-        obj.foo.must_equal 13
+        _(obj.foo).must_equal 13
       end
     end
   end

data/test/gir_ffi/enum_base_test.rb

@@ -1,43 +1,43 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 GirFFI.setup :Regress
 
 describe GirFFI::EnumBase do
-  describe '.wrap' do
-    it 'converts an integer to a symbol if possible' do
-      Regress::TestEnum.wrap(1).must_equal :value2
+  describe ".wrap" do
+    it "converts an integer to a symbol if possible" do
+      _(Regress::TestEnum.wrap(1)).must_equal :value2
     end
 
-    it 'passes an integer if it cannot be converted' do
-      Regress::TestEnum.wrap(32).must_equal 32
+    it "passes an integer if it cannot be converted" do
+      _(Regress::TestEnum.wrap(32)).must_equal 32
     end
 
-    it 'passes a known symbol untouched' do
-      Regress::TestEnum.wrap(:value1).must_equal :value1
+    it "passes a known symbol untouched" do
+      _(Regress::TestEnum.wrap(:value1)).must_equal :value1
     end
 
-    it 'passes an unknown symbol untouched' do
-      Regress::TestEnum.wrap(:foo).must_equal :foo
+    it "passes an unknown symbol untouched" do
+      _(Regress::TestEnum.wrap(:foo)).must_equal :foo
     end
   end
 
-  describe '.to_int' do
-    it 'passes a known integer untouched' do
-      Regress::TestEnum.to_int(1).must_equal 1
+  describe ".to_int" do
+    it "passes a known integer untouched" do
+      _(Regress::TestEnum.to_int(1)).must_equal 1
     end
 
-    it 'passes an unknown integer untouched' do
-      Regress::TestEnum.to_int(32).must_equal 32
+    it "passes an unknown integer untouched" do
+      _(Regress::TestEnum.to_int(32)).must_equal 32
     end
 
-    it 'convertes a known symbol to an integer' do
-      Regress::TestEnum.to_int(:value1).must_equal 0
+    it "convertes a known symbol to an integer" do
+      _(Regress::TestEnum.to_int(:value1)).must_equal 0
     end
 
-    it 'raises an error for an unknown symbol' do
-      -> { Regress::TestEnum.to_int(:foo) }.must_raise ArgumentError
+    it "raises an error for an unknown symbol" do
+      _(-> { Regress::TestEnum.to_int(:foo) }).must_raise ArgumentError
     end
   end
 end

data/test/gir_ffi/error_type_info_test.rb

@@ -1,50 +1,50 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
-require 'gir_ffi/error_type_info'
+require "gir_ffi_test_helper"
+require "gir_ffi/error_type_info"
 
 describe GirFFI::ErrorTypeInfo do
   let(:instance) { GirFFI::ErrorTypeInfo.new }
 
-  describe '#array_length' do
-    it 'returns the correct value' do
-      instance.array_length.must_equal(-1)
+  describe "#array_length" do
+    it "returns the correct value" do
+      _(instance.array_length).must_equal(-1)
     end
   end
 
-  describe '#tag_or_class' do
-    it 'returns the correct value' do
-      instance.tag_or_class.must_equal [:pointer, :error]
+  describe "#tag_or_class" do
+    it "returns the correct value" do
+      _(instance.tag_or_class).must_equal [:pointer, :error]
     end
   end
 
-  describe '#pointer?' do
-    it 'returns the correct value' do
-      instance.pointer?.must_equal true
+  describe "#pointer?" do
+    it "returns the correct value" do
+      _(instance.pointer?).must_equal true
     end
   end
 
-  describe '#flattened_tag' do
-    it 'returns the correct value' do
-      instance.flattened_tag.must_equal :error
+  describe "#flattened_tag" do
+    it "returns the correct value" do
+      _(instance.flattened_tag).must_equal :error
     end
   end
 
-  describe '#extra_conversion_arguments' do
-    it 'returns the correct value' do
-      instance.extra_conversion_arguments.must_equal []
+  describe "#extra_conversion_arguments" do
+    it "returns the correct value" do
+      _(instance.extra_conversion_arguments).must_equal []
     end
   end
 
-  describe '#argument_class_name' do
-    it 'returns the correct value' do
-      instance.argument_class_name.must_equal 'GLib::Error'
+  describe "#argument_class_name" do
+    it "returns the correct value" do
+      _(instance.argument_class_name).must_equal "GLib::Error"
     end
   end
 
-  describe '#needs_ruby_to_c_conversion_for_callbacks?' do
-    it 'returns the correct value' do
-      instance.needs_ruby_to_c_conversion_for_callbacks?.must_equal true
+  describe "#needs_ruby_to_c_conversion_for_callbacks?" do
+    it "returns the correct value" do
+      _(instance.needs_ruby_to_c_conversion_for_callbacks?).must_equal true
     end
   end
 end