gir_ffi 0.15.2 → 0.15.7

data/test/integration/generated_gio_test.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :Gio
-
-# Tests generated methods and functions in the Gio namespace.
-describe "The generated Gio module" do
-  describe "File#new_for_path, a method returning an interface," do
-    it "returns an object of a more specific class" do
-      file = Gio::File.new_for_path("/")
-      _(file.class.registered_ancestors).must_equal [file.class, Gio::File, GObject::Object]
-
-      refute_instance_of Gio::File, file
-      assert_includes file.class.registered_ancestors, Gio::File
-    end
-  end
-
-  describe "the result of #file_new_from_path" do
-    before do
-      @it = Gio.file_new_for_path("/")
-    end
-
-    it "is able to set up a method in a class that is not the first ancestor" do
-      refute_defines_instance_method @it.class, :get_qdata
-      refute_defines_instance_method Gio::File, :get_qdata
-      assert_defines_instance_method GObject::Object, :get_qdata
-
-      @it.setup_and_call :get_qdata, 1
-    end
-
-    it "knows its GType" do
-      instance_gtype = GObject.type_from_instance @it
-      _(@it.class.gtype).must_equal instance_gtype
-    end
-  end
-
-  describe "the FileInfo class" do
-    describe "an instance" do
-      before do
-        file = Gio.file_new_for_path("/")
-        @fileinfo = file.query_info "*", :none, nil
-      end
-
-      it "has a working #get_attribute_type method" do
-        type = @fileinfo.get_attribute_type "standard::display-name"
-        assert_equal :string, type
-      end
-    end
-  end
-
-  describe "the action-added signal" do
-    before do
-      @grp = Gio::SimpleActionGroup.new
-    end
-
-    it "correctly passes on the string parameter 'action_name'" do
-      a = nil
-      GObject.signal_connect @grp, "action-added" do |_grp, action_name, _user_data|
-        a = action_name
-      end
-      GObject.signal_emit @grp, "action-added", "foo"
-      assert_equal "foo", a
-    end
-  end
-
-  describe "the reply signal" do
-    before do
-      @mo = Gio::MountOperation.new
-    end
-
-    it "correctly passes on the enum parameter 'result'" do
-      a = nil
-      GObject.signal_connect @mo, "reply" do |_mnt, result, _user_data|
-        a = result
-      end
-      GObject.signal_emit @mo, "reply", :unhandled
-      assert_equal :unhandled, a
-    end
-  end
-
-  describe "the CharsetConverter class" do
-    it "includes two interfaces" do
-      klass = Gio::CharsetConverter
-      _(klass.included_interfaces).must_equal [Gio::Initable, Gio::Converter]
-    end
-
-    it "allows an instance to find the #reset method" do
-      cnv = Gio::CharsetConverter.new "utf8", "utf8"
-      cnv.reset
-      pass
-    end
-  end
-
-  describe "the SocketSourceFunc callback" do
-    it "can be cast to a native function" do
-      Gio::SocketSourceFunc.new { |*args| p args }.to_native
-    end
-  end
-
-  describe "Gio::SimpleAction" do
-    let(:simple_action) { Gio::SimpleAction.new("test", "d") }
-
-    it 'can read the property "state-type" with #get_property' do
-      _(simple_action.get_property("state-type")).must_be_nil
-    end
-
-    it 'can read the property "state-type" with #state_type' do
-      _(simple_action.state_type).must_be_nil
-    end
-
-    it 'cannot write the property "state-type" with #state_type=' do
-      _(simple_action).wont_respond_to :state_type=
-    end
-  end
-end

data/test/integration/generated_glib_test.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-# Tests generated classes, methods and functions in the GLib namespace.
-describe "The generated GLib module" do
-  it "can auto-generate the GLib::SOURCE_REMOVE constant" do
-    _(GLib::SOURCE_REMOVE).must_equal false
-  end
-end

data/test/integration/generated_gobject_test.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :Regress
-
-describe GObject do
-  describe ".type_interfaces" do
-    it "works, showing that returning an array of GType works" do
-      klass = GObject::TypeModule
-      ifcs = GObject.type_interfaces klass.gtype
-      assert_equal 1, ifcs.size
-    end
-  end
-
-  describe ".signal_set_va_marshaller" do
-    it "can be set up" do
-      result = GObject.setup_method "signal_set_va_marshaller"
-      _(result).must_equal true
-    end
-  end
-
-  describe GObject::TypeInfo do
-    let(:instance) { GObject::TypeInfo.new }
-    it "has a working field setter for class_init" do
-      instance.class_init = proc do |_object_class, _data|
-      end
-    end
-
-    it "has a working field getter for class_init" do
-      _(instance.class_init).must_be_nil
-      instance.class_init = proc do |_object_class, _data|
-      end
-      result = instance.class_init
-      _(result).wont_be_nil
-      _(result).must_be_instance_of FFI::Function
-    end
-  end
-
-  describe GObject::TypePlugin do
-    it "is implemented as a module" do
-      mod = GObject::TypePlugin
-      assert_instance_of Module, mod
-      refute_instance_of Class, mod
-    end
-  end
-
-  describe GObject::TypeModule do
-    it "has the GObject::TypePlugin module as an ancestor" do
-      klass = GObject::TypeModule
-      assert_includes klass.registered_ancestors, GObject::TypePlugin
-    end
-  end
-
-  describe GObject::ValueArray do
-    it "uses the constructor provided by GObject" do
-      instance = GObject::ValueArray.new 16
-      _(instance.n_prealloced).must_equal 16
-      _(instance.n_values).must_equal 0
-    end
-  end
-
-  describe GObject::SignalQuery do
-    it "works" do
-      GObject::SignalQuery.new
-      pass
-    end
-
-    it "uses the n_params field for the length of param_types" do
-      gtype = GObject::Object.gtype
-      signals = GObject.signal_list_ids gtype
-      signal_query = GObject.signal_query signals.first
-      _(signal_query.n_params).must_equal 1
-      _(signal_query.param_types.size).must_equal 1
-    end
-  end
-
-  describe GObject::Binding do
-    it "is created with GObject::Object#bind_property" do
-      source = Regress::TestObj.constructor
-      target = Regress::TestObj.constructor
-      binding = source.bind_property "double", target, "double", :default
-      _(binding).must_be_kind_of GObject::Binding
-    end
-
-    describe "an instance" do
-      let(:source) { Regress::TestObj.constructor }
-      let(:target) { Regress::TestObj.constructor }
-      let(:binding) { source.bind_property "double", target, "double", :default }
-
-      it 'can read the property "target-property" with #get_property' do
-        _(binding.get_property("target-property")).must_equal "double"
-      end
-
-      it 'can read the property "target-property" with #target_property' do
-        _(binding.target_property).must_equal "double"
-      end
-
-      it 'cannot write the property "target-property" with #target_property=' do
-        _(binding).wont_respond_to :target_property=
-      end
-    end
-  end
-
-  describe GObject::ParamSpec do
-    it "has a generated field accessor for #flags but not #get_flags method" do
-      pspec = GObject.param_spec_int("foo", "foo bar",
-                                     "The Foo Bar Property",
-                                     10, 20, 15,
-                                     3)
-      _(pspec).wont_respond_to :get_flags
-      _(pspec.method(:flags).original_name).must_equal :flags
-    end
-
-    it "aliases #get_name to #name instead of having a separate field accessor" do
-      pspec = GObject.param_spec_int("foo", "foo bar",
-                                     "The Foo Bar Property",
-                                     10, 20, 15,
-                                     3)
-      _(pspec).must_respond_to :get_name
-      _(pspec.method(:name).original_name).must_equal :get_name
-    end
-  end
-end

data/test/integration/generated_gst_test.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :Gst
-Gst.init []
-
-# Tests behavior of objects in the generated Gio namespace.
-describe "the generated Gst module" do
-  describe "Gst::FakeSink" do
-    let(:instance) { Gst::ElementFactory.make("fakesink", "sink") }
-
-    it "allows the handoff signal to be connected and emitted" do
-      a = nil
-      instance.signal_connect("handoff") { a = 10 }
-      GObject.signal_emit(instance, "handoff")
-      _(a).must_equal 10
-    end
-
-    it "correctly fetches the name" do
-      _(instance.name).must_equal "sink"
-    end
-
-    it "allows the can-activate-push property to be read" do
-      _(instance.get_property("can-activate-push")).must_equal true
-    end
-  end
-
-  describe "Gst::AutoAudioSink" do
-    let(:instance) { Gst::ElementFactory.make("autoaudiosink", "audiosink") }
-
-    it "correctly fetches the name" do
-      skip "Audio sink was not created" unless instance
-      _(instance.get_name).must_equal "audiosink"
-      _(instance.name).must_equal "audiosink"
-    end
-  end
-end

data/test/integration/generated_gtk_source_test.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :GtkSource
-
-# Tests behavior of objects in the generated GtkSource namespace.
-describe "The generated GtkSource module" do
-  describe "GtkSource::CompletionContext" do
-    let(:instance) { GtkSource::CompletionContext.new }
-
-    it "allows adding proposals" do
-      # Interface changed in GtkSourceView 3.24
-      proposals = if GtkSource::CompletionItem.instance_methods.include? :set_label
-                    Array.new(3) do |i|
-                      GtkSource::CompletionItem.new.tap do |item|
-                        item.label = "Proposal #{i}"
-                        item.text =  "Proposal #{i}"
-                        item.info = "blah #{i}"
-                      end
-                    end
-                  else
-                    [
-                      GtkSource::CompletionItem.new("Proposal 1", "Proposal 1", nil, "blah 1"),
-                      GtkSource::CompletionItem.new("Proposal 2", "Proposal 2", nil, "blah 2"),
-                      GtkSource::CompletionItem.new("Proposal 3", "Proposal 3", nil, "blah 3")
-                    ]
-                  end
-      instance.add_proposals nil, proposals, true
-    end
-  end
-end

data/test/integration/generated_gtop_test.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :GTop
-
-# Tests generated methods and functions in the GTop namespace. This namespace
-# contains types with bad names, like 'glibtop_cpu'.
-describe "The generated GTop module" do
-  describe "Glibtop" do
-    it "is a valid struct class" do
-      # Superclass is either BoxedBase or StructBase, depending on library
-      # versions. This means StructBase is always one of the ancestors.
-      assert GTop::Glibtop < GirFFI::StructBase
-    end
-
-    it "can be created using Glibtop.init" do
-      instance = GTop::Glibtop.init
-      _(instance).must_be_kind_of GTop::Glibtop
-    end
-  end
-end

data/test/integration/generated_pango_ft2_test.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :PangoFT2
-
-# Tests generated methods and functions in the PangoFT2 namespace.
-describe PangoFT2 do
-  describe PangoFT2::FontMap do
-    it "has a working method #load_font" do
-      font_map = PangoFT2::FontMap.new
-      context = font_map.create_context
-      font_description = Pango::FontDescription.new
-      font_map.load_font context, font_description
-    end
-  end
-end

data/test/integration/generated_pango_test.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :Pango
-
-# Tests generated methods and functions in the Pango namespace.
-describe Pango do
-  describe Pango::Language do
-    it "has a working method #get_scripts" do
-      lang = Pango::Language.from_string "ja"
-      result = lang.get_scripts
-
-      if result.is_a? GirFFI::SizedArray
-        scripts = result
-      else
-        ptr, size = *result
-        scripts = GirFFI::SizedArray.new Pango::Script, size, ptr
-      end
-
-      _(scripts).must_be :==, [:han, :katakana, :hiragana]
-    end
-  end
-end

data/test/integration/generated_regress_test.rb

@@ -1,4062 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :Regress
-
-class ConcreteDrawable < Regress::TestInheritDrawable
-end
-
-GirFFI.define_type ConcreteDrawable
-
-# Tests generated methods and functions in the Regress namespace.
-describe Regress do
-  describe Regress::Lib do
-    it "extends FFI::Library" do
-      _(Regress::Lib.singleton_class).must_be :include?, FFI::Library
-    end
-  end
-  it "has the constant ANNOTATION_CALCULATED_DEFINE" do
-    _(Regress::ANNOTATION_CALCULATED_DEFINE).must_equal 100
-  end
-  it "has the constant ANNOTATION_CALCULATED_LARGE" do
-    skip "Constant is marked with the wrong type"
-    _(Regress::ANNOTATION_CALCULATED_LARGE).must_equal 10_000_000_000
-  end
-  it "has the constant ANNOTATION_CALCULATED_LARGE_DIV" do
-    _(Regress::ANNOTATION_CALCULATED_LARGE_DIV).must_equal 1_000_000
-  end
-  describe "Regress::ATestError" do
-    it "has the member :code0" do
-      _(Regress::ATestError[:code0]).must_equal 0
-    end
-
-    it "has the member :code1" do
-      _(Regress::ATestError[:code1]).must_equal 1
-    end
-
-    it "has the member :code2" do
-      _(Regress::ATestError[:code2]).must_equal 2
-    end
-  end
-
-  describe "Regress::AnAnonymousUnion" do
-    let(:instance) { Regress::AnAnonymousUnion.new }
-
-    it "has a writable field x" do
-      _(instance.x).must_equal 0
-      instance.x = 42
-      _(instance.x).must_equal 42
-    end
-
-    it "has a writable field a" do
-      skip "Anonymous union fields are not exposed in the GIR data"
-    end
-
-    it "has a writable field padding" do
-      skip "Anonymous union fields are not exposed in the GIR data"
-    end
-  end
-
-  describe "Regress::AnnotationBitfield" do
-    it "has the member :foo" do
-      _(Regress::AnnotationBitfield[:foo]).must_equal 1
-    end
-
-    it "has the member :bar" do
-      _(Regress::AnnotationBitfield[:bar]).must_equal 2
-    end
-  end
-
-  describe "Regress::AnnotationFields" do
-    let(:instance) { Regress::AnnotationFields.new }
-
-    it "has a writable field field1" do
-      _(instance.field1).must_equal 0
-      instance.field1 = 42
-      _(instance.field1).must_equal 42
-    end
-
-    it "has a writable field arr" do
-      _(instance.arr).must_be_nil
-      instance.arr = [1, 2, 3]
-      # TODO: len should be set automatically
-      instance.len = 3
-      _(instance.arr.to_a).must_equal [1, 2, 3]
-      _(instance.len).must_equal 3
-    end
-
-    it "has a writable field len" do
-      skip "len should not be set independently"
-    end
-  end
-
-  describe "Regress::AnnotationObject" do
-    let(:instance) { Regress::AnnotationObject.new }
-
-    it "has an attribute org.example.Test" do
-      info = get_introspection_data("Regress", "AnnotationObject")
-      _(info.attribute("org.example.Test")).must_equal "cows"
-    end
-
-    it "has a working method #allow_none" do
-      _(instance.allow_none("hello!")).must_be_nil
-      _(instance.allow_none(nil)).must_be_nil
-      _(instance.allow_none).must_be_nil
-    end
-
-    it "has a working method #calleeowns" do
-      result, object = instance.calleeowns
-      _(result).must_equal 1
-      _(object).must_be_nil
-    end
-
-    it "has a working method #calleesowns" do
-      result, toown1, toown2 = instance.calleesowns
-      _(result).must_equal 1
-      _(toown1).must_be_nil
-      _(toown2).must_be_nil
-    end
-
-    it "has a working method #compute_sum" do
-      instance.compute_sum [1, 2, 3]
-      pass
-    end
-
-    it "has a working method #compute_sum_n" do
-      instance.compute_sum_n [1, 2, 3]
-      pass
-    end
-
-    it "has a working method #compute_sum_nz" do
-      instance.compute_sum_nz [1, 2, 3]
-      pass
-    end
-
-    it "has a working method #create_object" do
-      result = instance.create_object
-      _(result).must_equal instance
-    end
-
-    it "has a working method #do_not_use" do
-      # TODO: Handle deprecation
-      _(instance.do_not_use).must_be_nil
-    end
-
-    it "has a working method #extra_annos" do
-      info = get_method_introspection_data("Regress", "AnnotationObject", "extra_annos")
-      _(info.attribute("org.foobar")).must_equal "testvalue"
-
-      _(instance.extra_annos).must_be_nil
-    end
-
-    it "has a working method #foreach" do
-      a = 1
-      instance.foreach { a += 1 }
-      _(a).must_equal 1
-    end
-
-    it "has a working method #get_hash" do
-      result = instance.get_hash
-      hash = result.to_hash
-      _(hash["one"]).must_equal instance
-      _(hash["two"]).must_equal instance
-    end
-
-    it "has a working method #get_objects" do
-      list = instance.get_objects
-      _(list.to_a).must_equal [instance]
-    end
-
-    it "has a working method #get_strings" do
-      list = instance.get_strings
-      _(list.to_a).must_equal %w(bar regress_annotation)
-    end
-
-    it "has a working method #hidden_self" do
-      _(instance.hidden_self).must_be_nil
-    end
-
-    it "has a working method #in" do
-      # TODO: Automatically convert to pointer argument
-      ptr = FFI::MemoryPointer.new(:int, 1)
-      ptr.put_int 0, 2342
-      _(instance.in(ptr)).must_equal 2342
-    end
-
-    it "has a working method #inout" do
-      _(instance.inout(2342)).must_equal [2343, 2343]
-    end
-
-    it "has a working method #inout2" do
-      _(instance.inout2(2342)).must_equal [2343, 2343]
-    end
-
-    it "has a working method #inout3" do
-      _(instance.inout3(2342)).must_equal [2343, 2342]
-    end
-
-    it "has a working method #method" do
-      _(instance.method).must_equal 1
-    end
-
-    it "has a working method #notrans" do
-      _(instance.notrans).must_be_nil
-    end
-
-    it "has a working method #out" do
-      _(instance.out).must_equal [1, 2]
-    end
-
-    it "has a working method #parse_args" do
-      _(instance.parse_args(%w(one two)).to_a).must_equal %w(one two)
-    end
-
-    it "has a working method #set_data" do
-      # TODO: Explicitely allow or deny passing a string here.
-      _(instance.set_data([1, 2, 3])).must_be_nil
-    end
-
-    it "has a working method #set_data2" do
-      _(instance.set_data2([1, -2, 3])).must_be_nil
-    end
-
-    it "has a working method #set_data3" do
-      _(instance.set_data3([1, 2, 3])).must_be_nil
-    end
-
-    it "has a working method #string_out" do
-      _(instance.string_out).must_equal [false, nil]
-    end
-
-    it "has a working method #use_buffer" do
-      skip "Ingoing pointer argument conversion is not implemented yet"
-      _(instance.use_buffer(FFI::MemoryPointer.new(:void, 1))).must_be_nil
-    end
-
-    it "has a working method #watch_full" do
-      instance.watch {}
-    end
-
-    it "has a working method #with_voidp" do
-      # NOTE: Anything implementing #to_ptr could be passed in here
-      obj = Regress::AnnotationObject.new
-      _(instance.with_voidp(obj)).must_be_nil
-    end
-
-    describe "its 'function-property' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("function-property")).must_be_nil
-      end
-
-      it "can be retrieved with #function_property" do
-        _(instance.function_property).must_be_nil
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property("function-property", proc {})
-        # AnnotationObject doesn't actually store stuff
-        _(instance.function_property).must_be_nil
-      end
-
-      it "can be set with #function_property=" do
-        instance.function_property = proc {}
-        # AnnotationObject doesn't actually store stuff
-        _(instance.get_property("function-property")).must_be_nil
-      end
-    end
-
-    describe "its 'string-property' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("string-property")).must_be_nil
-      end
-
-      it "can be retrieved with #string_property" do
-        _(instance.string_property).must_be_nil
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property("string-property", "hello 42")
-        # AnnotationObject doesn't actually store stuff
-        _(instance.string_property).must_be_nil
-      end
-
-      it "can be set with #string_property=" do
-        instance.string_property = "hello 42"
-        # AnnotationObject doesn't actually store stuff
-        _(instance.get_property("string-property")).must_be_nil
-      end
-    end
-
-    describe "its 'tab-property' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("tab-property")).must_be_nil
-      end
-
-      it "can be retrieved with #tab_property" do
-        _(instance.tab_property).must_be_nil
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property("tab-property", "hello 42")
-        # AnnotationObject doesn't actually store stuff
-        _(instance.tab_property).must_be_nil
-      end
-
-      it "can be set with #tab_property=" do
-        instance.tab_property = "hello 42"
-        # AnnotationObject doesn't actually store stuff
-        _(instance.get_property("tab-property")).must_be_nil
-      end
-    end
-
-    it "handles the 'attribute-signal' signal" do
-      signal_info = get_signal_introspection_data("Regress",
-                                                  "AnnotationObject",
-                                                  "attribute-signal")
-      argument_infos = signal_info.args
-      _(argument_infos.first.attribute("some.annotation.foo1")).must_equal "val1"
-      _(argument_infos.last.attribute("some.annotation.foo2")).must_equal "val2"
-
-      result = nil
-      instance.signal_connect "attribute-signal" do |_obj, _arg1, _arg2, _user_data|
-        # This signal uses a null marshaller, so the return value is never passed on.
-        result = "hello"
-      end
-
-      GObject.signal_emit instance, "attribute-signal", "foo", "bar"
-      _(result).must_equal "hello"
-    end
-
-    it "handles the 'doc-empty-arg-parsing' signal" do
-      test = nil
-      instance.signal_connect "doc-empty-arg-parsing" do |_obj, arg1, _user_data|
-        test = arg1
-      end
-
-      result = GObject.signal_emit instance, "doc-empty-arg-parsing", FFI::Pointer.new(123)
-      _(result).must_be_nil
-      _(test.address).must_equal 123
-    end
-
-    it "handles the 'list-signal' signal" do
-      result = nil
-      instance.signal_connect "list-signal" do |_obj, list, _user_data|
-        result = list
-      end
-
-      # TODO: Automatically convert to GLib::List
-      GObject.signal_emit instance, "list-signal", GLib::List.from(:utf8, %w(foo bar))
-      _(result.to_a).must_equal %w(foo bar)
-    end
-
-    it "handles the 'string-signal' signal" do
-      result = nil
-      instance.signal_connect "string-signal" do |_obj, string, _user_data|
-        result = string
-      end
-
-      GObject.signal_emit instance, "string-signal", "foo"
-      _(result).must_equal "foo"
-    end
-  end
-
-  describe "Regress::AnnotationStruct" do
-    let(:instance) { Regress::AnnotationStruct.new }
-
-    it "has a writable field objects" do
-      _(instance.objects.to_a).must_equal [nil] * 10
-
-      obj = Regress::AnnotationObject.new
-      instance.objects = [nil] * 5 + [obj] + [nil] * 4
-      _(instance.objects.to_a[5]).must_equal obj
-    end
-  end
-
-  describe "Regress::AnonymousUnionAndStruct" do
-    let(:instance) { Regress::AnonymousUnionAndStruct.new }
-
-    before { skip_below "1.49.1" }
-
-    it "has a writable field x" do
-      instance.x = 42
-      _(instance.x).must_equal 42
-    end
-
-    it "has a writable field a" do
-      skip "Anonymous struct fields are not exposed in the GIR data"
-    end
-
-    it "has a writable field b" do
-      skip "Anonymous struct fields are not exposed in the GIR data"
-    end
-
-    it "has a writable field padding" do
-      skip "Anonymous union fields are not exposed in the GIR data"
-    end
-  end
-  it "has the constant BOOL_CONSTANT" do
-    _(Regress::BOOL_CONSTANT).must_equal true
-  end
-
-  it "has the constant DOUBLE_CONSTANT" do
-    assert_equal 44.22, Regress::DOUBLE_CONSTANT
-  end
-
-  it "has the constant FOO_DEFINE_SHOULD_BE_EXPOSED" do
-    _(Regress::FOO_DEFINE_SHOULD_BE_EXPOSED).must_equal "should be exposed"
-  end
-
-  it "has the constant FOO_FLAGS_SECOND_AND_THIRD" do
-    skip_below "1.55.2"
-    _(Regress::FOO_FLAGS_SECOND_AND_THIRD).must_equal 6
-  end
-
-  it "has the constant FOO_PIE_IS_TASTY" do
-    _(Regress::FOO_PIE_IS_TASTY).must_equal 3.141590
-  end
-
-  it "has the constant FOO_SUCCESS_INT" do
-    _(Regress::FOO_SUCCESS_INT).must_equal 4408
-  end
-
-  describe "Regress::FooASingle" do
-    it "has the member :foo_some_single_enum" do
-      _(Regress::FooASingle[:foo_some_single_enum]).must_equal 0
-    end
-  end
-
-  describe "Regress::FooAddressType" do
-    it "has the member :invalid" do
-      _(Regress::FooAddressType[:invalid]).must_equal 0
-    end
-
-    it "has the member :ipv4" do
-      _(Regress::FooAddressType[:ipv4]).must_equal 1
-    end
-
-    it "has the member :ipv6" do
-      _(Regress::FooAddressType[:ipv6]).must_equal 2
-    end
-  end
-
-  describe "Regress::FooBRect" do
-    let(:instance) { Regress::FooBRect.wrap(Regress::FooBRect::Struct.new.to_ptr) }
-
-    it "has a writable field x" do
-      _(instance.x).must_equal 0.0
-      instance.x = 23.42
-      _(instance.x).must_equal 23.42
-    end
-
-    it "has a writable field y" do
-      _(instance.y).must_equal 0.0
-      instance.y = 23.42
-      _(instance.y).must_equal 23.42
-    end
-
-    it "creates an instance using #new" do
-      skip "This function is defined in the header but not implemented"
-    end
-
-    it "has a working method #add" do
-      skip "This function is defined in the header but not implemented"
-    end
-  end
-
-  describe "Regress::FooBUnion" do
-    let(:instance) { Regress::FooBUnion.wrap(Regress::FooBUnion::Struct.new.to_ptr) }
-
-    it "has a writable field type" do
-      _(instance.type).must_equal 0
-      instance.type = 42
-      _(instance.type).must_equal 42
-    end
-
-    it "has a writable field v" do
-      _(instance.v).must_equal 0.0
-      instance.v = 23.42
-      _(instance.v).must_equal 23.42
-    end
-
-    it "has a writable field rect" do
-      _(instance.rect).must_be_nil
-      rect = Regress::FooBRect.wrap(Regress::FooBRect::Struct.new.to_ptr)
-      rect.x = 42
-      rect.y = 23
-      skip "Cannot copy FooBRect structs"
-      instance.rect = rect
-      _(instance.rect.x).must_equal 42.0
-      _(instance.rect.y).must_equal 23.0
-    end
-
-    it "creates an instance using #new" do
-      skip "This function is defined in the header but not implemented"
-    end
-
-    it "has a working method #get_contained_type" do
-      skip "This function is defined in the header but not implemented"
-    end
-  end
-
-  describe "Regress::FooBoxed" do
-    let(:instance) { Regress::FooBoxed.new }
-
-    it "creates an instance using #new" do
-      _(instance).must_be_instance_of Regress::FooBoxed
-    end
-
-    it "has a working method #method" do
-      _(instance.method).must_be_nil
-    end
-  end
-
-  describe "Regress::FooBuffer" do
-    let(:instance) { Regress::FooBuffer.new }
-
-    it "creates an instance using #new" do
-      _(instance).must_be_instance_of Regress::FooBuffer
-    end
-
-    it "has a working method #some_method" do
-      _(instance.some_method).must_be_nil
-    end
-  end
-
-  describe "Regress::FooDBusData" do
-    let(:instance) { Regress::FooDBusData.new }
-
-    it "creates an instance using #new" do
-      _(instance).must_be_instance_of Regress::FooDBusData
-    end
-
-    it "has a working method #method" do
-      skip "This function is defined in the header but not implemented"
-    end
-  end
-
-  describe "Regress::FooEnumFullname" do
-    it "has the member :one" do
-      _(Regress::FooEnumFullname[:one]).must_equal 1
-    end
-
-    it "has the member :two" do
-      _(Regress::FooEnumFullname[:two]).must_equal 2
-    end
-
-    it "has the member :three" do
-      _(Regress::FooEnumFullname[:three]).must_equal 3
-    end
-  end
-
-  describe "Regress::FooEnumNoType" do
-    it "has the member :un" do
-      _(Regress::FooEnumNoType[:un]).must_equal 1
-    end
-
-    it "has the member :deux" do
-      _(Regress::FooEnumNoType[:deux]).must_equal 2
-    end
-
-    it "has the member :trois" do
-      _(Regress::FooEnumNoType[:trois]).must_equal 3
-    end
-
-    it "has the member :neuf" do
-      _(Regress::FooEnumNoType[:neuf]).must_equal 9
-    end
-  end
-
-  describe "Regress::FooEnumType" do
-    it "has the member :alpha" do
-      _(Regress::FooEnumType[:alpha]).must_equal 0
-    end
-
-    it "has the member :beta" do
-      _(Regress::FooEnumType[:beta]).must_equal 1
-    end
-
-    it "has the member :delta" do
-      _(Regress::FooEnumType[:delta]).must_equal 2
-    end
-
-    it "has a working function #method" do
-      skip "This function is defined in the header but not implemented"
-    end
-
-    it "has a working function #returnv" do
-      skip "This function is defined in the header but not implemented"
-    end
-  end
-
-  describe "Regress::FooError" do
-    it "has the member :good" do
-      _(Regress::FooError[:good]).must_equal 0
-    end
-
-    it "has the member :bad" do
-      _(Regress::FooError[:bad]).must_equal 1
-    end
-
-    it "has the member :ugly" do
-      _(Regress::FooError[:ugly]).must_equal 2
-    end
-
-    it "has a working function #quark" do
-      quark = Regress::FooError.quark
-      _(GLib.quark_to_string(quark)).must_equal "regress_foo-error-quark"
-    end
-  end
-
-  describe "Regress::FooEvent" do
-    let(:instance) { Regress::FooEvent.new }
-
-    it "has a writable field type" do
-      _(instance.type).must_equal 0
-      instance.type = 23
-      _(instance.type).must_equal 23
-    end
-
-    it "has a writable field any" do
-      _(instance.any.send_event).must_equal 0
-      any = Regress::FooEventAny.new
-      any.send_event = 42
-      instance.any = any
-      _(instance.any.send_event).must_equal 42
-    end
-
-    it "has a writable field expose" do
-      _(instance.expose.send_event).must_equal 0
-      _(instance.expose.count).must_equal 0
-      expose = Regress::FooEventExpose.new
-      expose.send_event = 23
-      expose.count = 14
-      instance.expose = expose
-      _(instance.expose.send_event).must_equal 23
-      _(instance.expose.count).must_equal 14
-    end
-  end
-
-  describe "Regress::FooEventAny" do
-    let(:instance) { Regress::FooEventAny.new }
-
-    it "has a writable field send_event" do
-      _(instance.send_event).must_equal 0
-      instance.send_event = 23
-      _(instance.send_event).must_equal 23
-    end
-  end
-
-  describe "Regress::FooEventExpose" do
-    let(:instance) { Regress::FooEventExpose.new }
-
-    it "has a writable field send_event" do
-      _(instance.send_event).must_equal 0
-      instance.send_event = 23
-      _(instance.send_event).must_equal 23
-    end
-
-    it "has a writable field count" do
-      _(instance.count).must_equal 0
-      instance.count = 42
-      _(instance.count).must_equal 42
-    end
-  end
-
-  describe "Regress::FooFlagsNoType" do
-    it "has the member :ett" do
-      _(Regress::FooFlagsNoType[:ett]).must_equal 1
-    end
-
-    it "has the member :tva" do
-      _(Regress::FooFlagsNoType[:tva]).must_equal 2
-    end
-
-    it "has the member :fyra" do
-      _(Regress::FooFlagsNoType[:fyra]).must_equal 4
-    end
-  end
-
-  describe "Regress::FooFlagsType" do
-    it "has the member :first" do
-      _(Regress::FooFlagsType[:first]).must_equal 1
-    end
-
-    it "has the member :second" do
-      _(Regress::FooFlagsType[:second]).must_equal 2
-    end
-
-    it "has the member :third" do
-      _(Regress::FooFlagsType[:third]).must_equal 4
-    end
-  end
-
-  describe "Regress::FooForeignStruct" do
-    let(:instance) { Regress::FooForeignStruct.new }
-
-    it "has a writable field regress_foo" do
-      _(instance.regress_foo).must_equal 0
-      instance.regress_foo = 143
-      _(instance.regress_foo).must_equal 143
-    end
-
-    it "creates an instance using #new" do
-      _(instance).must_be_instance_of Regress::FooForeignStruct
-    end
-
-    it "has a working method #copy" do
-      instance.regress_foo = 585
-      result = instance.copy
-      instance.regress_foo = 0
-      _(result.regress_foo).must_equal 585
-    end
-  end
-
-  describe "Regress::FooInterface" do
-    it "has a working function #static_method" do
-      _(Regress::FooInterface.static_method(42)).must_be_nil
-    end
-
-    it "has a working method #do_regress_foo" do
-      instance = Regress::FooObject.new
-      _(instance).must_be_kind_of Regress::FooInterface
-      _(instance.do_regress_foo(42)).must_be_nil
-    end
-  end
-
-  describe "Regress::FooObject" do
-    let(:instance) { Regress::FooObject.new }
-
-    it "creates an instance using #new" do
-      _(instance).must_be_instance_of Regress::FooObject
-    end
-
-    it "creates an instance using #new_as_super" do
-      other_instance = Regress::FooObject.new_as_super
-      _(other_instance).must_be_instance_of Regress::FooObject
-    end
-
-    it "has a working function #a_global_method" do
-      skip "This function is defined in the header but not implemented"
-    end
-
-    it "has a working function #get_default" do
-      _(Regress::FooObject.get_default).must_be_nil
-    end
-
-    it "has a working function #static_meth" do
-      skip "This function is defined in the header but not implemented"
-    end
-
-    it "has a working method #append_new_stack_layer" do
-      _(instance.append_new_stack_layer(42)).must_be_nil
-    end
-
-    it "has a working method #dup_name" do
-      _(instance.dup_name).must_equal "regress_foo"
-    end
-
-    it "has a working method #external_type" do
-      result = instance.external_type
-      _(result).must_be_nil
-    end
-
-    it "has a working method #get_name" do
-      _(instance.get_name).must_equal "regress_foo"
-    end
-
-    it "has a working method #handle_glyph" do
-      skip "This function is defined in the header but not implemented"
-    end
-
-    it "has a working method #is_it_time_yet" do
-      _(instance.is_it_time_yet(Time.now.to_i)).must_be_nil
-    end
-
-    it "has a working method #read" do
-      _(instance.read(12, 13)).must_be_nil
-    end
-
-    it "has a working method #various" do
-      skip "This function is defined in the header but not implemented"
-    end
-
-    it "has a working method #virtual_method" do
-      skip "This function is defined in the header but not implemented"
-    end
-
-    describe "its 'string' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("string")).must_be_nil
-      end
-
-      it "can be retrieved with #string" do
-        _(instance.string).must_be_nil
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property "string", "hello 42"
-        # FooObject doesn't actually store stuff
-        _(instance.string).must_be_nil
-        _(instance.get_property("string")).must_be_nil
-      end
-
-      it "can be set with #string=" do
-        instance.string = "hello 42"
-        # FooObject doesn't actually store stuff
-        _(instance.string).must_be_nil
-        _(instance.get_property("string")).must_be_nil
-      end
-    end
-
-    it "handles the 'signal' signal" do
-      instance.signal_connect "signal" do
-        "hello"
-      end
-
-      result = GObject.signal_emit instance, "signal"
-      _(result).must_equal "hello"
-    end
-  end
-
-  describe "Regress::FooOtherObject" do
-    it "is derived from GObject::Object" do
-      _(Regress::FooOtherObject.superclass).must_equal GObject::Object
-    end
-  end
-
-  describe "Regress::FooRectangle" do
-    let(:instance) { Regress::FooRectangle.new }
-
-    it "has a writable field x" do
-      _(instance.x).must_equal 0
-      instance.x = 23
-      _(instance.x).must_equal 23
-    end
-
-    it "has a writable field y" do
-      _(instance.y).must_equal 0
-      instance.y = 23
-      _(instance.y).must_equal 23
-    end
-
-    it "has a writable field width" do
-      _(instance.width).must_equal 0
-      instance.width = 23
-      _(instance.width).must_equal 23
-    end
-
-    it "has a writable field height" do
-      _(instance.height).must_equal 0
-      instance.height = 23
-      _(instance.height).must_equal 23
-    end
-
-    it "has a working method #add" do
-      other_instance = Regress::FooRectangle.new
-      result = instance.add other_instance
-      # NOTE: inout annotation has no effect on the method receiver
-      _(result).must_be_nil
-    end
-  end
-
-  describe "Regress::FooStackLayer" do
-    it "has the member :desktop" do
-      _(Regress::FooStackLayer[:desktop]).must_equal 0
-    end
-
-    it "has the member :bottom" do
-      _(Regress::FooStackLayer[:bottom]).must_equal 1
-    end
-
-    it "has the member :normal" do
-      _(Regress::FooStackLayer[:normal]).must_equal 2
-    end
-
-    it "has the member :top" do
-      _(Regress::FooStackLayer[:top]).must_equal 4
-    end
-
-    it "has the member :dock" do
-      _(Regress::FooStackLayer[:dock]).must_equal 4
-    end
-
-    it "has the member :fullscreen" do
-      _(Regress::FooStackLayer[:fullscreen]).must_equal 5
-    end
-
-    it "has the member :focused_window" do
-      _(Regress::FooStackLayer[:focused_window]).must_equal 6
-    end
-
-    it "has the member :override_redirect" do
-      _(Regress::FooStackLayer[:override_redirect]).must_equal 7
-    end
-
-    it "has the member :last" do
-      _(Regress::FooStackLayer[:last]).must_equal 8
-    end
-  end
-
-  describe "Regress::FooStruct" do
-    let(:instance) { Regress::FooStruct.new }
-
-    it "blocks access to the hidden struct field priv" do
-      _(proc { instance.priv = nil }).must_raise NoMethodError
-      _(proc { instance.priv }).must_raise NoMethodError
-    end
-
-    it "has a writable field member" do
-      _(instance.member).must_equal 0
-      instance.member = 23
-      _(instance.member).must_equal 23
-    end
-  end
-
-  describe "Regress::FooSubInterface" do
-    let(:derived_klass) do
-      Object.const_set("DerivedClass#{Sequence.next}",
-                       Class.new(Regress::FooObject))
-    end
-
-    def make_derived_instance
-      derived_klass.send :include, Regress::FooSubInterface
-      GirFFI.define_type derived_klass do |info|
-        yield info if block_given?
-      end
-      derived_klass.new
-    end
-
-    it "has a working method #do_bar" do
-      result = nil
-      instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :do_bar, proc { |obj| result = obj.get_name }
-      end
-      instance.do_bar
-      _(result).must_equal "regress_foo"
-    end
-
-    it "has a working method #do_baz" do
-      a = nil
-      instance = make_derived_instance do |info|
-        # TODO: Do not pass callback again in user_data if destroy notifier is absent
-        info.install_vfunc_implementation :do_baz,
-                                          proc { |obj, callback, _user_data|
-                                            callback.call
-                                            a = obj.get_name
-                                          }
-      end
-      b = nil
-      instance.do_baz { b = "hello" }
-      _(a).must_equal "regress_foo"
-      _(b).must_equal "hello"
-    end
-
-    it "handles the 'destroy-event' signal" do
-      a = nil
-      instance = make_derived_instance
-      instance.signal_connect "destroy-event" do
-        a = "hello"
-      end
-      GObject.signal_emit instance, "destroy-event"
-      _(a).must_equal "hello"
-    end
-  end
-
-  describe "Regress::FooSubobject" do
-    it "creates an instance using #new" do
-      skip "This function is defined in the header but not implemented"
-    end
-  end
-
-  describe "Regress::FooThingWithArray" do
-    let(:instance) { Regress::FooThingWithArray.new }
-
-    it "has a writable field x" do
-      _(instance.x).must_equal 0
-      instance.x = 23
-      _(instance.x).must_equal 23
-    end
-
-    it "has a writable field y" do
-      _(instance.y).must_equal 0
-      instance.y = 23
-      _(instance.y).must_equal 23
-    end
-
-    it "has a writable field lines" do
-      _(instance.lines).must_be :==, [0] * 80
-      instance.lines = (1..80).to_a
-      _(instance.lines).must_be :==, (1..80).to_a
-    end
-
-    it "has a writable field data" do
-      _(instance.data).must_equal FFI::Pointer::NULL
-      instance.data = FFI::Pointer.new(23)
-      _(instance.data).must_equal FFI::Pointer.new(23)
-    end
-  end
-
-  describe "Regress::FooUnion" do
-    let(:instance) { Regress::FooUnion.new }
-
-    it "has a writable field regress_foo" do
-      _(instance.regress_foo).must_equal 0
-      instance.regress_foo = 23
-      _(instance.regress_foo).must_equal 23
-    end
-  end
-
-  describe "Regress::FooUtilityStruct" do
-    let(:instance) { Regress::FooUtilityStruct.new }
-
-    it "has a writable field bar" do
-      struct = Utility::Struct.new
-      struct.field = 23
-
-      _(instance.bar.field).must_equal 0
-      instance.bar = struct
-      _(instance.bar.field).must_equal 23
-    end
-  end
-
-  it "has the constant GI_SCANNER_ELSE" do
-    _(Regress::GI_SCANNER_ELSE).must_equal 3
-  end
-
-  it "has the constant GI_SCANNER_IFDEF" do
-    _(Regress::GI_SCANNER_IFDEF).must_equal 3
-  end
-
-  it "has the constant GUINT64_CONSTANT" do
-    _(Regress::GUINT64_CONSTANT).must_equal 18_446_744_073_709_551_615
-  end
-
-  it "has the constant GUINT64_CONSTANTA" do
-    _(Regress::GUINT64_CONSTANTA).must_equal 18_446_744_073_709_551_615
-  end
-
-  it "has the constant G_GINT64_CONSTANT" do
-    _(Regress::G_GINT64_CONSTANT).must_equal 1000
-  end
-
-  it "has the constant INT_CONSTANT" do
-    assert_equal 4422, Regress::INT_CONSTANT
-  end
-
-  it "has the constant LONG_STRING_CONSTANT" do
-    _(Regress::LONG_STRING_CONSTANT).must_equal %w(TYPE VALUE ENCODING CHARSET
-                                                   LANGUAGE DOM INTL POSTAL PARCEL
-                                                   HOME WORK PREF VOICE FAX MSG
-                                                   CELL PAGER BBS MODEM CAR ISDN
-                                                   VIDEO AOL APPLELINK ATTMAIL CIS
-                                                   EWORLD INTERNET IBMMAIL MCIMAIL
-                                                   POWERSHARE PRODIGY TLX X400 GIF
-                                                   CGM WMF BMP MET PMB DIB PICT
-                                                   TIFF PDF PS JPEG QTIME MPEG
-                                                   MPEG2 AVI WAVE AIFF PCM X509
-                                                   PGP).join(",")
-  end
-
-  describe "Regress::LikeGnomeKeyringPasswordSchema" do
-    it "creates an instance using #new" do
-      obj = Regress::LikeGnomeKeyringPasswordSchema.new
-      _(obj).must_be_instance_of Regress::LikeGnomeKeyringPasswordSchema
-    end
-
-    let(:instance) { Regress::LikeGnomeKeyringPasswordSchema.new }
-
-    it "has a writable field dummy" do
-      _(instance.dummy).must_equal 0
-      instance.dummy = 42
-      _(instance.dummy).must_equal 42
-    end
-
-    it "has a writable field attributes" do
-      skip "Introspection data cannot deal with type of this field yet"
-    end
-
-    it "has a writable field dummy2" do
-      _(instance.dummy2).must_equal 0.0
-      instance.dummy2 = 42.42
-      _(instance.dummy2).must_equal 42.42
-    end
-  end
-
-  describe "Regress::LikeXklConfigItem" do
-    let(:instance) { Regress::LikeXklConfigItem.new }
-    let(:name_array) { "foo".bytes.to_a + [0] * 29 }
-
-    it "has a writable field name" do
-      # TODO: Should an array of gint8 be more string-like?
-      _(instance.name.to_a).must_equal [0] * 32
-      instance.name = name_array
-      _(instance.name.to_a).must_equal name_array
-    end
-
-    it "has a working method #set_name" do
-      instance.set_name "foo"
-      _(instance.name.to_a).must_equal name_array
-    end
-  end
-
-  it "has the constant MAXUINT64" do
-    _(Regress::MAXUINT64).must_equal 0xffff_ffff_ffff_ffff
-  end
-
-  it "has the constant MININT64" do
-    _(Regress::MININT64).must_equal(-0x8000_0000_0000_0000)
-  end
-
-  it "has the constant Mixed_Case_Constant" do
-    assert_equal 4423, Regress::Mixed_Case_Constant
-  end
-
-  it "has the constant NEGATIVE_INT_CONSTANT" do
-    _(Regress::NEGATIVE_INT_CONSTANT).must_equal(-42)
-  end
-
-  it "has the constant STRING_CONSTANT" do
-    assert_equal "Some String", Regress::STRING_CONSTANT
-  end
-
-  describe "Regress::TestABCError" do
-    it "has the member :code1" do
-      _(Regress::TestABCError[:code1]).must_equal 1
-    end
-
-    it "has the member :code2" do
-      _(Regress::TestABCError[:code2]).must_equal 2
-    end
-
-    it "has the member :code3" do
-      _(Regress::TestABCError[:code3]).must_equal 3
-    end
-
-    it "has a working function #quark" do
-      quark = Regress::TestABCError.quark
-      _(GLib.quark_to_string(quark)).must_equal "regress-test-abc-error"
-    end
-  end
-
-  describe "Regress::TestBoxed" do
-    let(:instance) { Regress::TestBoxed.new_alternative_constructor1 123 }
-
-    it "has a writable field some_int8" do
-      _(instance.some_int8).must_equal 123
-      instance.some_int8 = -43
-      _(instance.some_int8).must_equal(-43)
-    end
-
-    it "has a writable field nested_a" do
-      _(instance.nested_a.some_int).must_equal 0
-      nested = Regress::TestSimpleBoxedA.new
-      nested.some_int = 12_345
-      instance.nested_a = nested
-      _(instance.nested_a.some_int).must_equal 12_345
-    end
-
-    it "blocks access to the hidden struct field priv" do
-      _(proc { instance.priv = nil }).must_raise NoMethodError
-      _(proc { instance.priv }).must_raise NoMethodError
-    end
-
-    it "creates an instance using #new" do
-      tb = Regress::TestBoxed.new
-      assert_instance_of Regress::TestBoxed, tb
-    end
-
-    it "creates an instance using #new_alternative_constructor1" do
-      tb = Regress::TestBoxed.new_alternative_constructor1 1
-      assert_instance_of Regress::TestBoxed, tb
-      assert_equal 1, tb.some_int8
-    end
-
-    it "creates an instance using #new_alternative_constructor2" do
-      tb = Regress::TestBoxed.new_alternative_constructor2 1, 2
-      assert_instance_of Regress::TestBoxed, tb
-      assert_equal 1 + 2, tb.some_int8
-    end
-
-    it "creates an instance using #new_alternative_constructor3" do
-      tb = Regress::TestBoxed.new_alternative_constructor3 "54"
-      assert_instance_of Regress::TestBoxed, tb
-      assert_equal 54, tb.some_int8
-    end
-
-    it "has non-zero positive result for #gtype" do
-      _(Regress::TestBoxed.gtype).must_be :>, 0
-    end
-
-    it "has a working method #_not_a_method" do
-      # NOTE: This method is marked as moved, but this is not exposed in the typelib
-      instance._not_a_method
-      pass
-    end
-
-    it "has a working method #copy" do
-      tb2 = instance.copy
-      assert_instance_of Regress::TestBoxed, tb2
-      assert_equal 123, tb2.some_int8
-      instance.some_int8 = 89
-      assert_equal 123, tb2.some_int8
-    end
-
-    it "has a working method #equals" do
-      tb2 = Regress::TestBoxed.new_alternative_constructor2 120, 3
-      assert_equal true, instance.equals(tb2)
-    end
-  end
-
-  describe "Regress::TestBoxedB" do
-    let(:instance) { Regress::TestBoxedB.new 8, 42 }
-
-    it "has a writable field some_int8" do
-      _(instance.some_int8).must_equal 8
-      instance.some_int8 = -43
-      _(instance.some_int8).must_equal(-43)
-    end
-
-    it "has a writable field some_long" do
-      _(instance.some_long).must_equal 42
-      instance.some_long = -4342
-      _(instance.some_long).must_equal(-4342)
-    end
-
-    it "creates an instance using #new" do
-      tb = Regress::TestBoxedB.new 8, 42
-      assert_instance_of Regress::TestBoxedB, tb
-    end
-
-    it "has a working method #copy" do
-      cp = instance.copy
-      _(cp).must_be_instance_of Regress::TestBoxedB
-      _(cp.some_int8).must_equal 8
-      _(cp.some_long).must_equal 42
-      instance.some_int8 = 2
-      _(cp.some_int8).must_equal 8
-    end
-  end
-
-  describe "Regress::TestBoxedC" do
-    let(:instance) { Regress::TestBoxedC.new }
-
-    it "has a writable field refcount" do
-      _(instance.refcount).must_equal 1
-      instance.refcount = 2
-      _(instance.refcount).must_equal 2
-    end
-
-    it "has a writable field another_thing" do
-      _(instance.another_thing).must_equal 42
-      instance.another_thing = 4342
-      _(instance.another_thing).must_equal 4342
-    end
-
-    it "creates an instance using #new" do
-      tb = Regress::TestBoxedC.new
-      assert_instance_of Regress::TestBoxedC, tb
-    end
-  end
-
-  describe "Regress::TestBoxedD" do
-    let(:instance) { Regress::TestBoxedD.new "foo", 42 }
-
-    it "creates an instance using #new" do
-      _(instance).must_be_instance_of Regress::TestBoxedD
-    end
-
-    it "has a working method #copy" do
-      copy = instance.copy
-      _(copy).must_be_instance_of Regress::TestBoxedD
-      _(instance.get_magic).must_equal copy.get_magic
-      _(instance).wont_equal copy
-    end
-
-    it "has a working method #free" do
-      skip "#free is used internally and shouldn't be exposed"
-      instance.free
-      pass
-    end
-
-    it "has a working method #get_magic" do
-      _(instance.get_magic).must_equal "foo".length + 42
-    end
-  end
-
-  describe "Regress::TestDEFError" do
-    it "has the member :code0" do
-      _(Regress::TestDEFError[:code0]).must_equal 0
-    end
-
-    it "has the member :code1" do
-      _(Regress::TestDEFError[:code1]).must_equal 1
-    end
-
-    it "has the member :code2" do
-      _(Regress::TestDEFError[:code2]).must_equal 2
-    end
-  end
-
-  describe "Regress::TestEnum" do
-    it "has the member :value1" do
-      _(Regress::TestEnum[:value1]).must_equal 0
-    end
-
-    it "has the member :value2" do
-      _(Regress::TestEnum[:value2]).must_equal 1
-    end
-
-    it "has the member :value3" do
-      _(Regress::TestEnum[:value3]).must_equal(-1)
-    end
-
-    it "has the member :value4" do
-      _(Regress::TestEnum[:value4]).must_equal 48
-    end
-
-    it "has the member :value5" do
-      skip_below "1.55.2"
-      _(Regress::TestEnum[:value5]).must_equal 49
-    end
-
-    it "has a working function #param" do
-      _(Regress::TestEnum.param(:value1)).must_equal("value1")
-      _(Regress::TestEnum.param(:value2)).must_equal("value2")
-      _(Regress::TestEnum.param(:value3)).must_equal("value3")
-      _(Regress::TestEnum.param(:value4)).must_equal("value4")
-      _(Regress::TestEnum.param(0)).must_equal("value1")
-      _(Regress::TestEnum.param(1)).must_equal("value2")
-      _(Regress::TestEnum.param(-1)).must_equal("value3")
-      _(Regress::TestEnum.param(48)).must_equal("value4")
-    end
-  end
-
-  describe "Regress::TestEnumNoGEnum" do
-    it "has the member :evalue1" do
-      _(Regress::TestEnumNoGEnum[:evalue1]).must_equal 0
-    end
-
-    it "has the member :evalue2" do
-      _(Regress::TestEnumNoGEnum[:evalue2]).must_equal 42
-    end
-
-    it "has the member :evalue3" do
-      _(Regress::TestEnumNoGEnum[:evalue3]).must_equal 48
-    end
-  end
-
-  describe "Regress::TestEnumUnsigned" do
-    it "has the member :value1" do
-      _(Regress::TestEnumUnsigned[:value1]).must_equal 1
-    end
-
-    # NOTE In c, the positive and negative values are not distinguished
-    it "has the member :value2" do
-      _(Regress::TestEnumUnsigned[:value2]).must_equal(-2_147_483_648)
-    end
-  end
-
-  describe "Regress::TestError" do
-    it "has the member :code1" do
-      _(Regress::TestError[:code1]).must_equal 1
-    end
-
-    it "has the member :code2" do
-      _(Regress::TestError[:code2]).must_equal 2
-    end
-
-    it "has the member :code3" do
-      _(Regress::TestError[:code3]).must_equal 3
-    end
-
-    it "has a working function #quark" do
-      quark = Regress::TestError.quark
-      _(GLib.quark_to_string(quark)).must_equal "regress-test-error"
-    end
-  end
-
-  describe "Regress::TestFlags" do
-    it "has the member :flag1" do
-      assert_equal 1, Regress::TestFlags[:flag1]
-    end
-    it "has the member :flag2" do
-      assert_equal 2, Regress::TestFlags[:flag2]
-    end
-    it "has the member :flag3" do
-      assert_equal 4, Regress::TestFlags[:flag3]
-    end
-  end
-
-  describe "Regress::TestFloating" do
-    it "creates an instance using #new" do
-      o = Regress::TestFloating.new
-      _(o).must_be_instance_of Regress::TestFloating
-    end
-
-    describe "an instance" do
-      before do
-        @o = Regress::TestFloating.new
-      end
-
-      it "has a reference count of 1" do
-        assert_equal 1, object_ref_count(@o)
-      end
-
-      it "has been sunk" do
-        _(@o).wont_be :floating?
-      end
-    end
-  end
-
-  describe "Regress::TestFundamentalObject" do
-    it "does not have GObject::Object as an ancestor" do
-      refute(Regress::TestFundamentalObject < GObject::Object)
-    end
-
-    it "cannot be instantiated" do
-      _(proc { Regress::TestFundamentalObject.new }).must_raise NoMethodError
-    end
-
-    let(:derived_instance) { Regress::TestFundamentalSubObject.new "foo" }
-    let(:base_struct) { Regress::TestFundamentalObject::Struct.new derived_instance.to_ptr }
-
-    it "has a working method #ref" do
-      _(base_struct[:refcount]).must_equal 1
-      derived_instance.ref
-      _(base_struct[:refcount]).must_equal 2
-    end
-
-    it "has a working method #unref" do
-      _(base_struct[:refcount]).must_equal 1
-      derived_instance.unref
-      _(base_struct[:refcount]).must_equal 0
-    end
-  end
-
-  describe "Regress::TestFundamentalSubObject" do
-    it "creates an instance using #new" do
-      obj = Regress::TestFundamentalSubObject.new "foo"
-      _(obj).must_be_instance_of Regress::TestFundamentalSubObject
-    end
-
-    let(:instance) { Regress::TestFundamentalSubObject.new "foo" }
-
-    it "is a subclass of TestFundamentalObject" do
-      assert_kind_of Regress::TestFundamentalObject, instance
-    end
-
-    it "has a field :data storing the constructor parameter" do
-      assert_equal "foo", instance.struct[:data].to_utf8
-    end
-  end
-
-  describe "Regress::TestInheritDrawable" do
-    it "cannot be instantiated" do
-      _(proc { Regress::TestInheritDrawable.new }).must_raise NoMethodError
-    end
-
-    let(:derived_instance) { ConcreteDrawable.new }
-
-    it "has a working method #do_foo" do
-      derived_instance.do_foo 42
-      pass
-    end
-
-    it "has a working method #do_foo_maybe_throw" do
-      derived_instance.do_foo_maybe_throw 42
-      _(proc { derived_instance.do_foo_maybe_throw 41 }).must_raise GirFFI::GLibError
-    end
-
-    it "has a working method #get_origin" do
-      _(derived_instance.get_origin).must_equal [0, 0]
-    end
-
-    it "has a working method #get_size" do
-      _(derived_instance.get_size).must_equal [42, 42]
-    end
-  end
-
-  describe "Regress::TestInheritPixmapObjectClass" do
-    it "has a writable field parent_class" do
-      skip "This is a class struct without defined class"
-    end
-  end
-
-  describe "Regress::TestInterface" do
-    let(:derived_klass) do
-      klass = Object.const_set("DerivedClass#{Sequence.next}",
-                               Class.new(Regress::FooObject))
-      klass.send :include, Regress::TestInterface
-      GirFFI.define_type klass do |info|
-        info.install_property GObject.param_spec_int("number", "Number", "Number",
-                                                     0, 10, 0,
-                                                     readwrite: true, construct: true)
-      end
-      klass
-    end
-
-    it "is a module" do
-      assert_instance_of Module, Regress::TestInterface
-    end
-
-    it "extends InterfaceBase" do
-      _(Regress::TestInterface.singleton_class).must_include GirFFI::InterfaceBase
-    end
-
-    it "has non-zero positive result for #gtype" do
-      _(Regress::TestInterface.gtype).must_be :>, 0
-    end
-
-    it "has a working method #emit_signal" do
-      skip_below "1.57.2"
-      a = nil
-      instance = derived_klass.new
-      GObject.signal_connect instance, "interface-signal" do
-        a = "hello"
-      end
-      instance.emit_signal
-      _(a).must_equal "hello"
-    end
-
-    describe "its 'number' property" do
-      before { skip_below "1.59.1" }
-
-      let(:instance) { derived_klass.new }
-
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("number")).must_equal 0
-      end
-
-      it "can be retrieved with #number" do
-        _(instance.number).must_equal 0
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property("number", 10)
-        _(instance.get_property("number")).must_equal 10
-      end
-
-      it "can be set with #number=" do
-        instance.number = 4
-
-        _(instance.number).must_equal 4
-        _(instance.get_property("number")).must_equal 4
-      end
-    end
-
-    it "handles the 'interface-signal' signal" do
-      skip_below "1.57.2"
-      a = nil
-      instance = derived_klass.new
-      GObject.signal_connect instance, "interface-signal" do
-        a = "hello"
-      end
-      GObject.signal_emit instance, "interface-signal"
-      _(a).must_equal "hello"
-    end
-  end
-
-  describe "Regress::TestObj" do
-    it "creates an instance using #constructor" do
-      obj = Regress::TestObj.constructor
-      _(obj).must_be_instance_of Regress::TestObj
-    end
-
-    it "creates an instance using #new" do
-      o1 = Regress::TestObj.constructor
-      o2 = Regress::TestObj.new o1
-      _(o2).must_be_instance_of Regress::TestObj
-    end
-
-    it "creates an instance using #new_callback" do
-      a = 1
-      o = Regress::TestObj.new_callback { a = 2 }
-      assert_instance_of Regress::TestObj, o
-      _(a).must_equal 2
-
-      # Regress::TestObj.new_callback adds a callback to the list of notified
-      # callbacks. Thaw the callbacks to make sure the list is cleared for
-      # later tests.
-      result = Regress.test_callback_thaw_notifications
-      _(result).must_equal 2
-    end
-
-    it "creates an instance using #new_from_file" do
-      o = Regress::TestObj.new_from_file("foo")
-      assert_instance_of Regress::TestObj, o
-    end
-
-    it "has a working function #null_out" do
-      obj = Regress::TestObj.null_out
-      _(obj).must_be_nil
-    end
-
-    it "has a working function #static_method" do
-      rv = Regress::TestObj.static_method 623
-      assert_equal 623.0, rv
-    end
-
-    it "has a working function #static_method_callback" do
-      a = 1
-      Regress::TestObj.static_method_callback { a = 2 }
-      assert_equal 2, a
-    end
-
-    let(:instance) { Regress::TestObj.new_from_file("foo") }
-
-    describe "its gtype" do
-      it "can be found through gtype and GObject.type_from_instance" do
-        gtype = Regress::TestObj.gtype
-        r = GObject.type_from_instance instance
-        assert_equal gtype, r
-      end
-    end
-
-    it "has a reference count of 1" do
-      assert_equal 1, object_ref_count(instance)
-    end
-
-    it "does not float" do
-      _(instance).wont_be :floating?
-    end
-
-    it "has a working method #matrix" do
-      _(instance.matrix("bar")).must_equal 42
-    end
-
-    it "has a working method #do_matrix" do
-      _(instance.do_matrix("bar")).must_equal 42
-    end
-
-    it "has a working method #emit_sig_with_array_len_prop" do
-      skip_below "1.47.92"
-      array = nil
-      instance.signal_connect "sig-with-array-len-prop" do |_obj, ary|
-        array = ary.to_a
-      end
-      instance.emit_sig_with_array_len_prop
-      _(array.to_a).must_equal [0, 1, 2, 3, 4]
-    end
-
-    it "has a working method #emit_sig_with_error" do
-      skip_below "1.61.1"
-      error = nil
-      instance.signal_connect "sig-with-gerror" do |_obj, err|
-        error = err
-      end
-      instance.emit_sig_with_error
-      _(error).must_be_instance_of GLib::Error
-    end
-
-    it "has a working method #emit_sig_with_foreign_struct" do
-      has_fired = false
-      instance.signal_connect "sig-with-foreign-struct" do |_obj, cr|
-        has_fired = true
-        _(cr).must_be_instance_of Cairo::Context
-      end
-      instance.emit_sig_with_foreign_struct
-      assert has_fired
-    end
-
-    it "has a working method #emit_sig_with_inout_int" do
-      skip_below "1.57.2"
-      instance.signal_connect "sig-with-inout-int" do |_obj, i, _ud|
-        i + 1
-      end
-      instance.emit_sig_with_inout_int
-    end
-
-    it "has a working method #emit_sig_with_int64" do
-      instance.signal_connect "sig-with-int64-prop" do |_obj, i, _ud|
-        i
-      end
-      instance.emit_sig_with_int64
-    end
-
-    it "has a working method #emit_sig_with_null_error" do
-      skip_below "1.61.1"
-      error = nil
-      instance.signal_connect "sig-with-gerror" do |_obj, err|
-        error = err
-      end
-      instance.emit_sig_with_null_error
-      _(error).must_be_nil
-    end
-
-    it "has a working method #emit_sig_with_obj" do
-      has_fired = false
-      instance.signal_connect "sig-with-obj" do |_it, obj|
-        has_fired = true
-        _(obj.int).must_equal 3
-      end
-      instance.emit_sig_with_obj
-      assert has_fired
-    end
-
-    it "has a working method #emit_sig_with_uint64" do
-      instance.signal_connect "sig-with-uint64-prop" do |_obj, i, _ud|
-        i
-      end
-      instance.emit_sig_with_uint64
-    end
-
-    it "has a working method #forced_method" do
-      instance.forced_method
-      pass
-    end
-
-    it "has a working method #instance_method" do
-      rv = instance.instance_method
-      assert_equal(-1, rv)
-    end
-
-    it "has a working method #instance_method_callback" do
-      a = 1
-      instance.instance_method_callback { a = 2 }
-      assert_equal 2, a
-    end
-
-    it "has a working method #instance_method_full" do
-      _(object_ref_count(instance)).must_equal 1
-      instance.instance_method_full
-      _(object_ref_count(instance)).must_equal 1
-    end
-
-    it "has a working method #name_conflict" do
-      skip_below "1.53.4"
-      _(instance.name_conflict).must_be_nil
-    end
-
-    it "has a working method #not_nullable_element_typed_gpointer_in" do
-      skip_below "1.47.92"
-      instance.not_nullable_element_typed_gpointer_in [1, 2, 3]
-      # TODO: Make method raise when passed nil
-    end
-
-    it "has a working method #not_nullable_typed_gpointer_in" do
-      skip_below "1.47.92"
-      obj = Regress::TestObj.new_from_file("bar")
-      instance.not_nullable_typed_gpointer_in obj
-      # TODO: Make method raise when passed nil
-    end
-
-    it "has a working method #set_bare" do
-      obj = Regress::TestObj.new_from_file("bar")
-      instance.set_bare obj
-      _(instance.bare).must_equal obj
-    end
-
-    it "has a working method #skip_inout_param" do
-      a = 1
-      c = 2.0
-      num1 = 3
-      num2 = 4
-      result, out_b, sum = instance.skip_inout_param a, c, num1, num2
-      _(result).must_equal true
-      _(out_b).must_equal a + 1
-      _(sum).must_equal num1 + 10 * num2
-    end
-
-    it "has a working method #skip_out_param" do
-      a = 1
-      c = 2.0
-      d = 3
-      num1 = 4
-      num2 = 5
-      result, out_d, sum = instance.skip_out_param a, c, d, num1, num2
-      _(result).must_equal true
-      _(out_d).must_equal d + 1
-      _(sum).must_equal num1 + 10 * num2
-    end
-
-    it "has a working method #skip_param" do
-      a = 1
-      d = 3
-      num1 = 4
-      num2 = 5
-      result, out_b, out_d, sum = instance.skip_param a, d, num1, num2
-      _(result).must_equal true
-      _(out_b).must_equal a + 1
-      _(out_d).must_equal d + 1
-      _(sum).must_equal num1 + 10 * num2
-    end
-
-    it "has a working method #skip_return_val" do
-      a = 1
-      c = 2.0
-      d = 3
-      num1 = 4
-      num2 = 5
-      out_b, out_d, out_sum = instance.skip_return_val a, c, d, num1, num2
-      _(out_b).must_equal a + 1
-      _(out_d).must_equal d + 1
-      _(out_sum).must_equal num1 + 10 * num2
-    end
-
-    it "has a working method #skip_return_val_no_out" do
-      result = instance.skip_return_val_no_out 1
-      _(result).must_be_nil
-
-      _(proc { instance.skip_return_val_no_out 0 }).must_raise GirFFI::GLibError
-    end
-
-    it "has a working method #torture_signature_0" do
-      y, z, q = instance.torture_signature_0(-21, "hello", 13)
-      assert_equal [-21, 2 * -21, "hello".length + 13],
-                   [y, z, q]
-    end
-
-    it "has a working method #torture_signature_1" do
-      ret, y, z, q = instance.torture_signature_1(-21, "hello", 12)
-      _([ret, y, z, q]).must_equal [true, -21, 2 * -21, "hello".length + 12]
-
-      _(proc { instance.torture_signature_1(-21, "hello", 11) })
-        .must_raise GirFFI::GLibError
-    end
-
-    describe "its 'bare' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("bare")).must_be_nil
-      end
-
-      it "can be retrieved with #bare" do
-        _(instance.bare).must_be_nil
-      end
-
-      it "can be set with #set_property" do
-        obj = Regress::TestObj.new_from_file("bar")
-        instance.set_property "bare", obj
-        _(instance.get_property("bare")).must_equal obj
-      end
-
-      it "can be set with #bare=" do
-        obj = Regress::TestObj.new_from_file("bar")
-        instance.bare = obj
-
-        _(instance.bare).must_equal obj
-        _(instance.get_property("bare")).must_equal obj
-      end
-    end
-
-    describe "its 'boxed' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("boxed")).must_be_nil
-      end
-
-      it "can be retrieved with #boxed" do
-        _(instance.boxed).must_be_nil
-      end
-
-      it "can be set with #set_property" do
-        tb = Regress::TestBoxed.new_alternative_constructor1 75
-        instance.set_property "boxed", tb
-        _(instance.get_property("boxed").some_int8).must_equal 75
-      end
-
-      it "can be set with #boxed=" do
-        tb = Regress::TestBoxed.new_alternative_constructor1 75
-        instance.boxed = tb
-        _(instance.boxed.some_int8).must_equal tb.some_int8
-        _(instance.get_property("boxed").some_int8).must_equal tb.some_int8
-      end
-    end
-
-    describe "its 'byte-array' property" do
-      before { skip_below("1.57.2") }
-
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("byte-array")).must_be_nil
-      end
-
-      it "can be retrieved with #byte_array" do
-        _(instance.byte_array).must_be_nil
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property "byte-array", "hello"
-        _(instance.get_property("byte-array").to_string).must_equal "hello"
-      end
-
-      it "can be set with #byte_array=" do
-        instance.byte_array = "bye"
-        _(instance.byte_array.to_string).must_equal "bye"
-        instance.byte_array = GLib::ByteArray.from("byebye")
-        _(instance.get_property("byte-array").to_string).must_equal "byebye"
-      end
-    end
-
-    describe "its 'double' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("double")).must_equal 0.0
-      end
-
-      it "can be retrieved with #double" do
-        _(instance.double).must_equal 0.0
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property "double", 3.14
-        _(instance.get_property("double")).must_equal 3.14
-      end
-
-      it "can be set with #double=" do
-        instance.double = 3.14
-        _(instance.double).must_equal 3.14
-        _(instance.get_property("double")).must_equal 3.14
-      end
-    end
-
-    describe "its 'float' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("float")).must_equal 0.0
-      end
-
-      it "can be retrieved with #float" do
-        _(instance.float).must_equal 0.0
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property "float", 3.14
-        _(instance.get_property("float")).must_be_close_to 3.14
-      end
-
-      it "can be set with #float=" do
-        instance.float = 3.14
-        _(instance.float).must_be_close_to 3.14
-        _(instance.get_property("float")).must_be_close_to 3.14
-      end
-    end
-
-    describe "its 'gtype' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("gtype")).must_equal 0
-      end
-
-      it "can be retrieved with #gtype" do
-        _(instance.gtype).must_equal 0
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property "gtype", GObject::TYPE_INT64
-        _(instance.get_property("gtype")).must_equal GObject::TYPE_INT64
-      end
-
-      it "can be set with #gtype=" do
-        instance.gtype = GObject::TYPE_STRING
-        _(instance.gtype).must_equal GObject::TYPE_STRING
-        _(instance.get_property("gtype")).must_equal GObject::TYPE_STRING
-      end
-    end
-
-    describe "its 'hash-table' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("hash-table")).must_be_nil
-      end
-
-      it "can be retrieved with #hash_table" do
-        _(instance.hash_table).must_be_nil
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property "hash-table", "foo" => -4, "bar" => 83
-        _(instance.hash_table.to_hash).must_equal("foo" => -4, "bar" => 83)
-      end
-
-      it "can be set with #hash_table=" do
-        instance.hash_table = { "foo" => -4, "bar" => 83 }
-        _(instance.hash_table.to_hash).must_equal("foo" => -4, "bar" => 83)
-        _(instance.get_property("hash-table").to_hash).must_equal("foo" => -4,
-                                                                        "bar" => 83)
-      end
-    end
-
-    describe "its 'hash-table-old' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("hash-table-old")).must_be_nil
-      end
-
-      it "can be retrieved with #hash_table_old" do
-        _(instance.hash_table_old).must_be_nil
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property "hash-table-old", "foo" => 34, "bar" => -3
-        _(instance.hash_table_old.to_hash).must_equal("foo" => 34, "bar" => -3)
-      end
-
-      it "can be set with #hash_table_old=" do
-        instance.hash_table_old = { "foo" => 34, "bar" => -3 }
-        _(instance.hash_table_old.to_hash).must_equal("foo" => 34, "bar" => -3)
-        _(instance.get_property("hash-table-old").to_hash).must_equal("foo" => 34,
-                                                                            "bar" => -3)
-      end
-    end
-
-    describe "its 'int' property" do
-      it "can be retrieved with #get_property" do
-        assert_equal 0, instance.get_property("int")
-      end
-
-      it "can be retrieved with #int" do
-        assert_equal 0, instance.int
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property "int", 42
-        assert_equal 42, instance.get_property("int")
-      end
-
-      it "can be set with #int=" do
-        instance.int = 41
-        assert_equal 41, instance.get_property("int")
-        assert_equal 41, instance.int
-      end
-    end
-
-    describe "its 'list' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("list")).must_be_nil
-      end
-
-      it "can be retrieved with #list" do
-        _(instance.list).must_be_nil
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property "list", %w(foo bar)
-        _(instance.list.to_a).must_equal %w(foo bar)
-      end
-
-      it "can be set with #list=" do
-        instance.list = %w(foo bar)
-        _(instance.list.to_a).must_equal %w(foo bar)
-        _(instance.get_property("list")).must_be :==, %w(foo bar)
-      end
-    end
-
-    describe "its 'list-old' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("list-old")).must_be_nil
-      end
-
-      it "can be retrieved with #list_old" do
-        _(instance.list_old).must_be_nil
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property "list-old", %w(foo bar)
-        _(instance.list_old).must_be :==, %w(foo bar)
-      end
-
-      it "can be set with #list_old=" do
-        instance.list_old = %w(foo bar)
-        _(instance.list_old).must_be :==, %w(foo bar)
-        _(instance.get_property("list-old")).must_be :==, %w(foo bar)
-      end
-    end
-
-    describe "its 'name-conflict' property" do
-      before { skip_below "1.53.4" }
-
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("name-conflict")).must_equal 42
-      end
-
-      it "cannot be retrieved with #name_conflict" do
-        # Method names are prioritized over property names, so we call the
-        # method here instead of fetching the property
-        _(instance.name_conflict).must_be_nil
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property("name-conflict", 23)
-        _(instance.get_property("name-conflict")).must_equal 23
-      end
-
-      it "can be set with #name_conflict=" do
-        instance.name_conflict = 23
-        _(instance.get_property("name-conflict")).must_equal 23
-      end
-    end
-    describe "its 'pptrarray' property" do
-      before do
-        skip "The pptrarray property is not implemented properly"
-      end
-
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("pptrarray")).must_be_nil
-      end
-
-      it "can be retrieved with #pptrarray" do
-        _(instance.pptrarray).must_be_nil
-      end
-
-      it "can be set with #set_property" do
-        arr = Regress.test_garray_container_return
-        instance.set_property "pptrarray", arr
-        _(instance.pptrarray).must_be :==, arr
-      end
-
-      it "can be set with #pptrarray=" do
-        arr = Regress.test_garray_container_return
-        instance.pptrarray = arr
-        _(instance.pptrarray).must_be :==, arr
-        _(instance.get_property("pptrarray")).must_be :==, arr
-      end
-    end
-
-    describe "its 'string' property" do
-      it "can be retrieved with #get_property" do
-        assert_nil instance.get_property("string")
-      end
-
-      it "can be retrieved with #string" do
-        assert_nil instance.string
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property "string", "foobar"
-        assert_equal "foobar", instance.get_property("string")
-      end
-
-      it "can be set with #string=" do
-        instance.string = "foobar"
-        assert_equal "foobar", instance.string
-        assert_equal "foobar", instance.get_property("string")
-      end
-    end
-
-    describe "its 'write-only' property" do
-      before { skip_below "1.59.1" }
-
-      it "cannot be retrieved with #get_property" do
-        skip "Not implemented yet"
-        _(proc { instance.get_property("write-only") }).must_raise GirFFI::GLibError
-      end
-
-      it "cannot be retrieved with #write_only" do
-        skip "Not implemented yet"
-        _(proc { instance.write_only }).must_raise NoMethodError
-      end
-
-      it "can be set with #set_property" do
-        instance.int = 42
-        instance.set_property("write-only", false)
-        _(instance.int).must_equal 42
-        instance.set_property("write-only", true)
-        _(instance.int).must_equal 0
-      end
-
-      it "can be set with #write_only=" do
-        instance.int = 42
-        instance.write_only = false
-        _(instance.int).must_equal 42
-        instance.write_only = true
-        _(instance.int).must_equal 0
-      end
-    end
-    it "handles the 'all' signal" do
-      a = nil
-      GObject.signal_connect(instance, "all") { a = 4 }
-      GObject.signal_emit instance, "all"
-      _(a).must_equal 4
-    end
-
-    it "handles the 'cleanup' signal" do
-      a = nil
-      GObject.signal_connect(instance, "cleanup") { a = 4 }
-      GObject.signal_emit instance, "cleanup"
-      _(a).must_equal 4
-    end
-
-    it "handles the 'first' signal" do
-      a = nil
-      GObject.signal_connect(instance, "first") { a = 4 }
-      GObject.signal_emit instance, "first"
-      _(a).must_equal 4
-    end
-
-    it "handles the 'sig-with-array-len-prop' signal" do
-      a = nil
-
-      GObject.signal_connect(instance, "sig-with-array-len-prop") do |_obj, arr, _user_data|
-        a = arr
-      end
-
-      arr = GirFFI::InPointer.from_array(:uint, [1, 2, 3])
-      GObject.signal_emit instance, "sig-with-array-len-prop", arr, 3
-
-      _(a.to_a).must_equal [1, 2, 3]
-    end
-
-    it "handles the 'sig-with-array-prop' signal" do
-      a = nil
-      GObject.signal_connect(instance, "sig-with-array-prop") { |_, arr, _| a = arr }
-      GObject.signal_emit instance, "sig-with-array-prop",
-                          GLib::Array.from(:uint, [1, 2, 3])
-      _(a.to_a).must_equal [1, 2, 3]
-    end
-
-    it "handles the 'sig-with-foreign-struct' signal" do
-      a = nil
-      instance.signal_connect "sig-with-foreign-struct" do |_obj, ct|
-        a = ct
-      end
-
-      cairo_context = Regress.test_cairo_context_full_return
-
-      GObject.signal_emit instance, "sig-with-foreign-struct", cairo_context
-
-      _(a).must_be_instance_of Cairo::Context
-      _(a).must_equal cairo_context
-    end
-
-    it "handles the 'sig-with-gerror' signal" do
-      skip_below "1.61.1"
-      a = nil
-      GObject.signal_connect(instance, "sig-with-gerror") do |_obj, err|
-        a = err
-      end
-      GObject.signal_emit instance, "sig-with-gerror", GLib::Error.new
-      _(a).must_be_instance_of GLib::Error
-    end
-
-    it "handles the 'sig-with-hash-prop' signal" do
-      a = nil
-
-      GObject.signal_connect(instance, "sig-with-hash-prop") do |_, ghash, _|
-        a = ghash.to_hash
-      end
-
-      g_hash_table = GLib::HashTable.from([:utf8, GObject::Value],
-                                          "foo" => GObject::Value.from("bar"))
-
-      GObject.signal_emit instance, "sig-with-hash-prop", g_hash_table
-
-      _(a["foo"]).must_be_instance_of GObject::Value
-      _(a["foo"].get_value).must_equal "bar"
-    end
-
-    it "handles the 'sig-with-inout-int' signal" do
-      skip_below "1.53.4"
-      skip "Not implemented yet"
-      GObject.signal_connect instance, "sig-with-inout-int" do |_obj, i, _ud|
-        i + 2
-      end
-      result = GObject.signal_emit instance, "sig-with-inout-int", 65
-      _(result).must_equal 67
-    end
-
-    it "handles the 'sig-with-int64-prop' signal" do
-      a = nil
-
-      GObject.signal_connect(instance, "sig-with-int64-prop") do |_obj, int64, _user_data|
-        a = int64
-      end
-
-      result = GObject.signal_emit instance, "sig-with-int64-prop", 0x7fff_ffff_ffff_ffff
-
-      _(a).must_equal 0x7fff_ffff_ffff_ffff
-      _(result).must_equal 0x7fff_ffff_ffff_ffff
-    end
-
-    it "handles the 'sig-with-intarray-ret' signal" do
-      a = nil
-
-      GObject.signal_connect(instance, "sig-with-intarray-ret") do |_, i, _|
-        a = i
-        [3, 2, 1]
-      end
-
-      result = GObject.signal_emit instance, "sig-with-intarray-ret", 3
-
-      _(a).must_equal 3
-
-      _(result.to_a).must_equal [3, 2, 1]
-    end
-
-    it "handles the 'sig-with-obj' signal" do
-      a = nil
-
-      GObject.signal_connect(instance, "sig-with-obj") do |_, obj, _|
-        a = obj
-      end
-
-      object = Regress::TestObj.constructor
-      GObject.signal_emit instance, "sig-with-obj", object
-
-      _(a).must_equal object
-    end
-
-    it "handles the 'sig-with-strv' signal" do
-      a = nil
-
-      GObject.signal_connect(instance, "sig-with-strv") do |_, strs, _|
-        a = strs
-      end
-
-      GObject.signal_emit instance, "sig-with-strv", GLib::Strv.from(%w(foo bar))
-
-      _(a.to_a).must_equal %w(foo bar)
-    end
-
-    it "handles the 'sig-with-uint64-prop' signal" do
-      a = nil
-
-      GObject.signal_connect(instance, "sig-with-uint64-prop") do |_, uint64, _|
-        a = uint64
-      end
-
-      result = GObject.signal_emit instance, "sig-with-uint64-prop", 0xffff_ffff_ffff_ffff
-
-      _(a).must_equal 0xffff_ffff_ffff_ffff
-      _(result).must_equal 0xffff_ffff_ffff_ffff
-    end
-
-    it "handles the 'test' signal" do
-      a = b = nil
-      o = Regress::TestSubObj.new
-      GObject.signal_connect(o, "test", 2) do |i, d|
-        a = d
-        b = i
-      end
-      GObject.signal_emit o, "test"
-      assert_equal [2, o], [a, b]
-    end
-
-    it "handles the 'test-with-static-scope-arg' signal" do
-      a = nil
-
-      GObject.signal_connect(instance, "test-with-static-scope-arg") do |_, obj, _|
-        a = obj
-      end
-
-      arg = Regress::TestSimpleBoxedA.new
-      arg.some_int = 12_345
-      GObject.signal_emit instance, "test-with-static-scope-arg", arg
-
-      _(a.some_int).must_equal 12_345
-    end
-  end
-
-  describe "Regress::TestOtherError" do
-    it "has the member :code1" do
-      _(Regress::TestOtherError[:code1]).must_equal 1
-    end
-
-    it "has the member :code2" do
-      _(Regress::TestOtherError[:code2]).must_equal 2
-    end
-
-    it "has the member :code3" do
-      _(Regress::TestOtherError[:code3]).must_equal 3
-    end
-
-    it "has a working function #quark" do
-      quark = Regress::TestOtherError.quark
-      _(GLib.quark_to_string(quark)).must_equal "regress-test-other-error"
-    end
-  end
-
-  describe "Regress::TestPrivateEnum" do
-    it "has the member :public_enum_before" do
-      _(Regress::TestPrivateEnum[:public_enum_before]).must_equal 1
-    end
-    it "does not have the member :private" do
-      _(Regress::TestPrivateEnum[:private]).must_be_nil
-    end
-    it "has the member :public_enum_after" do
-      _(Regress::TestPrivateEnum[:public_enum_after]).must_equal 4
-    end
-  end
-
-  describe "Regress::TestPrivateStruct" do
-    let(:instance) { Regress::TestPrivateStruct.new }
-
-    it "has a writable field this_is_public_before" do
-      _(instance.this_is_public_before).must_equal 0
-      instance.this_is_public_before = 42
-      _(instance.this_is_public_before).must_equal 42
-    end
-
-    it "has a private field this_is_private" do
-      skip "This field is identified as readable in the typelib"
-      _(instance).wont_respond_to :this_is_private
-      _(instance).wont_respond_to :this_is_private=
-    end
-
-    it "has a writable field this_is_public_after" do
-      _(instance.this_is_public_after).must_equal 0
-      instance.this_is_public_after = 42
-      _(instance.this_is_public_after).must_equal 42
-    end
-  end
-
-  describe "Regress::TestReferenceCounters" do
-    let(:instance) { Regress::TestReferenceCounters.new }
-
-    before { skip_below "1.59.1" }
-
-    it "has a writable field refcount" do
-      _(instance.refcount).must_equal 0
-      instance.refcount = 42
-      _(instance.refcount).must_equal 42
-    end
-
-    it "has a writable field atomicrefcount" do
-      _(instance.atomicrefcount).must_equal 0
-      instance.atomicrefcount = 42
-      _(instance.atomicrefcount).must_equal 42
-    end
-  end
-
-  describe "Regress::TestReferenceEnum" do
-    it "has the member :0" do
-      _(Regress::TestReferenceEnum[:"0"]).must_equal 4
-    end
-
-    it "has the member :1" do
-      _(Regress::TestReferenceEnum[:"1"]).must_equal 2
-    end
-
-    it "has the member :2" do
-      _(Regress::TestReferenceEnum[:"2"]).must_equal 54
-    end
-
-    it "has the member :3" do
-      _(Regress::TestReferenceEnum[:"3"]).must_equal 4
-    end
-
-    it "has the member :4" do
-      _(Regress::TestReferenceEnum[:"4"]).must_equal 216
-    end
-
-    it "has the member :5" do
-      _(Regress::TestReferenceEnum[:"5"]).must_equal(-217)
-    end
-  end
-
-  describe "Regress::TestSimpleBoxedA" do
-    it "creates an instance using #new" do
-      obj = Regress::TestSimpleBoxedA.new
-      assert_instance_of Regress::TestSimpleBoxedA, obj
-    end
-
-    let(:instance) { Regress::TestSimpleBoxedA.new }
-
-    it "has a writable field some_int" do
-      _(instance.some_int).must_equal 0
-      instance.some_int = 42
-      _(instance.some_int).must_equal 42
-    end
-
-    it "has a writable field some_int8" do
-      _(instance.some_int8).must_equal 0
-      instance.some_int8 = 42
-      _(instance.some_int8).must_equal 42
-    end
-
-    it "has a writable field some_double" do
-      _(instance.some_double).must_equal 0.0
-      instance.some_double = 42.0
-      _(instance.some_double).must_equal 42.0
-    end
-
-    it "has a writable field some_enum" do
-      _(instance.some_enum).must_equal :value1
-      instance.some_enum = :value4
-      _(instance.some_enum).must_equal :value4
-    end
-
-    it "has a working method #copy" do
-      instance.some_int = 4236
-
-      obj2 = instance.copy
-      _(obj2).must_be_instance_of Regress::TestSimpleBoxedA
-      _(obj2.some_int).must_equal instance.some_int
-
-      instance.some_int = 89
-      _(obj2.some_int).wont_equal instance.some_int
-    end
-
-    it "has a working method #equals" do
-      instance.some_int = 4236
-
-      ob2 = Regress::TestSimpleBoxedA.new
-      ob2.some_int = 4236
-      _(ob2.equals(instance)).must_equal true
-      ob2.some_enum = :value3
-      _(ob2.equals(instance)).must_equal true
-      ob2.some_int = 42
-      _(ob2.equals(instance)).wont_equal true
-    end
-
-    it "has a working function #const_return" do
-      result = Regress::TestSimpleBoxedA.const_return
-      _([result.some_int, result.some_int8, result.some_double]).must_equal [5, 6, 7.0]
-    end
-  end
-
-  describe "Regress::TestSimpleBoxedB" do
-    let(:instance) { Regress::TestSimpleBoxedB.new }
-    it "has a writable field some_int8" do
-      _(instance.some_int8).must_equal 0
-      instance.some_int8 = 42
-      _(instance.some_int8).must_equal 42
-    end
-
-    it "has a writable field nested_a" do
-      _(instance.nested_a.some_int).must_equal 0
-      instance.nested_a = Regress::TestSimpleBoxedA.const_return
-      _(instance.nested_a.some_int).must_equal 5
-    end
-
-    it "has a working method #copy" do
-      instance.some_int8 = -42
-      instance.nested_a.some_int = 4242
-
-      copy = instance.copy
-      _([copy.some_int8, copy.nested_a.some_int]).must_equal [-42, 4242]
-
-      instance.some_int8 = 103
-      _(copy.some_int8).must_equal(-42)
-    end
-  end
-
-  describe "Regress::TestStructA" do
-    let(:instance) { Regress::TestStructA.new }
-    it "has a writable field some_int" do
-      _(instance.some_int).must_equal 0
-      instance.some_int = 2556
-      _(instance.some_int).must_equal 2556
-    end
-
-    it "has a writable field some_int8" do
-      _(instance.some_int8).must_equal 0
-      instance.some_int8 = -10
-      _(instance.some_int8).must_equal(-10)
-    end
-
-    it "has a writable field some_double" do
-      _(instance.some_double).must_equal 0.0
-      instance.some_double = 1.03455e20
-      _(instance.some_double).must_equal 1.03455e20
-    end
-
-    it "has a writable field some_enum" do
-      _(instance.some_enum).must_equal :value1
-      instance.some_enum = :value2
-      _(instance.some_enum).must_equal :value2
-    end
-
-    it "has a working method #clone" do
-      a = Regress::TestStructA.new
-      a.some_int = 2556
-      a.some_int8 = -10
-      a.some_double = 1.03455e20
-      a.some_enum = :value2
-
-      b = a.clone
-
-      assert_equal 2556, b.some_int
-      assert_equal(-10, b.some_int8)
-      assert_equal 1.03455e20, b.some_double
-      assert_equal :value2, b.some_enum
-    end
-
-    it "has a working function #parse" do
-      a = Regress::TestStructA.parse("this string is actually ignored")
-      _(a.some_int).must_equal 23
-    end
-  end
-
-  describe "Regress::TestStructB" do
-    let(:instance) { Regress::TestStructB.new }
-    it "has a writable field some_int8" do
-      _(instance.some_int8).must_equal 0
-      instance.some_int8 = 42
-      _(instance.some_int8).must_equal 42
-    end
-
-    it "has a writable field nested_a" do
-      _(instance.nested_a.some_int).must_equal 0
-
-      nested = Regress::TestStructA.new
-      nested.some_int = -4321
-
-      instance.nested_a = nested
-      _(instance.nested_a.some_int).must_equal(-4321)
-    end
-
-    it "has a working method #clone" do
-      a = Regress::TestStructB.new
-      a.some_int8 = 42
-      a.nested_a.some_int = 2556
-      a.nested_a.some_int8 = -10
-      a.nested_a.some_double = 1.03455e20
-      a.nested_a.some_enum = :value2
-
-      b = a.clone
-
-      assert_equal 42, b.some_int8
-      assert_equal 2556, b.nested_a.some_int
-      assert_equal(-10, b.nested_a.some_int8)
-      assert_equal 1.03455e20, b.nested_a.some_double
-      assert_equal :value2, b.nested_a.some_enum
-    end
-  end
-
-  describe "Regress::TestStructC" do
-    let(:instance) { Regress::TestStructC.new }
-    it "has a writable field another_int" do
-      _(instance.another_int).must_equal 0
-      instance.another_int = 42
-      _(instance.another_int).must_equal 42
-    end
-
-    it "has a writable field obj" do
-      o = Regress::TestSubObj.new
-      _(instance.obj).must_be_nil
-      instance.obj = o
-      _(instance.obj).must_equal o
-    end
-  end
-
-  describe "Regress::TestStructD" do
-    let(:instance) { Regress::TestStructD.new }
-    it "has a writable field array1" do
-      _(instance.array1).must_be :==, []
-      struct = Regress::TestStructA.new
-      instance.array1 = [struct]
-      _(instance.array1).must_be :==, [struct]
-    end
-
-    it "has a writable field array2" do
-      _(instance.array2).must_be :==, []
-      o = Regress::TestSubObj.new
-      instance.array2 = [o]
-      _(instance.array2).must_be :==, [o]
-    end
-
-    it "has a writable field field" do
-      _(instance.field).must_be_nil
-      o = Regress::TestSubObj.new
-      instance.field = o
-      _(instance.field).must_equal o
-    end
-
-    it "has a writable field list" do
-      _(instance.list).must_be_nil
-      o = Regress::TestSubObj.new
-      instance.list = [o]
-      _(instance.list).must_be :==, [o]
-    end
-
-    it "has a writable field garray" do
-      _(instance.garray).must_be_nil
-      o = Regress::TestSubObj.new
-      instance.garray = [o]
-      _(instance.garray).must_be :==, [o]
-    end
-  end
-
-  describe "Regress::TestStructE" do
-    let(:instance) { Regress::TestStructE.new }
-    it "has a writable field some_type" do
-      _(instance.some_type).must_equal 0
-      instance.some_type = GObject::TYPE_STRING
-      _(instance.some_type).must_equal GObject::TYPE_STRING
-    end
-
-    it "has a writable field some_union" do
-      _(instance.some_union.map(&:v_int)).must_equal [0, 0]
-
-      union1 = Regress::TestStructE__some_union__union.new
-      union1.v_int = 42
-      union2 = Regress::TestStructE__some_union__union.new
-      union2.v_int = 84
-
-      instance.some_union = [union1, union2]
-
-      _(instance.some_union.map(&:v_int)).must_equal [42, 84]
-    end
-  end
-  describe "Regress::TestStructE__some_union__union" do
-    let(:instance) { Regress::TestStructE__some_union__union.new }
-    it "has a writable field v_int" do
-      _(instance.v_int).must_equal 0
-      instance.v_int = -54_321
-      _(instance.v_int).must_equal(-54_321)
-    end
-
-    it "has a writable field v_uint" do
-      _(instance.v_uint).must_equal 0
-      instance.v_uint = 54_321
-      _(instance.v_uint).must_equal 54_321
-    end
-
-    it "has a writable field v_long" do
-      _(instance.v_long).must_equal 0
-      instance.v_long = -54_321
-      _(instance.v_long).must_equal(-54_321)
-    end
-
-    it "has a writable field v_ulong" do
-      _(instance.v_long).must_equal 0
-      instance.v_long = 54_321
-      _(instance.v_long).must_equal 54_321
-    end
-
-    it "has a writable field v_int64" do
-      _(instance.v_int64).must_equal 0
-      instance.v_int64 = -54_321_000_000_000
-      _(instance.v_int64).must_equal(-54_321_000_000_000)
-    end
-    it "has a writable field v_uint64" do
-      _(instance.v_uint64).must_equal 0
-      instance.v_uint64 = 54_321_000_000_000
-      _(instance.v_uint64).must_equal 54_321_000_000_000
-    end
-    it "has a writable field v_float" do
-      _(instance.v_float).must_equal 0
-      instance.v_float = 3.1415
-      _(instance.v_float).must_be_close_to 3.1415
-    end
-    it "has a writable field v_double" do
-      _(instance.v_double).must_equal 0
-      instance.v_double = 3.1415
-      _(instance.v_double).must_equal 3.1415
-    end
-    it "has a writable field v_pointer" do
-      _(instance.v_pointer).must_be :null?
-      instance.v_pointer = FFI::Pointer.new 54_321
-      _(instance.v_pointer.address).must_equal 54_321
-    end
-  end
-  describe "Regress::TestStructF" do
-    let(:instance) { Regress::TestStructF.new }
-
-    it "has a writable field ref_count" do
-      _(instance.ref_count).must_equal 0
-      instance.ref_count = 1
-      _(instance.ref_count).must_equal 1
-    end
-
-    it "has a writable field data1" do
-      _(instance.data1).must_be :null?
-      instance.data1 = FFI::MemoryPointer.new(:int32).tap { |it| it.put_int(0, 42) }
-      _(instance.data1.read_int).must_equal 42
-    end
-
-    # TODO: Check what gobject-introspection should/will do with these fields.
-    it "has a writable field data2" do
-      skip "Introspection data cannot deal with type of this field yet"
-    end
-
-    it "has a writable field data3" do
-      skip "Introspection data cannot deal with type of this field yet"
-    end
-
-    it "has a writable field data4" do
-      skip "Introspection data cannot deal with type of this field yet"
-    end
-
-    it "has a writable field data5" do
-      skip "Introspection data cannot deal with type of this field yet"
-    end
-
-    it "has a writable field data6" do
-      skip "Introspection data cannot deal with type of this field yet"
-    end
-
-    it "has a writable field data7" do
-      skip_below "1.59.3"
-      instance.data7 = 42
-      _(instance.data7).must_equal 42
-    end
-  end
-
-  describe "Regress::TestStructFixedArray" do
-    let(:instance) { Regress::TestStructFixedArray.new }
-    it "has a writable field just_int" do
-      _(instance.just_int).must_equal 0
-      instance.just_int = 42
-      _(instance.just_int).must_equal 42
-    end
-
-    it "has a writable field array" do
-      _(instance.array).must_be :==, [0] * 10
-      instance.array = (1..10).to_a
-      _(instance.array).must_be :==, (1..10).to_a
-    end
-
-    it "has a working method #frob" do
-      instance.array = (0..9).to_a
-      instance.frob
-      _(instance.array).must_be :==, (42..42 + 9).to_a
-      _(instance.just_int).must_equal 7
-    end
-  end
-
-  describe "Regress::TestSubObj" do
-    it "creates an instance using #new" do
-      tso = Regress::TestSubObj.new
-      assert_instance_of Regress::TestSubObj, tso
-    end
-
-    it "does not create an instance using its parent object's custom constructors" do
-      _(proc { Regress::TestSubObj.constructor }).must_raise NoMethodError
-    end
-
-    let(:instance) { Regress::TestSubObj.new }
-
-    it "has a working method #instance_method" do
-      res = instance.instance_method
-      assert_equal 0, res
-    end
-
-    it "has a working method #unset_bare" do
-      instance.unset_bare
-      pass
-    end
-
-    describe "its 'boolean' property" do
-      before { skip_below "1.59.1" }
-
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("boolean")).must_equal true
-      end
-
-      it "can be retrieved with #boolean" do
-        _(instance.boolean).must_equal true
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property("boolean", false)
-        _(instance.get_property("boolean")).must_equal false
-      end
-
-      it "can be set with #boolean=" do
-        instance.boolean = false
-        _(instance.get_property("boolean")).must_equal false
-      end
-    end
-
-    it "does not have a field parent_instance" do
-      _(instance).wont_respond_to :parent_instance
-    end
-  end
-
-  describe "Regress::TestWi8021x" do
-    it "creates an instance using #new" do
-      o = Regress::TestWi8021x.new
-      assert_instance_of Regress::TestWi8021x, o
-    end
-
-    it "has a working function #static_method" do
-      assert_equal(-84, Regress::TestWi8021x.static_method(-42))
-    end
-
-    let(:instance) { Regress::TestWi8021x.new }
-
-    it "has a working method #get_testbool" do
-      _(instance.get_testbool).must_equal true
-    end
-
-    it "has a working method #set_testbool" do
-      instance.set_testbool true
-      _(instance.get_testbool).must_equal true
-      instance.set_testbool false
-      _(instance.get_testbool).must_equal false
-    end
-
-    describe "its 'testbool' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("testbool")).must_equal true
-      end
-
-      it "can be retrieved with #testbool" do
-        _(instance.testbool).must_equal true
-      end
-
-      it "can be set with #set_property" do
-        instance.set_property "testbool", true
-        _(instance.get_testbool).must_equal true
-        _(instance.get_property("testbool")).must_equal true
-
-        instance.set_property "testbool", false
-        _(instance.get_testbool).must_equal false
-        _(instance.get_property("testbool")).must_equal false
-      end
-
-      it "can be set with #testbool=" do
-        instance.testbool = true
-        _(instance.testbool).must_equal true
-        _(instance.get_testbool).must_equal true
-        _(instance.get_property("testbool")).must_equal true
-
-        instance.testbool = false
-        _(instance.testbool).must_equal false
-        _(instance.get_testbool).must_equal false
-        _(instance.get_property("testbool")).must_equal false
-      end
-    end
-  end
-
-  it "has the constant UTF8_CONSTANT" do
-    assert_equal "const ♥ utf8", Regress::UTF8_CONSTANT
-  end
-
-  it "has a working function #aliased_caller_alloc" do
-    result = Regress.aliased_caller_alloc
-    _(result).must_be_instance_of Regress::TestBoxed
-  end
-
-  it "has a working function #annotation_attribute_func" do
-    info = get_introspection_data("Regress", "annotation_attribute_func")
-    param = info.args.last
-    _(param.attribute("some.annotation")).must_equal "value"
-    _(param.attribute("another.annotation")).must_equal "blahvalue"
-
-    obj = Regress::AnnotationObject.new
-    _(Regress.annotation_attribute_func(obj, "hello")).must_equal 42
-  end
-
-  it "has a working function #annotation_custom_destroy" do
-    result = Regress.annotation_custom_destroy {}
-    _(result).must_be_nil
-  end
-
-  it "has a working function #annotation_get_source_file" do
-    _(Regress.annotation_get_source_file).must_be_nil
-  end
-
-  it "has a working function #annotation_init" do
-    result = Regress.annotation_init %w(foo bar)
-    _(result.to_a).must_equal %w(foo bar)
-  end
-
-  it "has a working function #annotation_invalid_regress_annotation" do
-    _(Regress.annotation_invalid_regress_annotation(42)).must_be_nil
-  end
-
-  it "has a working function #annotation_ptr_array" do
-    # TODO: Automatically convert array elements to correct type
-    val1 = GObject::Value.from 1
-    val2 = GObject::Value.from "a"
-    _(Regress.annotation_ptr_array([val1, val2])).must_be_nil
-  end
-
-  it "has a working function #annotation_return_array" do
-    _(Regress.annotation_return_array).must_be_nil
-  end
-
-  it "has a working function #annotation_return_filename" do
-    skip "This function is wrongly annotated as transfer-ownership: full"
-    _(Regress.annotation_return_filename).must_equal "a utf-8 filename"
-  end
-
-  it "has a working function #annotation_set_source_file" do
-    _(Regress.annotation_set_source_file("a filename")).must_be_nil
-  end
-
-  it "has a working function #annotation_space_after_comment_bug631690" do
-    _(Regress.annotation_space_after_comment_bug631690).must_be_nil
-  end
-
-  it "has a working function #annotation_string_array_length" do
-    _(Regress.annotation_string_array_length(%w(foo bar))).must_be_nil
-  end
-
-  it "has a working function #annotation_string_zero_terminated" do
-    _(Regress.annotation_string_zero_terminated.to_a).must_equal []
-  end
-
-  it "has a working function #annotation_string_zero_terminated_out" do
-    _(Regress.annotation_string_zero_terminated_out(%w(foo bar)).to_a)
-      .must_equal %w(foo bar)
-  end
-
-  it "has a working function #annotation_test_parsing_bug630862" do
-    _(Regress.annotation_test_parsing_bug630862).must_be_nil
-  end
-
-  it "has a working function #annotation_transfer_floating" do
-    Regress.setup_method! :annotation_transfer_floating
-    method = Regress.method :annotation_transfer_floating
-    # NOTE: The arity of this method was changed in GObjectIntrospection 1.53.2
-    if method.arity == 1
-      object = GObject::Object.new
-      _(Regress.annotation_transfer_floating(object)).must_be_nil
-    else
-      _(Regress.annotation_transfer_floating).must_be_nil
-    end
-  end
-
-  it "has a working function #annotation_versioned" do
-    _(Regress.annotation_versioned).must_be_nil
-  end
-
-  it "has a working function #atest_error_quark" do
-    result = Regress.atest_error_quark
-    _(GLib.quark_to_string(result)).must_equal "regress-atest-error"
-  end
-
-  it "has a working function #foo_async_ready_callback" do
-    skip "This function is defined in the header but not implemented"
-  end
-
-  it "has a working function #foo_destroy_notify_callback" do
-    skip "This function is defined in the header but not implemented"
-  end
-
-  it "has a working function #foo_enum_type_method" do
-    skip "This function is defined in the header but not implemented"
-  end
-
-  it "has a working function #foo_enum_type_returnv" do
-    skip "This function is defined in the header but not implemented"
-  end
-
-  it "has a working function #foo_error_quark" do
-    result = Regress.foo_error_quark
-    _(GLib.quark_to_string(result)).must_equal("regress_foo-error-quark")
-  end
-
-  it "has a working function #foo_init" do
-    _(Regress.foo_init).must_equal 0x1138
-  end
-
-  it "has a working function #foo_interface_static_method" do
-    _(Regress.foo_interface_static_method(42)).must_be_nil
-  end
-
-  it "has a working function #foo_method_external_references" do
-    skip "This function is defined in the header but not implemented"
-  end
-
-  it "has a working function #foo_not_a_constructor_new" do
-    _(Regress.foo_not_a_constructor_new).must_be_nil
-  end
-
-  it "has a working function #foo_test_array" do
-    _(Regress.foo_test_array).must_be_nil
-  end
-
-  it "has a working function #foo_test_const_char_param" do
-    skip "This function is defined in the header but not implemented"
-  end
-
-  it "has a working function #foo_test_const_char_retval" do
-    skip "This function is defined in the header but not implemented"
-  end
-
-  it "has a working function #foo_test_const_struct_param" do
-    skip "This function is defined in the header but not implemented"
-  end
-
-  it "has a working function #foo_test_const_struct_retval" do
-    skip "This function is defined in the header but not implemented"
-  end
-
-  it "has a working function #foo_test_string_array" do
-    _(Regress.foo_test_string_array(%w(foo bar))).must_be_nil
-  end
-
-  it "has a working function #foo_test_string_array_with_g" do
-    _(Regress.foo_test_string_array_with_g(%w(foo bar))).must_be_nil
-  end
-
-  it "has a working function #foo_test_unsigned_qualifier" do
-    skip "This function is defined in the header but not implemented"
-  end
-
-  it "has a working function #foo_test_unsigned_type" do
-    skip "This function is defined in the header but not implemented"
-  end
-
-  it "has a working function #func_obj_null_in" do
-    Regress.func_obj_null_in nil
-    Regress.func_obj_null_in Regress::TestObj.constructor
-    pass
-  end
-
-  it "has a working function #func_obj_nullable_in" do
-    Regress.func_obj_null_in nil
-    Regress.func_obj_null_in Regress::TestObj.constructor
-    pass
-  end
-
-  it "has a working function #get_variant" do
-    skip_below "1.47.92"
-    var = Regress.get_variant
-    _(var.get_int32).must_equal 42
-    # TODO: Make var not floating
-  end
-
-  it "has a working function #global_get_flags_out" do
-    result = Regress.global_get_flags_out
-    _(result).must_equal(flag1: true, flag3: true)
-  end
-
-  it "has a working function #has_parameter_named_attrs" do
-    Regress.has_parameter_named_attrs 42, [23] * 32
-    pass
-  end
-
-  it "has a working function #introspectable_via_alias" do
-    Regress.introspectable_via_alias []
-    pass
-  end
-
-  it "has a working function #set_abort_on_error" do
-    Regress.set_abort_on_error false
-    Regress.set_abort_on_error true
-    pass
-  end
-
-  it "has a working function #test_abc_error_quark" do
-    quark = Regress.test_abc_error_quark
-    _(GLib.quark_to_string(quark)).must_equal "regress-test-abc-error"
-  end
-
-  it "has a working function #test_array_callback" do
-    a = nil
-    b = nil
-    c = 95
-
-    result = Regress.test_array_callback do |one, two|
-      a = one
-      b = two
-      c
-    end
-
-    _(result).must_equal 2 * c
-    _(a.to_a).must_equal [-1, 0, 1, 2]
-    _(b.to_a).must_equal %w(one two three)
-  end
-
-  it "has a working function #test_array_fixed_out_objects" do
-    result = Regress.test_array_fixed_out_objects
-    gtype = Regress::TestObj.gtype
-
-    _(result.size).must_equal 2
-
-    result.each do |o|
-      assert_instance_of Regress::TestObj, o
-      assert_equal gtype, GObject.type_from_instance(o)
-    end
-  end
-
-  it "has a working function #test_array_fixed_size_int_in" do
-    assert_equal 5 + 4 + 3 + 2 + 1, Regress.test_array_fixed_size_int_in([5, 4, 3, 2, 1])
-  end
-
-  describe "#test_array_fixed_size_int_in" do
-    it "raises an error when called with the wrong number of arguments" do
-      assert_raises ArgumentError do
-        Regress.test_array_fixed_size_int_in [2]
-      end
-    end
-  end
-
-  it "has a working function #test_array_fixed_size_int_out" do
-    _(Regress.test_array_fixed_size_int_out).must_be :==, [0, 1, 2, 3, 4]
-  end
-
-  it "has a working function #test_array_fixed_size_int_return" do
-    _(Regress.test_array_fixed_size_int_return).must_be :==, [0, 1, 2, 3, 4]
-  end
-
-  it "has a working function #test_array_gint16_in" do
-    assert_equal 5 + 4 + 3, Regress.test_array_gint16_in([5, 4, 3])
-  end
-
-  it "has a working function #test_array_gint32_in" do
-    assert_equal 5 + 4 + 3, Regress.test_array_gint32_in([5, 4, 3])
-  end
-
-  it "has a working function #test_array_gint64_in" do
-    assert_equal 5 + 4 + 3, Regress.test_array_gint64_in([5, 4, 3])
-  end
-
-  it "has a working function #test_array_gint8_in" do
-    assert_equal 5 + 4 + 3, Regress.test_array_gint8_in([5, 4, 3])
-  end
-
-  it "has a working function #test_array_gtype_in" do
-    t1 = GObject.type_from_name "gboolean"
-    t2 = GObject.type_from_name "gint64"
-    assert_equal "[gboolean,gint64,]", Regress.test_array_gtype_in([t1, t2])
-  end
-
-  it "has a working function #test_array_inout_callback" do
-    Regress.test_array_inout_callback do |ints|
-      arr = ints.to_a
-      arr.shift
-      arr
-    end
-    pass
-  end
-
-  it "has a working function #test_array_int_full_out" do
-    _(Regress.test_array_int_full_out).must_be :==, [0, 1, 2, 3, 4]
-  end
-
-  it "has a working function #test_array_int_in" do
-    assert_equal 5 + 4 + 3, Regress.test_array_int_in([5, 4, 3])
-  end
-
-  it "has a working function #test_array_int_inout" do
-    _(Regress.test_array_int_inout([5, 2, 3])).must_be :==, [3, 4]
-  end
-
-  it "has a working function #test_array_int_none_out" do
-    _(Regress.test_array_int_none_out).must_be :==, [1, 2, 3, 4, 5]
-  end
-
-  it "has a working function #test_array_int_null_in" do
-    Regress.test_array_int_null_in nil
-    pass
-  end
-
-  it "has a working function #test_array_int_null_out" do
-    _(Regress.test_array_int_null_out).must_be_nil
-  end
-
-  it "has a working function #test_array_int_out" do
-    _(Regress.test_array_int_out).must_be :==, [0, 1, 2, 3, 4]
-  end
-
-  it "has a working function #test_array_struct_in_full" do
-    skip_below "1.59.4"
-    # FIXME: Allow passing field values to .new
-    arr = [Regress::TestStructA.new.tap { |it| it.some_int = 201 },
-           Regress::TestStructA.new.tap { |it| it.some_int = 202 }]
-    Regress.test_array_struct_in_full(arr)
-  end
-
-  it "has a working function #test_array_struct_in_none" do
-    skip_below "1.59.4"
-    # FIXME: Allow passing field values to .new
-    arr = [Regress::TestStructA.new.tap { |it| it.some_int = 301 },
-           Regress::TestStructA.new.tap { |it| it.some_int = 302 },
-           Regress::TestStructA.new.tap { |it| it.some_int = 303 }]
-    Regress.test_array_struct_in_none(arr)
-  end
-
-  it "has a working function #test_array_struct_out" do
-    skip_below "1.47.92"
-    result = Regress.test_array_struct_out
-    _(result.map(&:some_int)).must_equal [22, 33, 44]
-  end
-
-  it "has a working function #test_array_struct_out_caller_alloc" do
-    skip_below "1.59.4"
-    skip "Not implemented yet"
-    result = Regress.test_array_struct_out_caller_alloc 3
-    _(result.map(&:some_int)).must_equal [22, 33, 44]
-  end
-
-  it "has a working function #test_array_struct_out_container" do
-    skip_below "1.59.4"
-    result = Regress.test_array_struct_out_container
-    _(result.map(&:some_int)).must_equal [11, 13, 17, 19, 23]
-  end
-
-  it "has a working function #test_array_struct_out_full_fixed" do
-    skip_below "1.59.4"
-    result = Regress.test_array_struct_out_full_fixed
-    _(result.map(&:some_int)).must_equal [2, 3, 5, 7]
-  end
-
-  it "has a working function #test_array_struct_out_none" do
-    skip_below "1.59.4"
-    result = Regress.test_array_struct_out_none
-    _(result.map(&:some_int)).must_equal [111, 222, 333]
-  end
-
-  it "has a working function #test_async_ready_callback" do
-    main_loop = GLib::MainLoop.new nil, false
-
-    a = 1
-    Regress.test_async_ready_callback do
-      main_loop.quit
-      a = 2
-    end
-
-    main_loop.run
-
-    assert_equal 2, a
-  end
-
-  it "has a working function #test_boolean" do
-    assert_equal false, Regress.test_boolean(false)
-    assert_equal true, Regress.test_boolean(true)
-  end
-
-  it "has a working function #test_boolean_false" do
-    assert_equal false, Regress.test_boolean_false(false)
-  end
-
-  it "has a working function #test_boolean_true" do
-    assert_equal true, Regress.test_boolean_true(true)
-  end
-
-  it "has a working function #test_boxeds_not_a_method" do
-    boxed = Regress::TestBoxed.new_alternative_constructor1 123
-    Regress.test_boxeds_not_a_method boxed
-    pass
-  end
-
-  it "has a working function #test_boxeds_not_a_static" do
-    Regress.test_boxeds_not_a_static
-    pass
-  end
-
-  it "has a working function #test_cairo_context_full_return" do
-    ct = Regress.test_cairo_context_full_return
-    assert_instance_of Cairo::Context, ct
-  end
-
-  it "has a working function #test_cairo_context_none_in" do
-    ct = Regress.test_cairo_context_full_return
-    Regress.test_cairo_context_none_in ct
-  end
-
-  it "has a working function #test_cairo_surface_full_out" do
-    cs = Regress.test_cairo_surface_full_out
-    assert_instance_of Cairo::Surface, cs
-  end
-
-  it "has a working function #test_cairo_surface_full_return" do
-    cs = Regress.test_cairo_surface_full_return
-    assert_instance_of Cairo::Surface, cs
-  end
-
-  it "has a working function #test_cairo_surface_none_in" do
-    cs = Regress.test_cairo_surface_full_return
-    Regress.test_cairo_surface_none_in cs
-  end
-
-  it "has a working function #test_cairo_surface_none_return" do
-    cs = Regress.test_cairo_surface_none_return
-    assert_instance_of Cairo::Surface, cs
-  end
-
-  it "has a working function #test_callback" do
-    result = Regress.test_callback { 5 }
-    assert_equal 5, result
-  end
-
-  it "has a working function #test_callback_async" do
-    a = 1
-    stored_proc = nil
-    Regress.test_callback_async do |user_data|
-      stored_proc = user_data
-      a = 2
-    end
-    result = Regress.test_callback_thaw_async
-    _(a).must_equal 2
-    _(stored_proc).wont_be_nil
-    _(result).must_equal 2
-    # TODO: See when we can clean up the stored callback for async callbacks.
-    stored_id = stored_proc.object_id
-    _(GirFFI::CallbackBase::CALLBACKS[stored_id].object_id).must_equal stored_id
-  end
-
-  it "has a working function #test_callback_destroy_notify" do
-    a = 1
-    stored_proc = nil
-    r1 = Regress.test_callback_destroy_notify do |user_data|
-      stored_proc = user_data
-      a = 2
-    end
-    _(a).must_equal 2
-    stored_id = stored_proc.object_id
-    _(GirFFI::CallbackBase::CALLBACKS[stored_id].object_id).must_equal stored_id
-
-    a = 3
-    r2 = Regress.test_callback_thaw_notifications
-    _(a).must_equal 2
-    _(r1).must_equal r2
-    _(GirFFI::CallbackBase::CALLBACKS[stored_id]).must_be_nil
-  end
-
-  it "has a working function #test_callback_destroy_notify_no_user_data" do
-    callback_times_called = 0
-    b = :not_nil
-
-    result = Regress.test_callback_destroy_notify_no_user_data do |user_data|
-      callback_times_called += 1
-      b = user_data
-      callback_times_called * 5
-    end
-
-    _(callback_times_called).must_equal 1
-    _(result).must_equal 5
-    _(b).must_be_nil
-
-    result = Regress.test_callback_thaw_notifications
-
-    _(callback_times_called).must_equal 2
-    _(result).must_equal 10
-    _(b).must_be_nil
-  end
-
-  it "has a working function #test_callback_return_full" do
-    obj = Regress::TestObj.constructor
-    Regress.test_callback_return_full { obj }
-    _(object_ref_count(obj)).must_equal 1
-  end
-
-  it "has a working function #test_callback_thaw_async" do
-    invoked = []
-    Regress.test_callback_async do
-      invoked << 1
-      1
-    end
-    Regress.test_callback_async do
-      invoked << 2
-      2
-    end
-    Regress.test_callback_async do
-      invoked << 3
-      3
-    end
-    result = Regress.test_callback_thaw_async
-    _(invoked).must_equal [3, 2, 1]
-    _(result).must_equal 1
-  end
-
-  it "has a working function #test_callback_thaw_notifications" do
-    Regress.test_callback_destroy_notify { 42 }
-    Regress.test_callback_destroy_notify { 24 }
-    result = Regress.test_callback_thaw_notifications
-    _(result).must_equal 66
-  end
-
-  it "has a working function #test_callback_user_data" do
-    stored_id = nil
-    result = Regress.test_callback_user_data do |u|
-      stored_id = u
-      5
-    end
-    # TODO: Ensure that the key stored_id is no longer in the callback store
-    _(stored_id).wont_be_nil
-    _(result).must_equal 5
-  end
-
-  it "has a working function #test_closure" do
-    c = GObject::RubyClosure.new { 5235 }
-    r = Regress.test_closure c
-    assert_equal 5235, r
-  end
-
-  it "has a working function #test_closure_one_arg" do
-    c = GObject::RubyClosure.new { |a| a * 2 }
-    r = Regress.test_closure_one_arg c, 2
-    assert_equal 4, r
-  end
-
-  it "has a working function #test_closure_variant" do
-    arg = GLib::Variant.new_string "foo"
-
-    # TODO: Convert proc to RubyClosure automatically
-    closure = GObject::RubyClosure.new do |variant|
-      str = variant.get_string
-      if str == "foo"
-        GLib::Variant.new_int32 40
-      else
-        GLib::Variant.new_string "bar"
-      end
-    end
-
-    result = Regress.test_closure_variant closure, arg
-
-    _(result.get_int32).must_equal 40
-  end
-
-  it "has a working function #test_create_fundamental_hidden_class_instance" do
-    skip_below "1.51.2"
-    instance = Regress.test_create_fundamental_hidden_class_instance
-    _(instance).must_be_kind_of Regress::TestFundamentalObject
-    g_type = instance.object_class.g_type
-    _(GObject.type_name(g_type)).must_equal "RegressTestFundamentalHiddenSubObject"
-  end
-
-  it "has a working function #test_date_in_gvalue" do
-    date = Regress.test_date_in_gvalue
-    assert_equal [1984, :december, 5],
-                 [date.get_year, date.get_month, date.get_day]
-  end
-
-  it "has a working function #test_def_error_quark" do
-    quark = Regress.test_def_error_quark
-    _(GLib.quark_to_string(quark)).must_equal "regress-test-def-error"
-  end
-
-  it "has a working function #test_double" do
-    r = Regress.test_double 5435.32
-    assert_equal 5435.32, r
-  end
-
-  it "has a working function #test_enum_param" do
-    r = Regress.test_enum_param :value3
-    assert_equal "value3", r
-  end
-
-  it "has a working function #test_error_quark" do
-    quark = Regress.test_error_quark
-    _(GLib.quark_to_string(quark)).must_equal "regress-test-error"
-  end
-
-  it "has a working function #test_filename_return" do
-    arr = Regress.test_filename_return
-    _(arr).must_be :==, ["åäö", "/etc/fstab"]
-  end
-
-  it "has a working function #test_float" do
-    r = Regress.test_float 5435.32
-    assert_in_delta 5435.32, r, 0.001
-  end
-
-  it "has a working function #test_garray_container_return" do
-    arr = Regress.test_garray_container_return
-    _(arr).must_be_instance_of GLib::PtrArray
-    _(arr.len).must_equal 1
-    _(arr.to_a).must_equal ["regress"]
-  end
-
-  it "has a working function #test_garray_full_return" do
-    result = Regress.test_garray_full_return
-    _(result.to_a).must_equal ["regress"]
-  end
-
-  it "has a working function #test_gerror_callback" do
-    result = nil
-    Regress.test_gerror_callback { |err| result = err.message }
-    _(result).must_equal "regression test error"
-  end
-
-  it "has a working function #test_ghash_container_return" do
-    hash = Regress.test_ghash_container_return
-    _(hash).must_be_instance_of GLib::HashTable
-    _(hash.to_hash).must_equal("foo" => "bar",
-                            "baz" => "bat",
-                            "qux" => "quux")
-  end
-
-  it "has a working function #test_ghash_everything_return" do
-    ghash = Regress.test_ghash_everything_return
-    _(ghash.to_hash).must_be :==, "foo" => "bar",
-                               "baz" => "bat",
-                               "qux" => "quux"
-  end
-
-  it "has a working function #test_ghash_gvalue_in" do
-    hash_table = Regress.test_ghash_gvalue_return
-    Regress.test_ghash_gvalue_in hash_table
-  end
-
-  it "has a working function #test_ghash_gvalue_return" do
-    result = Regress.test_ghash_gvalue_return
-    hash = result.to_hash
-
-    has_enum_and_flag_keys = hash.key?("flags")
-
-    _(hash["integer"].get_value).must_equal 12
-    _(hash["boolean"].get_value).must_equal true
-    _(hash["string"].get_value).must_equal "some text"
-    _(hash["strings"].get_value.to_a).must_equal %w(first second third)
-
-    if has_enum_and_flag_keys
-      _(hash["flags"].get_value).must_equal flag1: true, flag3: true
-      _(hash["enum"].get_value).must_equal :value2
-    end
-
-    expected_keys = if has_enum_and_flag_keys
-                      %w(boolean enum flags integer string strings)
-                    else
-                      %w(boolean integer string strings)
-                    end
-
-    _(hash.keys.sort).must_equal expected_keys
-  end
-
-  it "has a working function #test_ghash_nested_everything_return" do
-    result = Regress.test_ghash_nested_everything_return
-    hash = result.to_hash
-    _(hash.keys).must_equal ["wibble"]
-    _(hash["wibble"].to_hash).must_equal("foo" => "bar",
-                                      "baz" => "bat",
-                                      "qux" => "quux")
-  end
-
-  it "has a working function #test_ghash_nested_everything_return2" do
-    result = Regress.test_ghash_nested_everything_return2
-    hash = result.to_hash
-    _(hash.keys).must_equal ["wibble"]
-    _(hash["wibble"].to_hash).must_equal("foo" => "bar",
-                                      "baz" => "bat",
-                                      "qux" => "quux")
-  end
-
-  it "has a working function #test_ghash_nothing_in" do
-    Regress.test_ghash_nothing_in("foo" => "bar",
-                                  "baz" => "bat",
-                                  "qux" => "quux")
-  end
-
-  it "has a working function #test_ghash_nothing_in2" do
-    Regress.test_ghash_nothing_in2("foo" => "bar",
-                                   "baz" => "bat",
-                                   "qux" => "quux")
-  end
-
-  it "has a working function #test_ghash_nothing_return" do
-    ghash = Regress.test_ghash_nothing_return
-    _(ghash.to_hash).must_be :==, "foo" => "bar",
-                               "baz" => "bat",
-                               "qux" => "quux"
-  end
-
-  it "has a working function #test_ghash_nothing_return2" do
-    ghash = Regress.test_ghash_nothing_return2
-    _(ghash.to_hash).must_be :==, "foo" => "bar",
-                               "baz" => "bat",
-                               "qux" => "quux"
-  end
-
-  it "has a working function #test_ghash_null_in" do
-    Regress.test_ghash_null_in(nil)
-  end
-
-  it "has a working function #test_ghash_null_out" do
-    ghash = Regress.test_ghash_null_out
-    _(ghash).must_be_nil
-  end
-
-  it "has a working function #test_ghash_null_return" do
-    ghash = Regress.test_ghash_null_return
-    _(ghash).must_be_nil
-  end
-
-  it "has a working function #test_glist_container_return" do
-    list = Regress.test_glist_container_return
-    assert_instance_of GLib::List, list
-    _(list).must_be :==, %w(1 2 3)
-  end
-
-  it "has a working function #test_glist_everything_return" do
-    list = Regress.test_glist_everything_return
-    _(list).must_be :==, %w(1 2 3)
-  end
-
-  it "has a working function #test_glist_gtype_container_in" do
-    Regress.test_glist_gtype_container_in [Regress::TestObj.gtype, Regress::TestSubObj.gtype]
-    pass
-  end
-
-  it "has a working function #test_glist_nothing_in" do
-    Regress.test_glist_nothing_in %w(1 2 3)
-    pass
-  end
-
-  it "has a working function #test_glist_nothing_in2" do
-    Regress.test_glist_nothing_in2 %w(1 2 3)
-    pass
-  end
-
-  it "has a working function #test_glist_nothing_return" do
-    list = Regress.test_glist_nothing_return
-    _(list).must_be :==, %w(1 2 3)
-  end
-
-  it "has a working function #test_glist_nothing_return2" do
-    list = Regress.test_glist_nothing_return2
-    _(list).must_be :==, %w(1 2 3)
-  end
-
-  it "has a working function #test_glist_null_in" do
-    Regress.test_glist_null_in nil
-    pass
-  end
-
-  it "has a working function #test_glist_null_out" do
-    result = Regress.test_glist_null_out
-    _(result).must_be_nil
-  end
-
-  it "has a working function #test_gslist_container_return" do
-    slist = Regress.test_gslist_container_return
-    assert_instance_of GLib::SList, slist
-    _(slist).must_be :==, %w(1 2 3)
-  end
-
-  it "has a working function #test_gslist_everything_return" do
-    slist = Regress.test_gslist_everything_return
-    _(slist).must_be :==, %w(1 2 3)
-  end
-
-  it "has a working function #test_gslist_nothing_in" do
-    Regress.test_gslist_nothing_in %w(1 2 3)
-    pass
-  end
-
-  it "has a working function #test_gslist_nothing_in2" do
-    Regress.test_gslist_nothing_in2 %w(1 2 3)
-    pass
-  end
-
-  it "has a working function #test_gslist_nothing_return" do
-    slist = Regress.test_gslist_nothing_return
-    _(slist).must_be :==, %w(1 2 3)
-  end
-
-  it "has a working function #test_gslist_nothing_return2" do
-    slist = Regress.test_gslist_nothing_return2
-    _(slist).must_be :==, %w(1 2 3)
-  end
-
-  it "has a working function #test_gslist_null_in" do
-    Regress.test_gslist_null_in nil
-    pass
-  end
-
-  it "has a working function #test_gslist_null_out" do
-    result = Regress.test_gslist_null_out
-    _(result).must_be_nil
-  end
-
-  it "has a working function #test_gtype" do
-    result = Regress.test_gtype 23
-    assert_equal 23, result
-  end
-
-  it "has a working function #test_gvariant_as" do
-    _(Regress.test_gvariant_as.get_strv.to_a).must_equal %w(one two three)
-  end
-
-  it "has a working function #test_gvariant_asv" do
-    result = Regress.test_gvariant_asv
-    _(result.n_children).must_equal 2
-    _(result.lookup_value("name").get_string).must_equal "foo"
-    _(result.lookup_value("timeout").get_int32).must_equal 10
-  end
-
-  it "has a working function #test_gvariant_i" do
-    _(Regress.test_gvariant_i.get_int32).must_equal 1
-  end
-
-  it "has a working function #test_gvariant_s" do
-    _(Regress.test_gvariant_s.get_string).must_equal "one"
-  end
-
-  it "has a working function #test_gvariant_v" do
-    _(Regress.test_gvariant_v.get_variant.get_string).must_equal "contents"
-  end
-
-  it "has a working function #test_hash_table_callback" do
-    value = nil
-    Regress.test_hash_table_callback("foo" => 42) { |hash| value = hash }
-    _(value.to_hash).must_equal("foo" => 42)
-  end
-
-  it "has a working function #test_int" do
-    result = Regress.test_int 23
-    assert_equal 23, result
-  end
-
-  it "has a working function #test_int16" do
-    result = Regress.test_int16 23
-    assert_equal 23, result
-  end
-
-  it "has a working function #test_int32" do
-    result = Regress.test_int32 23
-    assert_equal 23, result
-  end
-
-  it "has a working function #test_int64" do
-    result = Regress.test_int64 2_300_000_000_000
-    assert_equal 2_300_000_000_000, result
-  end
-
-  it "has a working function #test_int8" do
-    result = Regress.test_int8 23
-    assert_equal 23, result
-  end
-
-  it "has a working function #test_int_out_utf8" do
-    len = Regress.test_int_out_utf8 "How long?"
-    assert_equal 9, len
-  end
-
-  it "has a working function #test_int_value_arg" do
-    gv = GObject::Value.new
-    gv.init GObject.type_from_name "gint"
-    gv.set_int 343
-    result = Regress.test_int_value_arg gv
-    assert_equal 343, result
-  end
-
-  it "has a working function #test_long" do
-    long_val = FFI.type_size(:long) == 8 ? 2_300_000_000_000 : 2_000_000_000
-    result = Regress.test_long long_val
-    assert_equal long_val, result
-  end
-
-  it "has a working function #test_multi_callback" do
-    a = 1
-    result = Regress.test_multi_callback do
-      a += 1
-      23
-    end
-    assert_equal 2 * 23, result
-    assert_equal 3, a
-  end
-
-  it "has a working function #test_multi_double_args" do
-    one, two = Regress.test_multi_double_args 23.1
-    assert_equal 2 * 23.1, one
-    assert_equal 3 * 23.1, two
-  end
-
-  it "has a working function #test_multiline_doc_comments" do
-    _(Regress.test_multiline_doc_comments).must_be_nil
-  end
-
-  it "has a working function #test_nested_parameter" do
-    _(Regress.test_nested_parameter(3)).must_be_nil
-  end
-
-  it "has a working function #test_noptr_callback" do
-    skip_below "1.47.1"
-    a = 0
-    Regress.test_noptr_callback { a = 1 }
-    _(a).must_equal 1
-  end
-
-  it "has a working function #test_null_gerror_callback" do
-    value = nil
-    Regress.test_owned_gerror_callback { |err| value = err }
-    _(value.message).must_equal "regression test owned error"
-  end
-
-  it "has a working function #test_null_strv_in_gvalue" do
-    skip_below "1.53.1"
-    result = Regress.test_null_strv_in_gvalue
-    _(result.to_a).must_be :empty?
-  end
-
-  it "has a working function #test_owned_gerror_callback" do
-    value = nil
-    Regress.test_owned_gerror_callback { |err| value = err }
-    _(value.message).must_equal "regression test owned error"
-  end
-
-  it "has a working function #test_return_allow_none" do
-    skip_below "1.47.1"
-    result = Regress.test_return_allow_none
-    _(result).must_be_nil
-  end
-
-  it "has a working function #test_return_nullable" do
-    skip_below "1.47.1"
-    result = Regress.test_return_nullable
-    _(result).must_be_nil
-  end
-
-  it "has a working function #test_short" do
-    result = Regress.test_short 23
-    assert_equal 23, result
-  end
-
-  it "has a working function #test_simple_boxed_a_const_return" do
-    result = Regress.test_simple_boxed_a_const_return
-    assert_equal [5, 6, 7.0], [result.some_int, result.some_int8, result.some_double]
-  end
-
-  it "has a working function #test_simple_callback" do
-    a = 0
-    Regress.test_simple_callback { a = 1 }
-    assert_equal 1, a
-  end
-
-  it "has a working function #test_size" do
-    assert_equal 2354, Regress.test_size(2354)
-  end
-
-  it "has a working function #test_ssize" do
-    assert_equal(-2_000_000, Regress.test_ssize(-2_000_000))
-  end
-
-  it "has a working function #test_struct_a_parse" do
-    a = Regress.test_struct_a_parse("this string is actually ignored")
-    _(a).must_be_instance_of Regress::TestStructA
-    _(a.some_int).must_equal 23
-  end
-
-  it "has a working function #test_strv_in" do
-    assert_equal true, Regress.test_strv_in(%w(1 2 3))
-  end
-
-  it "has a working function #test_strv_in_gvalue" do
-    arr = Regress.test_strv_in_gvalue
-    _(arr).must_be :==, %w(one two three)
-  end
-
-  it "has a working function #test_strv_out" do
-    arr = Regress.test_strv_out
-    _(arr).must_be :==, %w(thanks for all the fish)
-  end
-
-  it "has a working function #test_strv_out_c" do
-    arr = Regress.test_strv_out_c
-    _(arr).must_be :==, %w(thanks for all the fish)
-  end
-
-  it "has a working function #test_strv_out_container" do
-    arr = Regress.test_strv_out_container
-    _(arr).must_be :==, %w(1 2 3)
-  end
-
-  it "has a working function #test_strv_outarg" do
-    arr = Regress.test_strv_outarg
-    _(arr).must_be :==, %w(1 2 3)
-  end
-
-  it "has a working function #test_timet" do
-    # Time rounded to seconds.
-    t = Time.at(Time.now.to_i)
-    result = Regress.test_timet(t.to_i)
-    assert_equal t, Time.at(result)
-  end
-
-  it "has a working function #test_torture_signature_0" do
-    y, z, q = Regress.test_torture_signature_0 86, "foo", 2
-    assert_equal [86, 2 * 86, 3 + 2], [y, z, q]
-  end
-
-  it "has a working function #test_torture_signature_1" do
-    ret, y, z, q = Regress.test_torture_signature_1(-21, "hello", 12)
-    _([ret, y, z, q]).must_equal [true, -21, 2 * -21, "hello".length + 12]
-
-    _(proc { Regress.test_torture_signature_1(-21, "hello", 11) })
-      .must_raise GirFFI::GLibError
-  end
-
-  it "has a working function #test_torture_signature_2" do
-    a = 1
-    y, z, q = Regress.test_torture_signature_2 244, "foofoo", 31 do |u|
-      a = u
-    end
-    assert_equal [244, 2 * 244, 6 + 31], [y, z, q]
-    _(a).must_be_instance_of Regress::TestCallbackUserData
-  end
-
-  it "has a working function #test_uint" do
-    assert_equal 31, Regress.test_uint(31)
-  end
-
-  it "has a working function #test_uint16" do
-    assert_equal 31, Regress.test_uint16(31)
-  end
-
-  it "has a working function #test_uint32" do
-    assert_equal 540_000, Regress.test_uint32(540_000)
-  end
-
-  it "has a working function #test_uint64" do
-    assert_equal 54_000_000_000_000, Regress.test_uint64(54_000_000_000_000)
-  end
-
-  it "has a working function #test_uint8" do
-    assert_equal 31, Regress.test_uint8(31)
-  end
-
-  it "has a working function #test_ulong" do
-    assert_equal 54_000_000_000_000, Regress.test_uint64(54_000_000_000_000)
-  end
-
-  it "has a working function #test_unconventional_error_quark" do
-    result = Regress.test_unconventional_error_quark
-    _(GLib.quark_to_string(result)).must_equal "regress-test-other-error"
-  end
-
-  it "has a working function #test_unichar" do
-    assert_equal 120, Regress.test_unichar(120)
-    assert_equal 540_000, Regress.test_unichar(540_000)
-  end
-
-  it "has a working function #test_unsigned_enum_param" do
-    assert_equal "value1", Regress.test_unsigned_enum_param(:value1)
-    assert_equal "value2", Regress.test_unsigned_enum_param(:value2)
-  end
-
-  it "has a working function #test_ushort" do
-    assert_equal 54_000_000, Regress.test_uint64(54_000_000)
-  end
-
-  it "has a working function #test_utf8_const_in" do
-    Regress.test_utf8_const_in("const \xe2\x99\xa5 utf8")
-    pass
-  end
-
-  it "has a working function #test_utf8_const_return" do
-    result = Regress.test_utf8_const_return
-    assert_equal "const \xe2\x99\xa5 utf8", result
-  end
-
-  it "has a working function #test_utf8_inout" do
-    result = Regress.test_utf8_inout "const \xe2\x99\xa5 utf8"
-    assert_equal "nonconst \xe2\x99\xa5 utf8", result
-  end
-
-  it "has a working function #test_utf8_nonconst_return" do
-    result = Regress.test_utf8_nonconst_return
-    assert_equal "nonconst \xe2\x99\xa5 utf8", result
-  end
-
-  it "has a working function #test_utf8_null_in" do
-    Regress.test_utf8_null_in nil
-    pass
-  end
-
-  it "has a working function #test_utf8_null_out" do
-    _(Regress.test_utf8_null_out).must_be_nil
-  end
-
-  it "has a working function #test_utf8_out" do
-    result = Regress.test_utf8_out
-    assert_equal "nonconst \xe2\x99\xa5 utf8", result
-  end
-
-  it "has a working function #test_utf8_out_nonconst_return" do
-    r, out = Regress.test_utf8_out_nonconst_return
-    assert_equal %w(first second), [r, out]
-  end
-
-  it "has a working function #test_utf8_out_out" do
-    out0, out1 = Regress.test_utf8_out_nonconst_return
-    assert_equal %w(first second), [out0, out1]
-  end
-
-  it "has a working function #test_value_return" do
-    result = Regress.test_value_return 3423
-    _(result).must_equal 3423
-  end
-
-  it "has a working function #test_versioning" do
-    # TODO: Handle deprecation
-    Regress.test_versioning
-    pass
-  end
-
-  it "raises an appropriate NoMethodError when a function is not found" do
-    result = _(proc { Regress.this_method_does_not_exist }).must_raise(NoMethodError)
-    _(result.message).must_match(/^undefined method `this_method_does_not_exist' (for Regress:Module|on Regress \(Module\))$/)
-  end
-end