gir_ffi 0.14.0 → 0.15.3

data/test/ffi-glib/ptr_array_test.rb

@@ -1,30 +1,30 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GLib::PtrArray do
-  it 'knows its element type' do
+  it "knows its element type" do
     arr = GLib::PtrArray.new :utf8
     assert_equal :utf8, arr.element_type
   end
 
-  describe '::add' do
-    it 'correctly takes the type into account' do
+  describe "::add" do
+    it "correctly takes the type into account" do
       arr = GLib::PtrArray.new :utf8
-      str = 'test'
+      str = "test"
       GLib::PtrArray.add arr, str
 
       assert_equal str, arr.pdata.read_pointer.read_string
     end
   end
 
-  describe '#each' do
-    it 'works normally' do
+  describe "#each" do
+    it "works normally" do
       arr = GLib::PtrArray.new :utf8
 
-      GLib::PtrArray.add arr, 'test1'
-      GLib::PtrArray.add arr, 'test2'
-      GLib::PtrArray.add arr, 'test3'
+      GLib::PtrArray.add arr, "test1"
+      GLib::PtrArray.add arr, "test2"
+      GLib::PtrArray.add arr, "test3"
 
       a = []
       arr.each { |v| a << v }
@@ -32,81 +32,81 @@ describe GLib::PtrArray do
       assert_equal %w(test1 test2 test3), a
     end
 
-    it 'works when exiting the loop prematurely' do
+    it "works when exiting the loop prematurely" do
       arr = GLib::PtrArray.new :utf8
 
-      GLib::PtrArray.add arr, 'test1'
-      GLib::PtrArray.add arr, 'test2'
-      GLib::PtrArray.add arr, 'test3'
+      GLib::PtrArray.add arr, "test1"
+      GLib::PtrArray.add arr, "test2"
+      GLib::PtrArray.add arr, "test3"
 
       a = []
       arr.each do |v|
         a << v
-        break if v == 'test2'
+        break if v == "test2"
       end
 
       assert_equal %w(test1 test2), a
     end
   end
 
-  it 'includes Enumerable' do
-    GLib::PtrArray.must_include Enumerable
+  it "includes Enumerable" do
+    _(GLib::PtrArray).must_include Enumerable
   end
 
-  it 'has a working #to_a method' do
+  it "has a working #to_a method" do
     arr = GLib::PtrArray.new :utf8
 
-    GLib::PtrArray.add arr, 'test1'
-    GLib::PtrArray.add arr, 'test2'
-    GLib::PtrArray.add arr, 'test3'
+    GLib::PtrArray.add arr, "test1"
+    GLib::PtrArray.add arr, "test2"
+    GLib::PtrArray.add arr, "test3"
 
     assert_equal %w(test1 test2 test3), arr.to_a
   end
 
-  it 'has #add as an instance method too' do
+  it "has #add as an instance method too" do
     arr = GLib::PtrArray.new :utf8
-    arr.add 'test1'
-    assert_equal ['test1'], arr.to_a
+    arr.add "test1"
+    assert_equal ["test1"], arr.to_a
   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
       arr = GLib::PtrArray.from :utf8, %w(1 2 3)
 
-      arr.must_be :==, %w(1 2 3)
+      _(arr).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
       arr = GLib::PtrArray.from :utf8, %w(1 2 3)
 
-      arr.wont_be :==, %w(1 2)
+      _(arr).wont_be :==, %w(1 2)
     end
 
-    it 'returns true when comparing to a GPtrArray with the same elements' do
+    it "returns true when comparing to a GPtrArray with the same elements" do
       arr = GLib::PtrArray.from :utf8, %w(1 2 3)
       other = GLib::PtrArray.from :utf8, %w(1 2 3)
 
-      arr.must_be :==, other
+      _(arr).must_be :==, other
     end
 
-    it 'returns false when comparing to a GPtrArray with different elements' do
+    it "returns false when comparing to a GPtrArray with different elements" do
       arr = GLib::PtrArray.from :utf8, %w(1 2 3)
       other = GLib::PtrArray.from :utf8, %w(1 2)
 
-      arr.wont_be :==, other
+      _(arr).wont_be :==, other
     end
   end
 
-  describe '#index' do
-    it 'returns the correct element' do
+  describe "#index" do
+    it "returns the correct element" do
       arr = GLib::PtrArray.from :utf8, %w(1 2 3)
-      arr.index(1).must_equal '2'
+      _(arr.index(1)).must_equal "2"
     end
 
-    it 'raises an error if the index is out of bounds' do
+    it "raises an error if the index is out of bounds" do
       arr = GLib::PtrArray.from :utf8, %w(1 2 3)
-      proc { arr.index(16) }.must_raise IndexError
-      proc { arr.index(-1) }.must_raise IndexError
+      _(proc { arr.index(16) }).must_raise IndexError
+      _(proc { arr.index(-1) }).must_raise IndexError
     end
   end
 end

data/test/ffi-glib/ruby_closure_test.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GObject::RubyClosure do
-  describe '.new' do
-    it 'takes a mandatory block argument' do
+  describe ".new" do
+    it "takes a mandatory block argument" do
       assert_raises ArgumentError do
         GObject::RubyClosure.new
       end
     end
 
-    it 'returns a kind of Closure' do
+    it "returns a kind of Closure" do
       c = GObject::RubyClosure.new {}
       assert_kind_of GObject::Closure, c
     end
   end
 
-  describe '.wrap' do
-    it 'returns a fully functional object that can invoke the original block' do
+  describe ".wrap" do
+    it "returns a fully functional object that can invoke the original block" do
       a = 0
       c = GObject::RubyClosure.new { a = 2 }
       c2 = GObject::RubyClosure.wrap(c.to_ptr)
@@ -26,7 +26,7 @@ describe GObject::RubyClosure do
     end
   end
 
-  describe '.marshaller' do
+  describe ".marshaller" do
     it "invokes its closure argument's block" do
       a = 0
       c = GObject::RubyClosure.new { a = 2 }
@@ -34,7 +34,7 @@ describe GObject::RubyClosure do
       assert_equal 2, a
     end
 
-    it 'works when its closure argument is a GObject::Closure' do
+    it "works when its closure argument is a GObject::Closure" do
       a = 0
       c = GObject::RubyClosure.new { a = 2 }
       c2 = GObject::Closure.wrap(c.to_ptr)
@@ -50,8 +50,8 @@ describe GObject::RubyClosure do
     end
   end
 
-  describe '#invoke' do
-    it 'invokes the ruby block' do
+  describe "#invoke" do
+    it "invokes the ruby block" do
       a = 0
       c = GObject::RubyClosure.new { a = 2 }
       c2 = GObject::Closure.wrap(c.to_ptr)

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