gir_ffi 0.14.1 → 0.15.0

data/test/ffi-glib/destroy_notify_test.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GLib::DestroyNotify do
-  describe '.default' do
-    it 'removes the passed-in key from the callback store' do
-      dummy_proc = 'some-callback'
+  describe ".default" do
+    it "removes the passed-in key from the callback store" do
+      dummy_proc = "some-callback"
       GirFFI::CallbackBase.store_callback dummy_proc
-      GirFFI::CallbackBase::CALLBACKS[dummy_proc.object_id].wont_be_nil
+      _(GirFFI::CallbackBase::CALLBACKS[dummy_proc.object_id]).wont_be_nil
 
       user_data = GirFFI::ArgHelper.store dummy_proc
       GLib::DestroyNotify.default.call user_data
 
-      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/ffi-glib/hash_table_test.rb

@@ -1,68 +1,68 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GLib::HashTable do
-  it 'knows its key and value types' do
+  it "knows its key and value types" do
     hsh = GLib::HashTable.new :gint32, :utf8
     assert_equal :gint32, hsh.key_type
     assert_equal :utf8, hsh.value_type
   end
 
-  describe '::from' do
-    it 'creates a GHashTable from a Ruby hash' do
+  describe "::from" do
+    it "creates a GHashTable from a Ruby hash" do
       hsh = GLib::HashTable.from [:utf8, :gint32],
-                                 'foo' => 23, 'bar' => 32
-      assert_equal({ 'foo' => 23, 'bar' => 32 }, hsh.to_hash)
+                                 "foo" => 23, "bar" => 32
+      assert_equal({ "foo" => 23, "bar" => 32 }, hsh.to_hash)
     end
 
-    it 'return its argument if given a GHashTable' do
-      hsh = GLib::HashTable.from [:utf8, :gint32], 'foo' => 23, 'bar' => 32
+    it "return its argument if given a GHashTable" do
+      hsh = GLib::HashTable.from [:utf8, :gint32], "foo" => 23, "bar" => 32
       hsh2 = GLib::HashTable.from [:utf8, :gint32], hsh
       assert hsh2.equal? hsh
     end
 
-    it 'wraps its argument if given a pointer' do
-      hsh = GLib::HashTable.from [:utf8, :gint32], 'foo' => 23, 'bar' => 32
+    it "wraps its argument if given a pointer" do
+      hsh = GLib::HashTable.from [:utf8, :gint32], "foo" => 23, "bar" => 32
       pointer = hsh.to_ptr
       assert_instance_of FFI::Pointer, pointer
       hsh2 = GLib::HashTable.from [:utf8, :gint32], pointer
       assert_instance_of GLib::HashTable, hsh2
       refute hsh2.equal? hsh
-      hsh2.to_hash.must_equal hsh.to_hash
+      _(hsh2.to_hash).must_equal hsh.to_hash
     end
   end
 
-  it 'allows key-value pairs to be inserted' do
+  it "allows key-value pairs to be inserted" do
     h = GLib::HashTable.new :utf8, :utf8
-    h.insert 'foo', 'bar'
-    h.to_hash.must_equal 'foo' => 'bar'
+    h.insert "foo", "bar"
+    _(h.to_hash).must_equal "foo" => "bar"
   end
 
-  it 'includes Enumerable' do
-    GLib::HashTable.must_include Enumerable
+  it "includes Enumerable" do
+    _(GLib::HashTable).must_include Enumerable
   end
 
-  describe 'a HashTable provided by the system' do
+  describe "a HashTable provided by the system" do
     before do
       GirFFI.setup :Regress
       @hash = Regress.test_ghash_container_return
     end
 
-    it 'has a working #each method' do
+    it "has a working #each method" do
       a = {}
       @hash.each { |k, v| a[k] = v }
-      a.must_be :==,
-                'foo' => 'bar',
-                'baz' => 'bat',
-                'qux' => 'quux'
+      _(a).must_be :==,
+                   "foo" => "bar",
+                   "baz" => "bat",
+                   "qux" => "quux"
     end
 
-    it 'has a working #to_hash method' do
-      @hash.to_hash.must_be :==,
-                            'foo' => 'bar',
-                            'baz' => 'bat',
-                            'qux' => 'quux'
+    it "has a working #to_hash method" do
+      _(@hash.to_hash).must_be :==,
+                               "foo" => "bar",
+                               "baz" => "bat",
+                               "qux" => "quux"
     end
   end
 end

data/test/ffi-glib/list_test.rb

@@ -1,27 +1,27 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 describe GLib::List do
-  it 'knows its element type' do
+  it "knows its element type" do
     arr = GLib::List.new :gint32
     assert_equal :gint32, arr.element_type
   end
 
-  describe '#append' do
-    it 'appends integer values' do
+  describe "#append" do
+    it "appends integer values" do
       lst = GLib::List.new :gint32
       res = lst.append 1
       assert_equal 1, res.data
     end
 
-    it 'appends string values' do
+    it "appends string values" do
       lst = GLib::List.new :utf8
-      res = lst.append 'bla'
-      assert_equal 'bla', res.data
+      res = lst.append "bla"
+      assert_equal "bla", res.data
     end
 
-    it 'appends multiple values into a single list' do
+    it "appends multiple values into a single list" do
       lst = GLib::List.new :gint32
 
       lst = lst.append 1
@@ -33,54 +33,54 @@ describe GLib::List do
     end
   end
 
-  describe '::from' do
-    it 'creates a GList from a Ruby array' do
+  describe "::from" do
+    it "creates a GList from a Ruby array" do
       lst = GLib::List.from :gint32, [3, 2, 1]
       assert_equal [3, 2, 1], lst.to_a
     end
 
-    it 'return its argument if given a GList' do
+    it "return its argument if given a GList" do
       lst = GLib::List.from :gint32, [3, 2, 1]
       lst2 = GLib::List.from :gint32, lst
       assert lst2.equal? lst
     end
 
-    it 'wraps its argument if given a pointer' do
+    it "wraps its argument if given a pointer" do
       lst = GLib::List.from :gint32, [3, 2, 1]
       pointer = lst.to_ptr
       assert_instance_of FFI::Pointer, pointer
       lst2 = GLib::List.from :gint32, pointer
       assert_instance_of GLib::List, lst2
       refute lst2.equal? lst
-      lst2.to_a.must_equal lst.to_a
+      _(lst2.to_a).must_equal lst.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
       list = GLib::List.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::List.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::List.from :gint32, [1, 2, 3]
       other = GLib::List.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::List.from :gint32, [1, 2, 3]
       other = GLib::List.from :gint32, [1, 2]
 
-      list.wont_be :==, other
+      _(list).wont_be :==, other
     end
   end
 end

data/test/ffi-glib/main_loop_test.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 class MainLoopTestException < RuntimeError; end
 
 describe GLib::MainLoop do
-  describe '#run' do
-    it 'allows other threads to run' do
+  describe "#run" do
+    it "allows other threads to run" do
       main_loop = GLib::MainLoop.new nil, false
 
       a = []
@@ -16,26 +16,26 @@ describe GLib::MainLoop do
 
       slow_thread = Thread.new do
         sleep 0.001
-        a << 'During run'
+        a << "During run"
       end
 
-      a << 'Before run'
+      a << "Before run"
       main_loop.run
-      a << 'After run'
+      a << "After run"
 
       slow_thread.join
 
-      a.must_equal ['Before run', 'During run', 'After run']
+      _(a).must_equal ["Before run", "During run", "After run"]
     end
 
-    it 'raises and quits on exceptions in callbacks' do
+    it "raises and quits on exceptions in callbacks" do
       main_loop = GLib::MainLoop.new nil, false
 
-      a = 'expected'
+      a = "expected"
 
       # This timeout shouldn't get called
       guard = GLib.timeout_add GLib::PRIORITY_DEFAULT, 150 do
-        a = 'unexpected'
+        a = "unexpected"
         main_loop.quit
       end
 
@@ -43,8 +43,8 @@ describe GLib::MainLoop do
         raise MainLoopTestException
       end
 
-      -> { main_loop.run }.must_raise MainLoopTestException
-      a.must_equal 'expected'
+      _(-> { main_loop.run }).must_raise MainLoopTestException
+      _(a).must_equal "expected"
 
       # Clean up uncalled timeout
       GLib.source_remove guard

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)