gir_ffi 0.14.0 → 0.15.3

data/test/integration/generated_secret_test.rb

@@ -1,17 +1,14 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
-describe 'The generated Secret module' do
-  describe 'Secret::Schema' do
-    it 'has a working constructor' do
-      begin
-        GirFFI.setup :Secret
-      rescue RuntimeError
-        skip 'No GIR data for Secret available'
-      end
-      instance = Secret::Schema.new('foo', :none, 'bar' => :string)
-      instance.must_be_instance_of Secret::Schema
+GirFFI.setup :Secret
+
+describe "The generated Secret module" do
+  describe "Secret::Schema" do
+    it "has a working constructor" do
+      instance = Secret::Schema.new("foo", :none, "bar" => :string)
+      _(instance).must_be_instance_of Secret::Schema
     end
   end
 end

data/test/integration/generated_utility_test.rb

@@ -1,174 +1,174 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 GirFFI.setup :Utility
 
 describe Utility do
-  describe 'Utility::Buffer' do
+  describe "Utility::Buffer" do
     let(:instance) { Utility::Buffer.new }
 
-    it 'has a writable field data' do
-      instance.data.must_equal FFI::Pointer::NULL
+    it "has a writable field data" do
+      _(instance.data).must_equal FFI::Pointer::NULL
       instance.data = FFI::Pointer.new 54_321
-      instance.data.must_equal FFI::Pointer.new 54_321
+      _(instance.data).must_equal FFI::Pointer.new 54_321
     end
 
-    it 'has a writable field length' do
-      instance.length.must_equal 0
+    it "has a writable field length" do
+      _(instance.length).must_equal 0
       instance.length = 42
-      instance.length.must_equal 42
+      _(instance.length).must_equal 42
     end
   end
 
-  describe 'Utility::Byte' do
+  describe "Utility::Byte" do
     let(:instance) { Utility::Byte.new }
 
-    it 'has a writable field value' do
-      instance.value.must_equal 0
+    it "has a writable field value" do
+      _(instance.value).must_equal 0
       instance.value = 42
-      instance.value.must_equal 42
+      _(instance.value).must_equal 42
     end
 
-    it 'has a writable field first_nibble' do
-      skip 'This field is not exposed in the GIR'
+    it "has a writable field first_nibble" do
+      skip "This field is not exposed in the GIR"
       instance.value = 0xAB
-      instance.first_nibble.must_equal 0xA
+      _(instance.first_nibble).must_equal 0xA
       instance.first_nibble = 0x4
-      instance.value.must_equal 0x4B
+      _(instance.value).must_equal 0x4B
     end
 
-    it 'has a writable field second_nibble' do
-      skip 'This field is not exposed in the GIR'
+    it "has a writable field second_nibble" do
+      skip "This field is not exposed in the GIR"
       instance.value = 0xAB
-      instance.second_nibble.must_equal 0xB
+      _(instance.second_nibble).must_equal 0xB
       instance.second_nibble = 0x4
-      instance.value.must_equal 0xA4
+      _(instance.value).must_equal 0xA4
     end
   end
 
-  describe 'Utility::EnumType' do
-    it 'has the member :a' do
-      Utility::EnumType[:a].must_equal 0
+  describe "Utility::EnumType" do
+    it "has the member :a" do
+      _(Utility::EnumType[:a]).must_equal 0
     end
 
-    it 'has the member :b' do
-      Utility::EnumType[:b].must_equal 1
+    it "has the member :b" do
+      _(Utility::EnumType[:b]).must_equal 1
     end
 
-    it 'has the member :c' do
-      Utility::EnumType[:c].must_equal 2
+    it "has the member :c" do
+      _(Utility::EnumType[:c]).must_equal 2
     end
   end
 
-  describe 'Utility::FlagType' do
-    it 'has the member :a' do
-      Utility::FlagType[:a].must_equal 1
+  describe "Utility::FlagType" do
+    it "has the member :a" do
+      _(Utility::FlagType[:a]).must_equal 1
     end
 
-    it 'has the member :b' do
-      Utility::FlagType[:b].must_equal 2
+    it "has the member :b" do
+      _(Utility::FlagType[:b]).must_equal 2
     end
 
-    it 'has the member :c' do
-      Utility::FlagType[:c].must_equal 4
+    it "has the member :c" do
+      _(Utility::FlagType[:c]).must_equal 4
     end
   end
 
-  describe 'Utility::Object' do
+  describe "Utility::Object" do
     let(:instance) { Utility::Object.new }
 
-    it 'has a working method #watch_dir' do
+    it "has a working method #watch_dir" do
       # This method doesn't actually do anything
-      instance.watch_dir('/') {}
+      instance.watch_dir("/") {}
       pass
     end
   end
 
-  describe 'Utility::Struct' do
+  describe "Utility::Struct" do
     let(:instance) { Utility::Struct.new }
 
-    it 'has a writable field field' do
-      instance.field.must_equal 0
+    it "has a writable field field" do
+      _(instance.field).must_equal 0
       instance.field = 42
-      instance.field.must_equal 42
+      _(instance.field).must_equal 42
     end
 
-    it 'has a writable field bitfield1' do
-      skip 'Bitfield bit width is not implemented yet'
-      instance.bitfield1.must_equal 0
+    it "has a writable field bitfield1" do
+      skip "Bitfield bit width is not implemented yet"
+      _(instance.bitfield1).must_equal 0
       instance.bitfield1 = 15
-      instance.bitfield1.must_equal 7
+      _(instance.bitfield1).must_equal 7
     end
 
-    it 'has a writable field bitfield2' do
-      skip 'Bitfield bit width is not implemented yet'
-      instance.bitfield2.must_equal 0
+    it "has a writable field bitfield2" do
+      skip "Bitfield bit width is not implemented yet"
+      _(instance.bitfield2).must_equal 0
       instance.bitfield2 = 15
-      instance.bitfield2.must_equal 3
+      _(instance.bitfield2).must_equal 3
     end
 
-    it 'has a writable field data' do
-      instance.data.to_a.must_equal [0] * 16
+    it "has a writable field data" do
+      _(instance.data.to_a).must_equal [0] * 16
     end
   end
 
-  describe 'Utility::TaggedValue' do
+  describe "Utility::TaggedValue" do
     let(:instance) { Utility::TaggedValue.new }
 
-    it 'has a writable field tag' do
-      instance.tag.must_equal 0
+    it "has a writable field tag" do
+      _(instance.tag).must_equal 0
       instance.tag = 42
-      instance.tag.must_equal 42
+      _(instance.tag).must_equal 42
     end
 
-    it 'has a writable field v_pointer' do
-      skip 'This field is not exposed in the GIR'
-      instance.v_pointer.must_equal FFI::Pointer::NULL
+    it "has a writable field v_pointer" do
+      skip "This field is not exposed in the GIR"
+      _(instance.v_pointer).must_equal FFI::Pointer::NULL
       instance.v_pointer = FFI::Pointer.new(4321)
-      instance.v_pointer.must_equal FFI::Pointer.new(4321)
+      _(instance.v_pointer).must_equal FFI::Pointer.new(4321)
     end
 
-    it 'has a writable field v_real' do
-      skip 'This field is not exposed in the GIR'
-      instance.v_real.must_equal 0.0
+    it "has a writable field v_real" do
+      skip "This field is not exposed in the GIR"
+      _(instance.v_real).must_equal 0.0
       instance.v_real = 42.23
-      instance.v_real.must_equal 42.23
+      _(instance.v_real).must_equal 42.23
     end
 
-    it 'has a writable field v_integer' do
-      skip 'This field is not exposed in the GIR'
-      instance.v_integer.must_equal 0
+    it "has a writable field v_integer" do
+      skip "This field is not exposed in the GIR"
+      _(instance.v_integer).must_equal 0
       instance.v_integer = 42
-      instance.v_integer.must_equal 42
+      _(instance.v_integer).must_equal 42
     end
   end
 
-  describe 'Utility::Union' do
+  describe "Utility::Union" do
     let(:instance) { Utility::Union.new }
 
-    it 'has a writable field pointer' do
-      instance.pointer.must_be_nil
-      instance.pointer = 'hello 42'
-      instance.pointer.must_equal 'hello 42'
+    it "has a writable field pointer" do
+      _(instance.pointer).must_be_nil
+      instance.pointer = "hello 42"
+      _(instance.pointer).must_equal "hello 42"
     end
 
-    it 'has a writable field integer' do
-      instance.integer.must_equal 0
+    it "has a writable field integer" do
+      _(instance.integer).must_equal 0
       instance.integer = 42
-      instance.integer.must_equal 42
+      _(instance.integer).must_equal 42
     end
 
-    it 'has a writable field real' do
-      instance.real.must_equal 0.0
+    it "has a writable field real" do
+      _(instance.real).must_equal 0.0
       instance.real = 42.23
-      instance.real.must_equal 42.23
+      _(instance.real).must_equal 42.23
     end
   end
 
-  it 'has a working function #dir_foreach' do
+  it "has a working function #dir_foreach" do
     # This method doesn't actually do anything
-    result = Utility.dir_foreach('/') {}
-    result.must_be_nil
+    result = Utility.dir_foreach("/") {}
+    _(result).must_be_nil
   end
 end

data/test/integration/generated_warnlib_test.rb

@@ -1,17 +1,11 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
-
-describe 'The generated WarnLib module' do
-  before do
-    begin
-      GirFFI.setup :WarnLib
-    rescue RuntimeError
-      skip 'WarnLib GIR not available'
-    end
-  end
+require "gir_ffi_test_helper"
+
+GirFFI.setup :WarnLib
 
-  describe 'WarnLib::Whatever' do
+describe "The generated WarnLib module" do
+  describe "WarnLib::Whatever" do
     let(:derived_klass) do
       Object.const_set("DerivedClass#{Sequence.next}", Class.new(GObject::Object))
     end
@@ -20,30 +14,32 @@ describe 'The generated WarnLib module' do
       @result = nil
       derived_klass.class_eval { include WarnLib::Whatever }
       GirFFI.define_type derived_klass do |info|
-        info.install_vfunc_implementation :do_boo, proc { |_obj, x, _y| @result = "boo#{x}" }
-        info.install_vfunc_implementation :do_moo, proc { |_obj, x, _y| @result = "moo#{x}" }
+        info.install_vfunc_implementation :do_boo,
+                                          proc { |_obj, x, _y| @result = "boo#{x}" }
+        info.install_vfunc_implementation :do_moo,
+                                          proc { |_obj, x, _y| @result = "moo#{x}" }
       end
     end
 
     let(:instance) { derived_klass.new }
 
-    it 'has a working method #do_boo' do
+    it "has a working method #do_boo" do
       instance.do_boo 42, nil
-      @result.must_equal 'boo42'
+      _(@result).must_equal "boo42"
     end
 
-    it 'has a working method #do_moo' do
+    it "has a working method #do_moo" do
       instance.do_moo 23, nil
-      @result.must_equal 'moo23'
+      _(@result).must_equal "moo23"
     end
   end
 
-  it 'has a working function #throw_unpaired' do
-    proc { WarnLib.throw_unpaired }.must_raise GirFFI::GLibError
+  it "has a working function #throw_unpaired" do
+    _(proc { WarnLib.throw_unpaired }).must_raise GirFFI::GLibError
   end
 
-  it 'has a working function #unpaired_error_quark' do
+  it "has a working function #unpaired_error_quark" do
     result = WarnLib.unpaired_error_quark
-    GLib.quark_to_string(result).must_equal 'warnlib-unpaired-error'
+    _(GLib.quark_to_string(result)).must_equal "warnlib-unpaired-error"
   end
 end

data/test/integration/method_lookup_test.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require 'gir_ffi_test_helper'
+require "gir_ffi_test_helper"
 
 # Tests how methods are looked up and generated on first use.
-describe 'Looking up methods' do
+describe "Looking up methods" do
   before do
     save_module :Regress
     GirFFI.setup :Regress
   end
 
-  describe 'an instance method' do
-    it 'is found from a subclass' do
+  describe "an instance method" do
+    it "is found from a subclass" do
       assert_defines_instance_method Regress::TestObj, :forced_method
       refute_defines_instance_method Regress::TestSubObj, :forced_method
 
@@ -19,8 +19,8 @@ describe 'Looking up methods' do
     end
   end
 
-  describe 'a class method' do
-    it 'is found from a subclass' do
+  describe "a class method" do
+    it "is found from a subclass" do
       assert_defines_singleton_method Regress::TestObj, :static_method
       refute_defines_singleton_method Regress::TestSubObj, :static_method
 

data/test/introspection_test_helper.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require 'base_test_helper'
+require "base_test_helper"
 
-require 'ffi-gobject_introspection'
+require "ffi-gobject_introspection"
 
-GObjectIntrospection::IRepository.prepend_search_path File.join(File.dirname(__FILE__), 'lib')
+GObjectIntrospection::IRepository
+  .prepend_search_path File.join(File.dirname(__FILE__), "lib")
 
 module LocalSharedLibrary
   def shared_library(namespace)
     case namespace
-    when 'Everything', 'GIMarshallingTests', 'Regress', 'Utility', 'WarnLib'
-      File.join(File.dirname(__FILE__), 'lib', "lib#{namespace.downcase}.so")
+    when "Everything", "GIMarshallingTests", "Regress", "Utility", "WarnLib"
+      File.join(File.dirname(__FILE__), "lib", "lib#{namespace.downcase}.so")
     else
       super
     end
@@ -20,7 +21,9 @@ end
 GObjectIntrospection::IRepository.prepend LocalSharedLibrary
 
 module IntrospectionTestExtensions
-  module_function
+  class << self
+    attr_accessor :version
+  end
 
   def get_introspection_data(namespace, name)
     gir = GObjectIntrospection::IRepository.default
@@ -47,6 +50,45 @@ module IntrospectionTestExtensions
   def get_vfunc_introspection_data(namespace, klass, name)
     get_introspection_data(namespace, klass).find_vfunc name
   end
+
+  def skip_below(introduction_version)
+    unless LATEST_VERSION >= introduction_version
+      raise "Version #{introduction_version} is too new and would always be skipped"
+    end
+
+    skip "Introduced in #{introduction_version}" if introduction_version > version
+  end
+
+  def version
+    IntrospectionTestExtensions.version ||= calculate_version
+  end
+
+  VERSION_GUARDS = {
+    "1.61.1"  => %w(Regress TestObj emit_sig_with_error),
+    "1.59.4"  => %w(Regress test_array_struct_in_none),
+    "1.58.3"  => %w(Regress TestReferenceCounters),
+    "1.57.2"  => %w(Regress TestInterface emit_signal),
+    "1.55.2"  => %w(Regress FOO_FLAGS_SECOND_AND_THIRD),
+    "1.53.4"  => %w(Regress TestObj name_conflict),
+    "1.49.1"  => %w(Regress AnonymousUnionAndStruct),
+    "1.47.92" => %w(Regress get_variant),
+    "1.47.1"  => %w(Regress test_noptr_callback)
+  }.freeze
+
+  LATEST_VERSION = VERSION_GUARDS.keys.first
+
+  def calculate_version
+    VERSION_GUARDS.each do |version, (namespace, klass, methodname)|
+      result = if methodname
+                 get_method_introspection_data(namespace, klass, methodname)
+               else
+                 get_introspection_data(namespace, klass)
+               end
+      return version if result
+    end
+
+    "1.46.0" # Minimum supported version
+  end
 end
 
-Minitest::Test.send :include, IntrospectionTestExtensions
+Minitest::Test.include IntrospectionTestExtensions