gir_ffi 0.14.1 → 0.15.0

data/test/ffi-glib/s_list_test.rb

@@ -1,27 +1,27 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GLib::SList do
-  it 'knows its element type' do
+  it "knows its element type" do
     arr = GLib::SList.new :gint32
     assert_equal :gint32, arr.element_type
   end
 
-  describe '#prepend' do
-    it 'prepends integer values' do
+  describe "#prepend" do
+    it "prepends integer values" do
       lst = GLib::SList.new :gint32
       res = lst.prepend 1
       assert_equal 1, res.data
     end
 
-    it 'prepends string values' do
+    it "prepends string values" do
       lst = GLib::SList.new :utf8
-      res = lst.prepend 'bla'
-      assert_equal 'bla', res.data
+      res = lst.prepend "bla"
+      assert_equal "bla", res.data
     end
 
-    it 'prepends multiple values into a single list' do
+    it "prepends multiple values into a single list" do
       lst = GLib::SList.new :gint32
 
       res = lst.prepend 1
@@ -33,44 +33,44 @@ describe GLib::SList do
     end
   end
 
-  describe '::from' do
-    it 'creates a GSList from a Ruby array' do
+  describe "::from" do
+    it "creates a GSList from a Ruby array" do
       lst = GLib::SList.from :gint32, [3, 2, 1]
       assert_equal [3, 2, 1], lst.to_a
     end
 
-    it 'return its argument if given a GSList' do
+    it "return its argument if given a GSList" do
       lst = GLib::SList.from :gint32, [3, 2, 1]
       lst2 = GLib::SList.from :gint32, lst
       assert_equal lst, lst2
     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
       list = GLib::SList.from :gint32, [1, 2, 3]
 
-      list.must_be :==, [1, 2, 3]
+      _(list).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
       list = GLib::SList.from :gint32, [1, 2, 3]
 
-      list.wont_be :==, [1, 2]
+      _(list).wont_be :==, [1, 2]
     end
 
-    it 'returns true when comparing to a list with the same elements' do
+    it "returns true when comparing to a list with the same elements" do
       list = GLib::SList.from :gint32, [1, 2, 3]
       other = GLib::SList.from :gint32, [1, 2, 3]
 
-      list.must_be :==, other
+      _(list).must_be :==, other
     end
 
-    it 'returns false when comparing to a list with different elements' do
+    it "returns false when comparing to a list with different elements" do
       list = GLib::SList.from :gint32, [1, 2, 3]
       other = GLib::SList.from :gint32, [1, 2]
 
-      list.wont_be :==, other
+      _(list).wont_be :==, other
     end
   end
 end

data/test/ffi-glib/strv_test.rb

@@ -1,60 +1,60 @@
 # frozen_string_literal: true
 
-require 'base_test_helper'
+require "base_test_helper"
 
 describe GLib::Strv do
-  describe '::from' do
-    it 'creates a Strv from a Ruby array' do
+  describe "::from" do
+    it "creates a Strv from a Ruby array" do
       strv = GLib::Strv.from %w(1 2 3)
-      strv.must_be_instance_of GLib::Strv
-      strv.to_a.must_equal %w(1 2 3)
+      _(strv).must_be_instance_of GLib::Strv
+      _(strv.to_a).must_equal %w(1 2 3)
     end
 
-    it 'return its argument if given a Strv' do
+    it "return its argument if given a Strv" do
       strv = GLib::Strv.from %w(1 2 3)
       strv2 = GLib::Strv.from strv
       assert strv2.equal? strv
     end
 
-    it 'wraps its argument if given a pointer' do
+    it "wraps its argument if given a pointer" do
       strv = GLib::Strv.from %w(1 2 3)
 
       pointer = strv.to_ptr
-      pointer.must_be_kind_of FFI::Pointer
+      _(pointer).must_be_kind_of FFI::Pointer
 
       strv2 = GLib::Strv.from pointer
 
-      strv2.must_be_kind_of GLib::Strv
+      _(strv2).must_be_kind_of GLib::Strv
       refute strv2.equal? strv
-      strv2.to_a.must_equal strv.to_a
+      _(strv2.to_a).must_equal strv.to_a
     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
       strv = GLib::Strv.from %w(1 2 3)
 
-      strv.must_be :==, %w(1 2 3)
+      _(strv).must_be :==, %w(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
       strv = GLib::Strv.from %w(1 2 3)
 
-      strv.wont_be :==, %w(1 2)
+      _(strv).wont_be :==, %w(1 2)
     end
 
-    it 'returns true when comparing to a strv with the same elements' do
+    it "returns true when comparing to a strv with the same elements" do
       strv = GLib::Strv.from %w(1 2 3)
       other = GLib::Strv.from %w(1 2 3)
 
-      strv.must_be :==, other
+      _(strv).must_be :==, other
     end
 
-    it 'returns false when comparing to a strv with different elements' do
+    it "returns false when comparing to a strv with different elements" do
       strv = GLib::Strv.from %w(1 2 3)
       other = GLib::Strv.from %w(1 2)
 
-      strv.wont_be :==, other
+      _(strv).wont_be :==, other
     end
   end
 end

data/test/ffi-glib/variant_test.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GLib::Variant do
-  describe '#get_string' do
-    it 'returns just the contained string' do
-      var = GLib::Variant.new_string('Foo')
-      var.get_string.must_equal 'Foo'
+  describe "#get_string" do
+    it "returns just the contained string" do
+      var = GLib::Variant.new_string("Foo")
+      _(var.get_string).must_equal "Foo"
     end
   end
 end

data/test/ffi-gobject/gobject_test.rb

@@ -1,71 +1,75 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
-require 'ffi-gobject'
+require "ffi-gobject"
 
 GirFFI.setup :GIMarshallingTests
 
 describe GObject do
-  describe '.type_init' do
-    it 'does not raise an error' do
+  describe ".type_init" do
+    it "does not raise an error" do
       GObject.type_init
       pass
     end
   end
 
-  it 'has constants for the fundamental GTypes' do
-    GObject::TYPE_INVALID.must_equal GObject.type_from_name('invalid')
-    GObject.type_name(GObject::TYPE_INVALID).must_be_nil
+  it "has constants for the fundamental GTypes" do
+    _(GObject::TYPE_INVALID).must_equal GObject.type_from_name("invalid")
+    _(GObject.type_name(GObject::TYPE_INVALID)).must_be_nil
 
-    GObject.type_name(GObject::TYPE_NONE).must_equal       'void'
-    GObject.type_name(GObject::TYPE_INTERFACE).must_equal  'GInterface'
-    GObject.type_name(GObject::TYPE_CHAR).must_equal       'gchar'
-    GObject.type_name(GObject::TYPE_UCHAR).must_equal      'guchar'
-    GObject.type_name(GObject::TYPE_BOOLEAN).must_equal    'gboolean'
-    GObject.type_name(GObject::TYPE_INT).must_equal        'gint'
-    GObject.type_name(GObject::TYPE_UINT).must_equal       'guint'
-    GObject.type_name(GObject::TYPE_LONG).must_equal       'glong'
-    GObject.type_name(GObject::TYPE_ULONG).must_equal      'gulong'
-    GObject.type_name(GObject::TYPE_INT64).must_equal      'gint64'
-    GObject.type_name(GObject::TYPE_UINT64).must_equal     'guint64'
-    GObject.type_name(GObject::TYPE_ENUM).must_equal       'GEnum'
-    GObject.type_name(GObject::TYPE_FLAGS).must_equal      'GFlags'
-    GObject.type_name(GObject::TYPE_FLOAT).must_equal      'gfloat'
-    GObject.type_name(GObject::TYPE_DOUBLE).must_equal     'gdouble'
-    GObject.type_name(GObject::TYPE_STRING).must_equal     'gchararray'
-    GObject.type_name(GObject::TYPE_POINTER).must_equal    'gpointer'
-    GObject.type_name(GObject::TYPE_BOXED).must_equal      'GBoxed'
-    GObject.type_name(GObject::TYPE_PARAM).must_equal      'GParam'
-    GObject.type_name(GObject::TYPE_OBJECT).must_equal     'GObject'
-    GObject.type_name(GObject::TYPE_GTYPE).must_equal      'GType'
-    GObject.type_name(GObject::TYPE_VARIANT).must_equal    'GVariant'
-    GObject.type_name(GObject::TYPE_STRV).must_equal       'GStrv'
-    GObject.type_name(GObject::TYPE_HASH_TABLE).must_equal 'GHashTable'
+    _(GObject.type_name(GObject::TYPE_NONE)).must_equal       "void"
+    _(GObject.type_name(GObject::TYPE_INTERFACE)).must_equal  "GInterface"
+    _(GObject.type_name(GObject::TYPE_CHAR)).must_equal       "gchar"
+    _(GObject.type_name(GObject::TYPE_UCHAR)).must_equal      "guchar"
+    _(GObject.type_name(GObject::TYPE_BOOLEAN)).must_equal    "gboolean"
+    _(GObject.type_name(GObject::TYPE_INT)).must_equal        "gint"
+    _(GObject.type_name(GObject::TYPE_UINT)).must_equal       "guint"
+    _(GObject.type_name(GObject::TYPE_LONG)).must_equal       "glong"
+    _(GObject.type_name(GObject::TYPE_ULONG)).must_equal      "gulong"
+    _(GObject.type_name(GObject::TYPE_INT64)).must_equal      "gint64"
+    _(GObject.type_name(GObject::TYPE_UINT64)).must_equal     "guint64"
+    _(GObject.type_name(GObject::TYPE_ENUM)).must_equal       "GEnum"
+    _(GObject.type_name(GObject::TYPE_FLAGS)).must_equal      "GFlags"
+    _(GObject.type_name(GObject::TYPE_FLOAT)).must_equal      "gfloat"
+    _(GObject.type_name(GObject::TYPE_DOUBLE)).must_equal     "gdouble"
+    _(GObject.type_name(GObject::TYPE_STRING)).must_equal     "gchararray"
+    _(GObject.type_name(GObject::TYPE_POINTER)).must_equal    "gpointer"
+    _(GObject.type_name(GObject::TYPE_BOXED)).must_equal      "GBoxed"
+    _(GObject.type_name(GObject::TYPE_PARAM)).must_equal      "GParam"
+    _(GObject.type_name(GObject::TYPE_OBJECT)).must_equal     "GObject"
+    _(GObject.type_name(GObject::TYPE_GTYPE)).must_equal      "GType"
+    _(GObject.type_name(GObject::TYPE_VARIANT)).must_equal    "GVariant"
+
+    _(GObject.type_name(GObject::TYPE_ARRAY)).must_equal      "GArray"
+    _(GObject.type_name(GObject::TYPE_BYTE_ARRAY)).must_equal "GByteArray"
+    _(GObject.type_name(GObject::TYPE_ERROR)).must_equal      "GError"
+    _(GObject.type_name(GObject::TYPE_HASH_TABLE)).must_equal "GHashTable"
+    _(GObject.type_name(GObject::TYPE_STRV)).must_equal       "GStrv"
   end
 
-  describe '::object_class_from_instance' do
-    it 'returns a GObject::ObjectClass with the correct GType' do
+  describe "::object_class_from_instance" do
+    it "returns a GObject::ObjectClass with the correct GType" do
       obj = GIMarshallingTests::OverridesObject.new
       object_class = GObject.object_class_from_instance obj
       gtype = object_class.g_type_class.g_type
 
-      object_class.must_be_instance_of GObject::ObjectClass
-      gtype.must_equal GIMarshallingTests::OverridesObject.gtype
+      _(object_class).must_be_instance_of GObject::ObjectClass
+      _(gtype).must_equal GIMarshallingTests::OverridesObject.gtype
     end
   end
 
-  describe 'creating ParamSpecs' do
-    describe '#param_spec_int' do
-      it 'creates a GObject::ParamSpecInt' do
-        spec = GObject.param_spec_int('foo', 'foo bar',
-                                      'The Foo Bar Property',
+  describe "creating ParamSpecs" do
+    describe "#param_spec_int" do
+      it "creates a GObject::ParamSpecInt" do
+        spec = GObject.param_spec_int("foo", "foo bar",
+                                      "The Foo Bar Property",
                                       10, 20, 15,
                                       3)
-        spec.must_be_instance_of GObject::ParamSpecInt
-        spec.struct[:minimum].must_equal 10
-        spec.struct[:maximum].must_equal 20
-        spec.get_default_value.must_equal 15
+        _(spec).must_be_instance_of GObject::ParamSpecInt
+        _(spec.struct[:minimum]).must_equal 10
+        _(spec.struct[:maximum]).must_equal 20
+        _(spec.get_default_value).must_equal 15
       end
     end
   end

data/test/ffi-gobject/object_class_test.rb

@@ -1,31 +1,31 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
-require 'ffi-gobject'
+require "ffi-gobject"
 
 describe GObject::ObjectClass do
-  describe '#list_properties' do
+  describe "#list_properties" do
     it "returns GIMarshallingTests::OverridesObject's properties" do
       obj = GIMarshallingTests::OverridesObject.new
       object_class = GObject.object_class_from_instance obj
 
-      info = get_introspection_data 'GIMarshallingTests', 'OverridesObject'
+      info = get_introspection_data "GIMarshallingTests", "OverridesObject"
       expected_props = info.properties.map(&:name)
       expected_props += info.parent.properties.map(&:name)
 
       props = object_class.list_properties
       prop_names = props.map(&:get_name)
 
-      prop_names.sort.must_equal expected_props.sort
+      _(prop_names.sort).must_equal expected_props.sort
     end
   end
 
-  describe '#gtype' do
-    it 'returns the correct GType' do
+  describe "#gtype" do
+    it "returns the correct GType" do
       obj = GIMarshallingTests::OverridesObject.new
       object_class = GObject.object_class_from_instance obj
-      object_class.gtype.must_equal GIMarshallingTests::OverridesObject.gtype
+      _(object_class.gtype).must_equal GIMarshallingTests::OverridesObject.gtype
     end
   end
 end

data/test/ffi-gobject/object_test.rb

@@ -1,130 +1,112 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
-require 'ffi-gobject'
+require "ffi-gobject"
 GirFFI.setup :GIMarshallingTests
 
 describe GObject::Object do
-  describe '.new' do
-    it 'is overridden to take only one argument' do
-      GObject::Object.new({}).must_be_instance_of GObject::Object
+  describe ".new" do
+    it "is overridden to take only one argument" do
+      _(GObject::Object.new({})).must_be_instance_of GObject::Object
     end
 
-    it 'can be used to create objects with properties' do
+    it "can be used to create objects with properties" do
       obj = GIMarshallingTests::SubObject.new(int: 13)
-      obj.int.must_equal 13
+      _(obj.int).must_equal 13
     end
 
-    it 'allows omission of the first argument' do
-      GObject::Object.new.must_be_instance_of GObject::Object
+    it "allows omission of the first argument" do
+      _(GObject::Object.new).must_be_instance_of GObject::Object
     end
 
-    it 'raises an error for properties that do not exist' do
-      proc { GObject::Object.new(dog: 'bark') }.must_raise GirFFI::PropertyNotFoundError
+    it "raises an error for properties that do not exist" do
+      _(proc { GObject::Object.new(dog: "bark") }).must_raise GirFFI::PropertyNotFoundError
     end
   end
 
-  describe '#get_property' do
-    it 'is overridden to have arity 1' do
-      GObject::Object.instance_method('get_property').arity.must_equal 1
+  describe "#get_property" do
+    it "is overridden to have arity 1" do
+      _(GObject::Object.instance_method("get_property").arity).must_equal 1
     end
 
-    it 'raises an error for a property that does not exist' do
+    it "raises an error for a property that does not exist" do
       instance = GObject::Object.new
-      proc { instance.get_property 'foo-bar' }.must_raise GirFFI::PropertyNotFoundError
+      _(proc { instance.get_property "foo-bar" }).must_raise GirFFI::PropertyNotFoundError
     end
-  end
 
-  describe '#get_property_extended' do
-    it 'raises an error for a property that does not exist' do
+    it "raises an error for a property that does not exist" do
       instance = GObject::Object.new
-      proc { instance.get_property_extended 'foo-bar' }.
+      _(proc { instance.get_property "foo-bar" }).
         must_raise GirFFI::PropertyNotFoundError
     end
   end
 
-  describe '#set_property' do
-    it 'raises an error for a property that does not exist' do
+  describe "#get_property_extended" do
+    it "raises an error for a property that does not exist" do
       instance = GObject::Object.new
-      proc { instance.set_property 'foo-bar', 123 }.must_raise GirFFI::PropertyNotFoundError
+      _(proc { instance.get_property_extended "foo-bar" }).
+        must_raise GirFFI::PropertyNotFoundError
     end
   end
 
-  describe '#set_property_extended' do
-    it 'raises an error for a property that does not exist' do
+  describe "#set_property" do
+    it "raises an error for a property that does not exist" do
       instance = GObject::Object.new
-      proc { instance.set_property_extended 'foo-bar', 123 }.
-        must_raise GirFFI::PropertyNotFoundError
+      _(proc { instance.set_property "foo-bar", 123 }).must_raise GirFFI::PropertyNotFoundError
     end
   end
 
-  describe 'automatic accessor methods' do
-    class AccessorTest < GObject::Object
-      def get_x
-        @x
-      end
-
-      def set_x(val)
-        @x = val
-      end
-    end
-
-    subject { AccessorTest.new }
-
-    it 'reads x by calling get_x' do
-      subject.set_x(1)
-      assert_equal 1, subject.x
-    end
-
-    it 'writes x by calling set_x' do
-      subject.x = 2
-      assert_equal 2, subject.x
+  describe "#set_property_extended" do
+    it "raises an error for a property that does not exist" do
+      instance = GObject::Object.new
+      _(proc { instance.set_property_extended "foo-bar", 123 }).
+        must_raise GirFFI::PropertyNotFoundError
     end
   end
 
-  describe '#signal_connect' do
+  describe "#signal_connect" do
     subject { GObject::Object.new }
 
-    it 'delegates to GObject' do
-      expect(GObject).to receive(:signal_connect).with(subject, 'some-event', nil)
-      subject.signal_connect('some-event') do
+    it "delegates to GObject" do
+      expect(GObject).to receive(:signal_connect).with(subject, "some-event", nil)
+      subject.signal_connect("some-event") do
         nothing
       end
     end
 
-    it 'delegates to GObject if an optional data argument is passed' do
-      expect(GObject).to receive(:signal_connect).with(subject, 'some-event', 'data')
-      subject.signal_connect('some-event', 'data') do
+    it "delegates to GObject if an optional data argument is passed" do
+      expect(GObject).to receive(:signal_connect).with(subject, "some-event", "data")
+      subject.signal_connect("some-event", "data") do
         nothing
       end
     end
   end
 
-  describe '#signal_connect_after' do
+  describe "#signal_connect_after" do
     subject { GObject::Object.new }
 
-    it 'delegates to GObject' do
-      expect(GObject).to receive(:signal_connect_after).with(subject, 'some-event', nil)
-      subject.signal_connect_after('some-event') do
+    it "delegates to GObject" do
+      expect(GObject).to receive(:signal_connect_after).with(subject, "some-event", nil)
+      subject.signal_connect_after("some-event") do
         nothing
       end
     end
 
-    it 'delegates to GObject if an optional data argument is passed' do
-      expect(GObject).to receive(:signal_connect_after).with(subject, 'some-event', 'data')
-      subject.signal_connect_after('some-event', 'data') do
+    it "delegates to GObject if an optional data argument is passed" do
+      expect(GObject).to receive(:signal_connect_after).with(subject, "some-event", "data")
+      subject.signal_connect_after("some-event", "data") do
         nothing
       end
     end
   end
 
-  describe 'upon garbage collection' do
-    it 'lowers the reference count' do
-      skip 'cannot be reliably tested on JRuby and Rubinius' if jruby? || rubinius?
+  describe "upon garbage collection" do
+    it "lowers the reference count" do
+      skip "cannot be reliably tested on JRuby and Rubinius" if jruby? || rubinius?
 
       ptr = GObject::Object.new.to_ptr
-      object_ref_count(ptr).must_equal 1
+      _(object_ref_count(ptr)).must_equal 1
 
       GC.start
       # Creating a new object is sometimes needed to trigger enough garbage collection.
@@ -134,7 +116,7 @@ describe GObject::Object do
       GC.start
       GC.start
 
-      object_ref_count(ptr).must_equal 0
+      _(object_ref_count(ptr)).must_equal 0
     end
   end
 end