gir_ffi 0.14.1 → 0.15.0

data/test/gir_ffi/user_defined_object_info_test.rb

@@ -1,53 +1,53 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
-require 'gir_ffi/user_defined_object_info'
+require "gir_ffi_test_helper"
+require "gir_ffi/user_defined_object_info"
 
 GirFFI.setup :GIMarshallingTests
 
 describe GirFFI::UserDefinedObjectInfo do
-  describe '#described_class' do
+  describe "#described_class" do
     let(:info) { GirFFI::UserDefinedObjectInfo.new :some_class }
 
-    it 'returns the class passed to #initialize' do
-      info.described_class.must_equal :some_class
+    it "returns the class passed to #initialize" do
+      _(info.described_class).must_equal :some_class
     end
   end
 
-  describe '#install_property' do
+  describe "#install_property" do
     let(:info) { GirFFI::UserDefinedObjectInfo.new :some_class }
     let(:foo_spec) { Object.new }
 
-    it 'adds the passed in property to the list of properties' do
+    it "adds the passed in property to the list of properties" do
       info.install_property foo_spec
-      info.properties.must_equal [foo_spec]
+      _(info.properties).must_equal [foo_spec]
     end
   end
 
-  describe '#install_vfunc_implementation' do
+  describe "#install_vfunc_implementation" do
     let(:info) { GirFFI::UserDefinedObjectInfo.new :some_class }
     let(:implementation) { Object.new }
 
-    it 'adds to the list of vfunc implementations' do
-      info.vfunc_implementations.must_equal []
+    it "adds to the list of vfunc implementations" do
+      _(info.vfunc_implementations).must_equal []
       info.install_vfunc_implementation :foo, implementation
-      info.vfunc_implementations.map(&:name).must_equal [:foo]
+      _(info.vfunc_implementations.map(&:name)).must_equal [:foo]
     end
 
-    it 'stores the passed-in implementation in the implementation object' do
+    it "stores the passed-in implementation in the implementation object" do
       info.install_vfunc_implementation :foo, implementation
       impl = info.vfunc_implementations.first
-      impl.implementation.must_equal implementation
+      _(impl.implementation).must_equal implementation
     end
 
-    it 'provides a default implementation' do
+    it "provides a default implementation" do
       info.install_vfunc_implementation :foo
       impl = info.vfunc_implementations.first
-      impl.implementation.class.must_equal Proc
+      _(impl.implementation.class).must_equal Proc
     end
   end
 
-  describe '#initialize' do
+  describe "#initialize" do
     let(:foo_spec) { Object.new }
     let(:bar_spec) { Object.new }
     let(:info) do
@@ -62,48 +62,48 @@ describe GirFFI::UserDefinedObjectInfo do
       allow(bar_spec).to receive(:get_name).and_return :bar
     end
 
-    it 'yields the new object to the block passed' do
-      info.properties.map(&:get_name).must_equal [:foo, :bar]
+    it "yields the new object to the block passed" do
+      _(info.properties.map(&:get_name)).must_equal [:foo, :bar]
     end
   end
 
-  describe '#g_name' do
+  describe "#g_name" do
     let(:user_class) { Object.new }
     let(:info) { GirFFI::UserDefinedObjectInfo.new user_class }
 
     before do
-      allow(user_class).to receive(:name).and_return 'foo'
+      allow(user_class).to receive(:name).and_return "foo"
     end
 
     it "returns the described class' name by default" do
-      info.g_name.must_equal 'foo'
+      _(info.g_name).must_equal "foo"
     end
 
-    it 'returns the the name set by #g_name= if present' do
-      info.g_name = 'bar'
-      info.g_name.must_equal 'bar'
+    it "returns the the name set by #g_name= if present" do
+      info.g_name = "bar"
+      _(info.g_name).must_equal "bar"
     end
   end
 
-  describe '#find_method' do
+  describe "#find_method" do
     let(:user_class) { Object.new }
     let(:info) { GirFFI::UserDefinedObjectInfo.new user_class }
 
-    it 'finds no methods' do
-      info.find_method('foo').must_be_nil
+    it "finds no methods" do
+      _(info.find_method("foo")).must_be_nil
     end
   end
 
-  describe '#find_signal' do
+  describe "#find_signal" do
     let(:user_class) { Object.new }
     let(:info) { GirFFI::UserDefinedObjectInfo.new user_class }
 
-    it 'finds no signals' do
-      info.find_signal('foo').must_be_nil
+    it "finds no signals" do
+      _(info.find_signal("foo")).must_be_nil
     end
   end
 
-  describe '#interfaces' do
+  describe "#interfaces" do
     let(:modul) { GIMarshallingTests::Interface }
     let(:user_class) { Class.new GIMarshallingTests::Object }
     let(:info) { GirFFI::UserDefinedObjectInfo.new user_class }
@@ -112,8 +112,8 @@ describe GirFFI::UserDefinedObjectInfo do
       user_class.send :include, modul
     end
 
-    it 'returns the interface infos for the include modules' do
-      info.interfaces.must_equal [modul.gir_info]
+    it "returns the interface infos for the include modules" do
+      _(info.interfaces).must_equal [modul.gir_info]
     end
   end
 end

data/test/gir_ffi/user_defined_property_info_test.rb

@@ -1,39 +1,39 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
-require 'gir_ffi/user_defined_property_info'
+require "gir_ffi_test_helper"
+require "gir_ffi/user_defined_property_info"
 
 describe GirFFI::UserDefinedPropertyInfo do
   let(:pspec) do
-    GObject.param_spec_int('foo-bar', 'foo bar',
-                           'Foo Bar',
+    GObject.param_spec_int("foo-bar", "foo bar",
+                           "Foo Bar",
                            1, 3, 2,
                            readable: true, writable: true)
   end
   let(:container) { Object.new }
   let(:info) { GirFFI::UserDefinedPropertyInfo.new pspec, container, 24 }
 
-  describe '#param_spec' do
-    it 'returns the passed in parameter specification' do
-      info.param_spec.must_equal pspec
+  describe "#param_spec" do
+    it "returns the passed in parameter specification" do
+      _(info.param_spec).must_equal pspec
     end
   end
 
-  describe '#name' do
-    it 'returns the accessor name from the parameter specification' do
-      info.name.must_equal 'foo_bar'
+  describe "#name" do
+    it "returns the accessor name from the parameter specification" do
+      _(info.name).must_equal "foo_bar"
     end
   end
 
-  describe '#ffi_type' do
-    it 'returns the ffi type corresponding to the type tag' do
-      info.ffi_type.must_equal :int
+  describe "#ffi_type" do
+    it "returns the ffi type corresponding to the type tag" do
+      _(info.ffi_type).must_equal :int
     end
   end
 
-  describe '#field_type.tag' do
-    it 'returns the mapped type symbol' do
-      info.field_type.tag.must_equal :gint
+  describe "#field_type.tag" do
+    it "returns the mapped type symbol" do
+      _(info.field_type.tag).must_equal :gint
     end
   end
 end

data/test/gir_ffi/variable_name_generator_test.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
-require 'gir_ffi/variable_name_generator'
+require "gir_ffi/variable_name_generator"
 
 describe GirFFI::VariableNameGenerator do
-  describe '#new_var' do
-    it 'generates a sequence of predictable variable names' do
+  describe "#new_var" do
+    it "generates a sequence of predictable variable names" do
       gen = GirFFI::VariableNameGenerator.new
 
-      assert_equal '_v1', gen.new_var
-      assert_equal '_v2', gen.new_var
-      assert_equal '_v3', gen.new_var
-      assert_equal '_v4', gen.new_var
+      assert_equal "_v1", gen.new_var
+      assert_equal "_v2", gen.new_var
+      assert_equal "_v3", gen.new_var
+      assert_equal "_v4", gen.new_var
     end
   end
 end

data/test/gir_ffi/version_test.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
-describe 'GirFFI::VERSION' do
-  it 'is set to a valid version number' do
-    GirFFI::VERSION.must_match(/\d+\.\d+\.\d+/)
+describe "GirFFI::VERSION" do
+  it "is set to a valid version number" do
+    _(GirFFI::VERSION).must_match(/\d+\.\d+\.\d+/)
   end
 end

data/test/gir_ffi/zero_terminated_test.rb

@@ -1,108 +1,108 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GirFFI::ZeroTerminated do
-  describe '.from' do
+  describe ".from" do
     let(:result) { GirFFI::ZeroTerminated.from :int32, [1, 2, 3] }
 
-    it 'converts the passed array into a zero-terminated c array' do
+    it "converts the passed array into a zero-terminated c array" do
       ptr = result.to_ptr
-      ptr.read_array_of_int32(4).must_equal [1, 2, 3, 0]
+      _(ptr.read_array_of_int32(4)).must_equal [1, 2, 3, 0]
     end
 
-    it 'returns a GirFFI::ZeroTerminated object' do
-      result.must_be_instance_of GirFFI::ZeroTerminated
+    it "returns a GirFFI::ZeroTerminated object" do
+      _(result).must_be_instance_of GirFFI::ZeroTerminated
     end
 
-    it 'works for Regress::TestEnum from numbers' do
+    it "works for Regress::TestEnum from numbers" do
       GirFFI.setup :Regress
       enum_arr = GirFFI::ZeroTerminated.from Regress::TestEnum, [1, -1, 48]
       ptr = enum_arr.to_ptr
-      ptr.read_array_of_int32(4).must_equal [1, -1, 48, 0]
+      _(ptr.read_array_of_int32(4)).must_equal [1, -1, 48, 0]
     end
 
-    it 'works for Regress::TestEnum from symbols' do
+    it "works for Regress::TestEnum from symbols" do
       GirFFI.setup :Regress
       enum_arr = GirFFI::ZeroTerminated.from Regress::TestEnum, [:value2, :value3, :value4]
       ptr = enum_arr.to_ptr
-      ptr.read_array_of_int32(4).must_equal [1, -1, 48, 0]
+      _(ptr.read_array_of_int32(4)).must_equal [1, -1, 48, 0]
     end
   end
 
-  describe '.wrap' do
-    it 'wraps the given type and pointer' do
+  describe ".wrap" do
+    it "wraps the given type and pointer" do
       ptr = GirFFI::InPointer.from_array :int32, [1, 2, 3, 0]
       zt = GirFFI::ZeroTerminated.wrap :foo, ptr
-      zt.element_type.must_equal :foo
-      zt.to_ptr.must_equal ptr
+      _(zt.element_type).must_equal :foo
+      _(zt.to_ptr).must_equal ptr
     end
   end
 
-  describe '#each' do
-    it 'yields each element' do
+  describe "#each" do
+    it "yields each element" do
       zt = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
       arr = []
       zt.each do |int|
         arr << int
       end
-      arr.must_equal [1, 2, 3]
+      _(arr).must_equal [1, 2, 3]
     end
 
-    it 'yields zero times for a ZeroTerminated wrapping a null pointer' do
+    it "yields zero times for a ZeroTerminated wrapping a null pointer" do
       zt = GirFFI::ZeroTerminated.wrap :int32, FFI::Pointer.new(0)
       zt.each do |_str|
         flunk
       end
     end
 
-    it 'works for :int8' do
+    it "works for :int8" do
       zt = GirFFI::ZeroTerminated.from :int8, [1, 2, 3]
       arr = []
       zt.each do |int|
         arr << int
       end
-      arr.must_equal [1, 2, 3]
+      _(arr).must_equal [1, 2, 3]
     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
       zero_terminated = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
 
-      (zero_terminated == [1, 2, 3]).must_equal true
+      _(zero_terminated == [1, 2, 3]).must_equal true
     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
       zero_terminated = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
 
-      (zero_terminated == [1, 2]).must_equal false
+      _(zero_terminated == [1, 2]).must_equal false
     end
 
-    it 'returns true when comparing to a zero-terminated array with the same elements' do
+    it "returns true when comparing to a zero-terminated array with the same elements" do
       zero_terminated = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
       other = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
 
-      (zero_terminated == other).must_equal true
+      _(zero_terminated == other).must_equal true
     end
 
-    it 'returns false when comparing to a zero-terminated array with different elements' do
+    it "returns false when comparing to a zero-terminated array with different elements" do
       zero_terminated = GirFFI::ZeroTerminated.from :int32, [1, 2, 3]
       other = GirFFI::ZeroTerminated.from :int32, [1, 2]
 
-      (zero_terminated == other).must_equal false
+      _(zero_terminated == other).must_equal false
     end
   end
 
-  it 'includes Enumerable' do
-    GirFFI::ZeroTerminated.must_include Enumerable
+  it "includes Enumerable" do
+    _(GirFFI::ZeroTerminated).must_include Enumerable
   end
 
-  describe '#to_a' do
-    it 'works for Regress::TestEnum' do
+  describe "#to_a" do
+    it "works for Regress::TestEnum" do
       GirFFI.setup :Regress
       enum_arr = GirFFI::ZeroTerminated.from Regress::TestEnum, [1, 48, -1]
-      enum_arr.to_a.must_equal [:value2, :value4, :value3]
+      _(enum_arr.to_a).must_equal [:value2, :value4, :value3]
     end
   end
 end

data/test/gir_ffi_test_helper.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'introspection_test_helper'
+require "introspection_test_helper"
 
-require 'gir_ffi'
+require "gir_ffi"
 
 # Global sequence provider. Needed to make unique class names.
 class Sequence
@@ -81,4 +81,4 @@ module GirFFITestExtensions
   end
 end
 
-Minitest::Test.send :include, GirFFITestExtensions
+Minitest::Test.include GirFFITestExtensions

data/test/integration/callback_exceptions_test.rb

@@ -1,62 +1,58 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 GirFFI.setup :Regress
 
 class CallbackTestException < RuntimeError; end
 
-describe 'An exception in a callback' do
-  describe 'for signals' do
+describe "An exception in a callback" do
+  describe "for signals" do
     let(:object) { Regress::TestSubObj.new }
 
     before do
-      object.signal_connect 'test' do
-        raise CallbackTestException, 'Boom'
+      object.signal_connect "test" do
+        raise CallbackTestException, "Boom"
       end
     end
 
-    describe 'when the signal is emitted synchronously' do
-      it 'raises an error' do
-        proc { GObject.signal_emit object, 'test' }.must_raise CallbackTestException
+    describe "when the signal is emitted synchronously" do
+      it "raises an error" do
+        _(proc { GObject.signal_emit object, "test" }).must_raise CallbackTestException
       end
     end
 
-    describe 'when the signal is emitted during an event loop' do
-      it 'causes loop run to be terminated with an exception' do
+    describe "when the signal is emitted during an event loop" do
+      it "causes loop run to be terminated with an exception" do
         main_loop = GLib::MainLoop.new nil, false
 
         GLib.timeout_add GLib::PRIORITY_DEFAULT, 1 do
-          GObject.signal_emit object, 'test'
+          GObject.signal_emit object, "test"
           false
         end
         # Guard against runaway loop
         GLib.timeout_add GLib::PRIORITY_DEFAULT, 500 do
           main_loop.quit
         end
-        proc do
-          main_loop.run
-        end.must_raise CallbackTestException
+        _(proc { main_loop.run }).must_raise CallbackTestException
       end
     end
   end
 
-  describe 'for other callbacks' do
-    describe 'when the callback occurs during an event loop' do
-      it 'causes loop run to be terminated with an exception' do
+  describe "for other callbacks" do
+    describe "when the callback occurs during an event loop" do
+      it "causes loop run to be terminated with an exception" do
         main_loop = GLib::MainLoop.new nil, false
 
         GLib.timeout_add GLib::PRIORITY_DEFAULT, 1 do
-          raise CallbackTestException, 'Boom'
+          raise CallbackTestException, "Boom"
         end
         # Guard against runaway loop
         GLib.timeout_add GLib::PRIORITY_DEFAULT, 500 do
           main_loop.quit
         end
 
-        proc do
-          main_loop.run
-        end.must_raise CallbackTestException
+        _(proc { main_loop.run }).must_raise CallbackTestException
       end
     end
   end