gir_ffi 0.10.2 → 0.11.0

data/lib/gir_ffi-base/gobject/lib.rb

@@ -7,7 +7,6 @@ module GObject
     extend FFI::Library
     extend FFI::BitMasks
     ffi_lib 'gobject-2.0'
-    attach_function :g_type_init, [], :void
     attach_function :g_type_from_name, [:string], :size_t
     attach_function :g_type_fundamental, [:size_t], :size_t
   end

data/lib/gir_ffi-base/gobject.rb

@@ -5,12 +5,10 @@ raise 'The module GObject was already defined elsewhere' if Kernel.const_defined
 
 require 'gir_ffi-base/gobject/lib'
 
-# The part of the GObject namespace that is needed by GObjectIntrospection.
+# The part of the GObject namespace that is needed by GirFFI.
+#
+# :reek:TooManyConstants: because it needs to hold the type constants.
 module GObject
-  def self.type_init
-    Lib.g_type_init
-  end
-
   def self.type_from_name(name)
     Lib.g_type_from_name name
   end

data/lib/gir_ffi-base.rb

@@ -1,12 +1,7 @@
 # frozen_string_literal: true
 #
-# This section contains code that is needed by GObjectIntrospection and GirFFI,
-# but belongs in modules that can only be created fully once GirFFI is fully
-# loaded.
+# This section contains code that is needed by GirFFI, but belongs in modules
+# that can only be created fully once GirFFI is fully loaded.
 
-# GLib::Strv and GObject.type_init are needed by GObjectIntrospection
-require 'gir_ffi-base/glib/strv'
+# Some base GObject functions and constants are needed by GirFFI.
 require 'gir_ffi-base/gobject'
-
-# GLib::Boolean is needed by GirFFI.
-require 'gir_ffi-base/glib/boolean'

data/tasks/test.rake

@@ -132,8 +132,7 @@ namespace :test do
   end
 
   define_test_task(:main) do |t|
-    t.test_files = FileList['test/gir_ffi_test.rb',
-                            'test/gir_ffi/**/*_test.rb']
+    t.test_files = FileList['test/gir_ffi/**/*_test.rb']
   end
 
   define_test_task(:overrides) do |t|
@@ -190,6 +189,22 @@ namespace :test do
   Cucumber::Rake::Task.new(:features) do |t|
     t.cucumber_opts = 'features --format pretty'
   end
+
+  desc 'Run mutant'
+
+  task mutant: :lib do
+    command = <<-EOS
+      RUBY_THREAD_VM_STACK_SIZE=64000 \
+      bundle exec mutant \
+        --include lib \
+        --include test \
+        --use minitest \
+        --since master \
+        --jobs 4 \
+        "GirFFI*" "GObject*" "GObjectIntrospection*" "GLib*"
+    EOS
+    system command
+  end
 end
 
 file "test/lib/Makefile" => "test/lib/configure" do
@@ -201,4 +216,3 @@ file "test/lib/configure" => ["test/lib/autogen.sh", "test/lib/configure.ac"] do
 end
 
 task test: 'test:all'
-task test: 'test:features'

data/test/base_test_helper.rb

@@ -15,29 +15,8 @@ begin
 rescue LoadError
 end
 
-require 'minitest/rspec_mocks'
 require 'minitest/autorun'
-
-require 'gir_ffi-base'
-require 'ffi-gobject_introspection'
-
-GObjectIntrospection::IRepository.prepend_search_path File.join(File.dirname(__FILE__), 'lib')
-
-module GObjectIntrospection
-  class IRepository
-    def shared_library_with_regress(namespace)
-      case namespace
-      when 'Everything', 'GIMarshallingTests', 'Regress', 'Utility', 'WarnLib'
-        return File.join(File.dirname(__FILE__), 'lib', "lib#{namespace.downcase}.so")
-      else
-        return shared_library_without_regress namespace
-      end
-    end
-
-    alias_method :shared_library_without_regress, :shared_library
-    alias_method :shared_library, :shared_library_with_regress
-  end
-end
+require 'rspec/mocks/minitest_integration'
 
 Thread.abort_on_exception = true
 
@@ -82,4 +61,41 @@ module BaseTestExtensions
 end
 
 Minitest::Test.send :include, BaseTestExtensions
-Minitest::Test.send :include, Minitest::RSpecMocks
+
+# Provide methods needed for integration with mutant
+module ForMutant
+  # Mark the current test class as covering the given expression.
+  def cover(expression)
+    @expression = expression
+  end
+
+  # Return the currently set covering expression.
+  def covering
+    defined?(@expression) && @expression
+  end
+
+  # Return the cover expression, but raise an exception if it is not defined.
+  # This is the method used by mutant to fetch the coverage information.
+  def cover_expression
+    raise "Cover expression for #{self} is not specified" unless @expression
+    @expression
+  end
+end
+
+Minitest::Test.send :extend, ForMutant
+
+def cover_expression_for(cls)
+  full_stack = cls.describe_stack.dup << cls
+  full_stack.reverse_each do |level|
+    return level.covering if level.covering
+    return level.desc.to_s if level.desc.is_a? Module
+  end
+  full_stack.first.desc.to_s
+end
+
+# Override describe to automatically set cover information
+def describe(desc, *additional_desc, &block)
+  super.tap do |cls|
+    cls.cover cover_expression_for(cls) unless cls.covering
+  end
+end

data/test/ffi-glib/closure_test.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require 'gir_ffi_test_helper'
+
+describe GObject::Closure do
+  describe '.new' do
+    it 'updates the ref_count of the created object' do
+      # Tested on a subclass ...
+      c = GObject::RubyClosure.new {}
+      c.ref_count.must_equal 1
+    end
+  end
+
+  describe '#invoke' do
+    it 'invokes the closure' do
+      a = 0
+      c = GObject::RubyClosure.new { a = 2 }
+      c2 = GObject::Closure.wrap(c.to_ptr)
+      c2.invoke nil, []
+      a.must_equal 2
+    end
+
+    it 'returns the closure result' do
+      c = GObject::RubyClosure.new { 3 }
+      c2 = GObject::Closure.wrap(c.to_ptr)
+      result = c2.invoke GObject::Value.for_gtype(GObject::TYPE_INT), []
+      result.must_equal 3
+    end
+
+    it 'passes arguments' do
+      a = 0
+      c = GObject::RubyClosure.new { |val| a = val }
+      c2 = GObject::Closure.wrap(c.to_ptr)
+      c2.invoke nil, [5]
+      a.must_equal 5
+    end
+  end
+end

data/test/ffi-glib/main_loop_test.rb

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

data/test/ffi-glib/ruby_closure_test.rb

@@ -13,11 +13,6 @@ describe GObject::RubyClosure do
       c = GObject::RubyClosure.new {}
       assert_kind_of GObject::Closure, c
     end
-
-    it 'updates the ref_count of the created object' do
-      c = GObject::RubyClosure.new {}
-      c.ref_count.must_equal 1
-    end
   end
 
   describe '.wrap' do

data/test/ffi-gobject/object_test.rb

@@ -119,23 +119,19 @@ describe GObject::Object do
   end
 
   describe 'upon garbage collection' do
-    # FIXME: Test this some other way
     it 'lowers the reference count' do
-      if defined?(RUBY_ENGINE) && %w(jruby rbx).include?(RUBY_ENGINE)
+      if jruby? || rubinius?
         skip 'cannot be reliably tested on JRuby and Rubinius'
       end
-      if RUBY_VERSION >= '2.3.0'
-        skip 'cannot be reliably tested on CRuby >= 2.3'
-      end
 
-      object = GObject::Object.new
-      ptr = object.to_ptr
+      ptr = GObject::Object.new.to_ptr
       ref_count(ptr).must_equal 1
 
-      # Lose reference to object to allow garbage collection
-      object = nil # rubocop:disable Lint/UselessAssignment
-
       GC.start
+      # Creating a new object is sometimes needed to trigger enough garbage collection.
+      GObject::Object.new
+      sleep 1
+
       GC.start
       GC.start
 

data/test/ffi-gobject/param_spec_test.rb

@@ -3,16 +3,28 @@ require 'gir_ffi_test_helper'
 
 require 'ffi-gobject'
 describe GObject::ParamSpec do
+  let(:pspec) do
+    GObject.param_spec_int('foo-bar', 'foo bar',
+                           'Foo Bar',
+                           1, 3, 2,
+                           readable: true, writable: true)
+  end
+
   describe '#ref' do
     it 'increases the ref count' do
-      pspec = GObject.param_spec_boolean('foo', 'foo bar',
-                                         'Boolean Foo Bar',
-                                         false,
-                                         readable: true, writable: true)
-
       old = pspec.ref_count
       pspec.ref
       pspec.ref_count.must_equal old + 1
     end
   end
+
+  describe '#accessor_name' do
+    it 'returns a safe ruby method name' do
+      pspec.accessor_name.must_equal 'foo_bar'
+    end
+  end
+
+  it 'cannot be instantiated directly' do
+    proc { GObject::ParamSpec.new }.must_raise NoMethodError
+  end
 end

data/test/ffi-gobject/value_test.rb

@@ -256,7 +256,7 @@ describe GObject::Value do
       gv.get_value.must_equal value
     end
 
-    it 'unwraps a ulong' do
+    it 'unwraps an ulong' do
       value = FFI.type_size(:long) == 8 ? 0x1234_5678_9012_3456 : 0x1234_5678
       gv = GObject::Value.for_gtype GObject::TYPE_ULONG
       gv.set_ulong value
@@ -291,6 +291,17 @@ describe GObject::Value do
       result.must_be_kind_of GLib::Array
       result.reset_typespec(:uint).to_a.must_equal [1, 2, 3]
     end
+
+    it 'unwraps a Strv' do
+      strv = GLib::Strv.from %w(foo bar)
+      val = GObject::Value.for_gtype GObject::TYPE_STRV
+      val.set_boxed strv
+
+      result = val.get_value
+
+      result.must_be_kind_of GLib::Strv
+      result.to_a.must_equal %w(foo bar)
+    end
   end
 
   describe '::from' do
@@ -334,12 +345,8 @@ describe GObject::Value do
   end
 
   describe 'upon garbage collection' do
-    before do
-      GirFFI.setup :GIMarshallingTests
-    end
-
     it 'restores the underlying GValue to its pristine state' do
-      if defined?(RUBY_ENGINE) && %w(jruby rbx).include?(RUBY_ENGINE)
+      if jruby? || rubinius?
         skip 'cannot be reliably tested on JRuby and Rubinius'
       end
 
@@ -350,6 +357,8 @@ describe GObject::Value do
       value.current_gtype_name.must_equal 'gint'
 
       GC.start
+      # Creating a new object is sometimes needed to trigger enough garbage collection.
+      GObject::Value.new
       sleep 1
       GC.start
       GC.start

data/test/ffi-gobject_introspection/gobject_type_init_test.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require 'introspection_test_helper'
+
+describe GObjectIntrospection::GObjectTypeInit do
+  describe 'Lib' do
+    it 'represents the gobject-2.0 library' do
+      GObjectIntrospection::GObjectTypeInit::Lib.ffi_libraries.first.name.
+        must_match(/gobject-2\.0/)
+    end
+
+    it 'provides the g_type_init function' do
+      GObjectIntrospection::GObjectTypeInit::Lib.must_respond_to :g_type_init
+    end
+  end
+
+  describe '.type_init' do
+    it 'calls the g_type_init function from the gobject-2.0 library' do
+      allow(GObjectIntrospection::GObjectTypeInit::Lib).to receive(:g_type_init)
+
+      GObjectIntrospection::GObjectTypeInit.type_init
+
+      expect(GObjectIntrospection::GObjectTypeInit::Lib).to have_received(:g_type_init)
+    end
+  end
+end

data/test/ffi-gobject_introspection/i_base_info_test.rb

@@ -32,7 +32,7 @@ describe GObjectIntrospection::IBaseInfo do
 
   describe 'upon garbage collection' do
     it 'calls g_base_info_unref' do
-      if defined?(RUBY_ENGINE) && %w(jruby rbx).include?(RUBY_ENGINE)
+      if jruby? || rubinius?
         skip 'cannot be reliably tested on JRuby and Rubinius'
       end
 

data/test/ffi-gobject_introspection/i_repository_test.rb

@@ -58,4 +58,22 @@ describe GObjectIntrospection::IRepository do
       assert_kind_of GObjectIntrospection::IBaseInfo, gir.info('GObject', 0)
     end
   end
+
+  describe '#dependencies' do
+    it 'returns a list of dependencies of the given namespace' do
+      result = gir.dependencies('GObject')
+      result.must_equal ['GLib-2.0']
+    end
+
+    it 'passes its struct pointer to the c function just in case' do
+      ptr = gir.instance_variable_get(:@gobj)
+      allow(GObjectIntrospection::Lib).to receive(:g_irepository_get_dependencies).
+        and_call_original
+
+      gir.dependencies('GObject')
+
+      expect(GObjectIntrospection::Lib).to have_received(:g_irepository_get_dependencies).
+        with(ptr, 'GObject')
+    end
+  end
 end

data/test/ffi-gobject_introspection/i_vfunc_info_test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require 'introspection_test_helper'
+
+describe GObjectIntrospection::IVFuncInfo do
+  let(:vfunc_info) do
+    get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'method_int8_in'
+  end
+
+  let(:throwing_vfunc_info) do
+    get_vfunc_introspection_data 'GIMarshallingTests', 'Object', 'vfunc_meth_with_err'
+  end
+
+  let(:vfunc_info_with_different_invoker) do
+    get_vfunc_introspection_data 'Regress', 'TestObj', 'matrix'
+  end
+
+  describe '#throws?' do
+    it 'returns false if there is no error argument' do
+      vfunc_info.wont_be :throws?
+    end
+
+    it 'returns true if there is and error argument' do
+      throwing_vfunc_info.must_be :throws?
+    end
+  end
+
+  describe '#invoker' do
+    it 'returns nil if no invoker method is present' do
+      throwing_vfunc_info.invoker.must_be_nil
+    end
+
+    it 'returns info for the invoker method if present' do
+      vfunc_info.invoker.name.must_equal 'method_int8_in'
+    end
+
+    it 'returns the correct invoker even if named differently' do
+      vfunc_info_with_different_invoker.invoker.name.must_equal 'do_matrix'
+    end
+  end
+end

data/test/{gir_ffi-base/glib → ffi-gobject_introspection}/strv_test.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 require 'base_test_helper'
 
-describe GLib::Strv do
+describe GObjectIntrospection::Strv do
   it 'wraps a pointer' do
-    strv = GLib::Strv.new :some_pointer
+    strv = GObjectIntrospection::Strv.new :some_pointer
     assert_equal :some_pointer, strv.to_ptr
   end
 
   describe '::wrap' do
-    it 'takes a pointer and returns a GLib::Strv wrapping it' do
-      strv = GLib::Strv.wrap :some_pointer
-      assert_instance_of GLib::Strv, strv
+    it 'takes a pointer and returns a GObjectIntrospection::Strv wrapping it' do
+      strv = GObjectIntrospection::Strv.wrap :some_pointer
+      assert_instance_of GObjectIntrospection::Strv, strv
       assert_equal :some_pointer, strv.to_ptr
     end
   end
@@ -23,7 +23,7 @@ describe GLib::Strv do
       block = FFI::MemoryPointer.new(:pointer, ptrs.length)
       block.write_array_of_pointer ptrs
 
-      strv = GLib::Strv.new block
+      strv = GObjectIntrospection::Strv.new block
       arr = []
       strv.each do |str|
         arr << str
@@ -32,7 +32,7 @@ describe GLib::Strv do
     end
 
     it 'yields zero times for a Strv wrapping a null pointer' do
-      strv = GLib::Strv.new FFI::Pointer.new(0)
+      strv = GObjectIntrospection::Strv.new FFI::Pointer.new(0)
       strv.each do |_str|
         flunk
       end
@@ -40,6 +40,6 @@ describe GLib::Strv do
   end
 
   it 'includes Enumerable' do
-    GLib::Strv.must_include Enumerable
+    GObjectIntrospection::Strv.must_include Enumerable
   end
 end

data/test/gir_ffi/allocation_helper_test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require 'gir_ffi_test_helper'
+
+describe GirFFI::AllocationHelper do
+  describe '.free_after' do
+    before do
+      allow(GirFFI::LibC).to receive(:free)
+    end
+
+    it 'frees the passed-in pointer' do
+      ptr = double('pointer', null?: false)
+      GirFFI::AllocationHelper.free_after(ptr) {}
+      expect(GirFFI::LibC).to have_received(:free).with(ptr)
+    end
+
+    it 'does not free a passed-in null pointer' do
+      ptr = double('pointer', null?: true)
+      GirFFI::AllocationHelper.free_after(ptr) {}
+      expect(GirFFI::LibC).not_to have_received(:free)
+    end
+
+    it 'yields ptr to the block' do
+      ptr = double('pointer', null?: false)
+      foo = nil
+      GirFFI::AllocationHelper.free_after(ptr) { |it| foo = it }
+      foo.must_equal ptr
+    end
+
+    it 'returns the result of the block' do
+      ptr = double('pointer', null?: false)
+      result = GirFFI::AllocationHelper.free_after(ptr) { 'bar' }
+      result.must_equal 'bar'
+    end
+  end
+end

data/test/gir_ffi/arg_helper_test.rb

@@ -9,20 +9,87 @@ describe GirFFI::ArgHelper do
       GirFFI::ArgHelper.cast_from_pointer(klass, :pointer_value).must_equal :wrapped_value
     end
 
-    it 'handles negative :gint8' do
-      ptr = FFI::Pointer.new(-127)
-      GirFFI::ArgHelper.cast_from_pointer(:gint8, ptr).must_equal(-127)
-    end
+    describe 'for :gint8' do
+      it 'handles negative :gint8' do
+        ptr = FFI::Pointer.new(-127)
+        GirFFI::ArgHelper.cast_from_pointer(:gint8, ptr).must_equal(-127)
+      end
 
-    it 'handles positive :gint8' do
-      ptr = FFI::Pointer.new(128)
-      GirFFI::ArgHelper.cast_from_pointer(:gint8, ptr).must_equal(128)
+      it 'handles positive :gint8' do
+        ptr = FFI::Pointer.new(128)
+        GirFFI::ArgHelper.cast_from_pointer(:gint8, ptr).must_equal(128)
+      end
     end
 
     it 'handles :guint32' do
       ptr = FFI::Pointer.new(0xffffffff)
       GirFFI::ArgHelper.cast_from_pointer(:guint32, ptr).must_equal(0xffffffff)
     end
+
+    describe 'for :gint32' do
+      it 'handles positive :gint32' do
+        ptr = FFI::Pointer.new(1)
+        GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr).must_equal(1)
+      end
+
+      it 'handles negative :gint32' do
+        ptr = FFI::Pointer.new(0xffffffff)
+        GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr).must_equal(-1)
+      end
+
+      it 'handles largest negative :gint32' do
+        ptr = FFI::Pointer.new(0x80000000)
+        GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr).must_equal(-0x80000000)
+      end
+
+      it 'handles largest positive :gint32' do
+        ptr = FFI::Pointer.new(0x7fffffff)
+        GirFFI::ArgHelper.cast_from_pointer(:gint32, ptr).must_equal(0x7fffffff)
+      end
+    end
+
+    it 'handles :utf8' do
+      ptr = FFI::MemoryPointer.from_string 'foo'
+      GirFFI::ArgHelper.cast_from_pointer(:utf8, ptr).must_equal 'foo'
+    end
+
+    it 'handles :filename' do
+      ptr = FFI::MemoryPointer.from_string 'foo'
+      GirFFI::ArgHelper.cast_from_pointer(:filename, ptr).must_equal 'foo'
+    end
+
+    it 'handles GHashTable' do
+      hash = GLib::HashTable.from [:utf8, :gint32], 'foo' => 1, 'bar' => 2
+      ptr = hash.to_ptr
+      result = GirFFI::ArgHelper.cast_from_pointer([:pointer, [:ghash, :utf8, :gint32]], ptr)
+      result.to_hash.must_equal hash.to_hash
+    end
+
+    describe 'when passing a broken typespec' do
+      it 'raises on unknown symbol' do
+        ptr = FFI::Pointer.new(0xffffffff)
+        exception = -> { GirFFI::ArgHelper.cast_from_pointer(:foo, ptr) }.must_raise
+        exception.message.must_equal "Don't know how to cast foo"
+      end
+
+      it 'raises on unexpected main type for complex type' do
+        ptr = FFI::Pointer.new(0xffffffff)
+        exception = -> { GirFFI::ArgHelper.cast_from_pointer([:utf8], ptr) }.must_raise
+        exception.message.must_equal "Don't know how to cast [:utf8]"
+      end
+
+      it 'raises on unexpected sub type for complex type' do
+        ptr = FFI::Pointer.new(0xffffffff)
+        exception = -> { GirFFI::ArgHelper.cast_from_pointer([:pointer, :utf8], ptr) }.must_raise
+        exception.message.must_equal "Don't know how to cast [:pointer, :utf8]"
+      end
+
+      it 'raises on unexpected container type for complex type' do
+        ptr = FFI::Pointer.new(0xffffffff)
+        exception = -> { GirFFI::ArgHelper.cast_from_pointer([:pointer, [:gint32]], ptr) }.must_raise
+        exception.message.must_equal "Don't know how to cast [:pointer, [:gint32]]"
+      end
+    end
   end
 
   describe '.store' do
@@ -41,4 +108,32 @@ describe GirFFI::ArgHelper do
       end
     end
   end
+
+  describe '.check_fixed_array_size' do
+    it 'passes if array has the correct size' do
+      GirFFI::ArgHelper.check_fixed_array_size(3, [1, 2, 3], 'foo')
+      pass
+    end
+
+    it 'raises if array does not have the correct size' do
+      result = lambda do
+        GirFFI::ArgHelper.check_fixed_array_size(3, [1, 2], 'foo')
+      end.must_raise ArgumentError
+      result.message.must_equal 'foo should have size 3'
+    end
+  end
+
+  describe '.check_error' do
+    it 'does nothing if there is no error' do
+      err_ptr = double('err_ptr', read_pointer: nil)
+      GirFFI::ArgHelper.check_error err_ptr
+      pass
+    end
+
+    it 'raises an exception if there is an error' do
+      err = GLib::Error.new
+      err_ptr = double('err_ptr', read_pointer: err.to_ptr)
+      -> { GirFFI::ArgHelper.check_error err_ptr }.must_raise GirFFI::GLibError
+    end
+  end
 end