RubyGems - gir_ffi - Versions diffs - 0.15.3 → 0.15.4 - Mend

gir_ffi 0.15.3 → 0.15.4

Files changed (183) hide show

checksums.yaml +4 -4
data/Changelog.md +15 -0
data/README.md +5 -6
data/TODO.md +14 -35
data/docs/Documentation.md +6 -0
data/docs/Subclassing.md +38 -0
data/lib/ffi-glib.rb +8 -3
data/lib/ffi-glib/byte_array.rb +2 -1
data/lib/ffi-glib/destroy_notify.rb +2 -2
data/lib/ffi-glib/hash_table.rb +1 -2
data/lib/ffi-glib/list.rb +11 -5
data/lib/ffi-glib/list_methods.rb +12 -0
data/lib/ffi-glib/s_list.rb +10 -4
data/lib/ffi-gobject.rb +0 -3
data/lib/ffi-gobject/object.rb +77 -73
data/lib/ffi-gobject/object_class.rb +1 -1
data/lib/ffi-gobject/value.rb +107 -108
data/lib/ffi-gobject_introspection/i_base_info.rb +20 -19
data/lib/gir_ffi-base/gobject/lib.rb +4 -0
data/lib/gir_ffi/array_element_convertor.rb +1 -2
data/lib/gir_ffi/boxed_base.rb +1 -5
data/lib/gir_ffi/builder.rb +1 -1
data/lib/gir_ffi/builder_helper.rb +7 -4
data/lib/gir_ffi/builders/base_argument_builder.rb +2 -2
data/lib/gir_ffi/builders/base_method_builder.rb +1 -1
data/lib/gir_ffi/builders/base_type_builder.rb +1 -1
data/lib/gir_ffi/builders/callback_argument_builder.rb +2 -0
data/lib/gir_ffi/builders/callback_builder.rb +14 -12
data/lib/gir_ffi/builders/callback_return_value_builder.rb +4 -6
data/lib/gir_ffi/builders/class_struct_builder.rb +24 -0
data/lib/gir_ffi/builders/enum_builder.rb +3 -3
data/lib/gir_ffi/builders/interface_builder.rb +3 -1
data/lib/gir_ffi/builders/mapping_method_builder.rb +1 -1
data/lib/gir_ffi/builders/marshalling_method_builder.rb +5 -2
data/lib/gir_ffi/builders/method_template.rb +4 -4
data/lib/gir_ffi/builders/null_argument_builder.rb +0 -2
data/lib/gir_ffi/builders/null_return_value_builder.rb +0 -2
data/lib/gir_ffi/builders/object_builder.rb +16 -6
data/lib/gir_ffi/builders/property_builder.rb +1 -2
data/lib/gir_ffi/builders/signal_closure_builder.rb +3 -5
data/lib/gir_ffi/builders/struct_builder.rb +5 -5
data/lib/gir_ffi/builders/user_defined_builder.rb +8 -1
data/lib/gir_ffi/builders/vfunc_argument_builder.rb +1 -1
data/lib/gir_ffi/callback_base.rb +3 -3
data/lib/gir_ffi/core.rb +17 -2
data/lib/gir_ffi/glib_error.rb +1 -2
data/lib/gir_ffi/in_pointer.rb +7 -0
data/lib/gir_ffi/object_base.rb +27 -0
data/lib/gir_ffi/return_value_info.rb +1 -2
data/lib/gir_ffi/struct_base.rb +1 -9
data/lib/gir_ffi/struct_like_base.rb +9 -5
data/lib/gir_ffi/unintrospectable_type_info.rb +1 -1
data/lib/gir_ffi/union_base.rb +1 -9
data/lib/gir_ffi/user_defined_object_info.rb +3 -2
data/lib/gir_ffi/version.rb +1 -1
data/lib/gir_ffi/vfunc_implementation.rb +1 -0
metadata +86 -136
data/Gemfile +0 -14
data/Rakefile +0 -9
data/tasks/test.rake +0 -204
data/test/base_test_helper.rb +0 -70
data/test/ffi-glib/array_test.rb +0 -203
data/test/ffi-glib/byte_array_test.rb +0 -28
data/test/ffi-glib/bytes_test.rb +0 -61
data/test/ffi-glib/closure_test.rb +0 -38
data/test/ffi-glib/destroy_notify_test.rb +0 -18
data/test/ffi-glib/hash_table_test.rb +0 -68
data/test/ffi-glib/list_test.rb +0 -86
data/test/ffi-glib/main_loop_test.rb +0 -53
data/test/ffi-glib/ptr_array_test.rb +0 -112
data/test/ffi-glib/ruby_closure_test.rb +0 -62
data/test/ffi-glib/s_list_test.rb +0 -76
data/test/ffi-glib/strv_test.rb +0 -60
data/test/ffi-glib/variant_test.rb +0 -12
data/test/ffi-gobject/gobject_test.rb +0 -76
data/test/ffi-gobject/object_class_test.rb +0 -31
data/test/ffi-gobject/object_test.rb +0 -123
data/test/ffi-gobject/param_spec_test.rb +0 -32
data/test/ffi-gobject/value_test.rb +0 -390
data/test/ffi-gobject_introspection/gobject_type_init_test.rb +0 -26
data/test/ffi-gobject_introspection/i_base_info_test.rb +0 -52
data/test/ffi-gobject_introspection/i_constant_info_test.rb +0 -29
data/test/ffi-gobject_introspection/i_enum_info_test.rb +0 -18
data/test/ffi-gobject_introspection/i_function_info_test.rb +0 -6
data/test/ffi-gobject_introspection/i_interface_info_test.rb +0 -23
data/test/ffi-gobject_introspection/i_object_info_test.rb +0 -49
data/test/ffi-gobject_introspection/i_property_info_test.rb +0 -47
data/test/ffi-gobject_introspection/i_registered_type_info_test.rb +0 -27
data/test/ffi-gobject_introspection/i_repository_test.rb +0 -81
data/test/ffi-gobject_introspection/i_struct_info_test.rb +0 -23
data/test/ffi-gobject_introspection/i_type_info_test.rb +0 -30
data/test/ffi-gobject_introspection/i_union_info_test.rb +0 -17
data/test/ffi-gobject_introspection/i_vfunc_info_test.rb +0 -41
data/test/ffi-gobject_introspection/lib_test.rb +0 -13
data/test/ffi-gobject_introspection/strv_test.rb +0 -46
data/test/ffi-gobject_test.rb +0 -153
data/test/gir_ffi/allocation_helper_test.rb +0 -36
data/test/gir_ffi/arg_helper_test.rb +0 -146
data/test/gir_ffi/boolean_test.rb +0 -43
data/test/gir_ffi/boxed_base_test.rb +0 -65
data/test/gir_ffi/builder_test.rb +0 -168
data/test/gir_ffi/builders/argument_builder_test.rb +0 -691
data/test/gir_ffi/builders/base_argument_builder_test.rb +0 -6
data/test/gir_ffi/builders/callback_argument_builder_test.rb +0 -130
data/test/gir_ffi/builders/callback_builder_test.rb +0 -117
data/test/gir_ffi/builders/callback_return_value_builder_test.rb +0 -84
data/test/gir_ffi/builders/constant_builder_test.rb +0 -6
data/test/gir_ffi/builders/constructor_builder_test.rb +0 -39
data/test/gir_ffi/builders/enum_builder_test.rb +0 -23
data/test/gir_ffi/builders/field_builder_test.rb +0 -140
data/test/gir_ffi/builders/function_builder_test.rb +0 -570
data/test/gir_ffi/builders/initializer_builder_test.rb +0 -56
data/test/gir_ffi/builders/interface_builder_test.rb +0 -32
data/test/gir_ffi/builders/module_builder_test.rb +0 -43
data/test/gir_ffi/builders/object_builder_test.rb +0 -98
data/test/gir_ffi/builders/property_builder_test.rb +0 -161
data/test/gir_ffi/builders/registered_type_builder_test.rb +0 -54
data/test/gir_ffi/builders/return_value_builder_test.rb +0 -444
data/test/gir_ffi/builders/signal_closure_builder_test.rb +0 -199
data/test/gir_ffi/builders/struct_builder_test.rb +0 -96
data/test/gir_ffi/builders/unintrospectable_boxed_builder_test.rb +0 -29
data/test/gir_ffi/builders/unintrospectable_builder_test.rb +0 -84
data/test/gir_ffi/builders/union_builder_test.rb +0 -28
data/test/gir_ffi/builders/user_defined_builder_test.rb +0 -528
data/test/gir_ffi/builders/vfunc_argument_builder_test.rb +0 -107
data/test/gir_ffi/builders/vfunc_builder_test.rb +0 -245
data/test/gir_ffi/callback_base_test.rb +0 -22
data/test/gir_ffi/class_base_test.rb +0 -171
data/test/gir_ffi/core_test.rb +0 -99
data/test/gir_ffi/enum_base_test.rb +0 -43
data/test/gir_ffi/error_type_info_test.rb +0 -50
data/test/gir_ffi/ffi_ext/pointer_test.rb +0 -22
data/test/gir_ffi/g_type_test.rb +0 -31
data/test/gir_ffi/in_pointer_test.rb +0 -203
data/test/gir_ffi/info_ext/i_callable_info_test.rb +0 -26
data/test/gir_ffi/info_ext/i_callback_info_test.rb +0 -22
data/test/gir_ffi/info_ext/i_field_info_test.rb +0 -37
data/test/gir_ffi/info_ext/i_function_info_test.rb +0 -74
data/test/gir_ffi/info_ext/i_signal_info_test.rb +0 -32
data/test/gir_ffi/info_ext/i_type_info_test.rb +0 -712
data/test/gir_ffi/info_ext/i_unresolved_info_test.rb +0 -19
data/test/gir_ffi/info_ext/safe_constant_name_test.rb +0 -26
data/test/gir_ffi/info_ext/safe_function_name_test.rb +0 -26
data/test/gir_ffi/interface_base_test.rb +0 -20
data/test/gir_ffi/method_stubber_test.rb +0 -67
data/test/gir_ffi/object_base_test.rb +0 -64
data/test/gir_ffi/object_store_test.rb +0 -41
data/test/gir_ffi/receiver_argument_info_test.rb +0 -33
data/test/gir_ffi/sized_array_test.rb +0 -206
data/test/gir_ffi/struct_base_test.rb +0 -23
data/test/gir_ffi/struct_like_base_test.rb +0 -167
data/test/gir_ffi/type_map_test.rb +0 -17
data/test/gir_ffi/unintrospectable_type_info_test.rb +0 -121
data/test/gir_ffi/union_base_test.rb +0 -23
data/test/gir_ffi/user_defined_object_info_test.rb +0 -119
data/test/gir_ffi/user_defined_property_info_test.rb +0 -39
data/test/gir_ffi/variable_name_generator_test.rb +0 -18
data/test/gir_ffi/version_test.rb +0 -9
data/test/gir_ffi/zero_terminated_test.rb +0 -108
data/test/gir_ffi_test_helper.rb +0 -84
data/test/integration/callback_exceptions_test.rb +0 -59
data/test/integration/derived_classes_test.rb +0 -54
data/test/integration/generated_everything_test.rb +0 -453
data/test/integration/generated_gimarshallingtests_test.rb +0 -3109
data/test/integration/generated_gio_test.rb +0 -116
data/test/integration/generated_glib_test.rb +0 -10
data/test/integration/generated_gobject_test.rb +0 -124
data/test/integration/generated_gst_test.rb +0 -38
data/test/integration/generated_gtk_source_test.rb +0 -21
data/test/integration/generated_gtop_test.rb +0 -22
data/test/integration/generated_pango_ft2_test.rb +0 -17
data/test/integration/generated_pango_test.rb +0 -24
data/test/integration/generated_regress_test.rb +0 -4076
data/test/integration/generated_secret_test.rb +0 -14
data/test/integration/generated_utility_test.rb +0 -174
data/test/integration/generated_warnlib_test.rb +0 -45
data/test/integration/method_lookup_test.rb +0 -34
data/test/introspection_test_helper.rb +0 -94
data/test/lib/Makefile.am +0 -110
data/test/lib/autogen.sh +0 -4
data/test/lib/configure.ac +0 -34
data/test/lib/m4/jhflags.m4 +0 -21
data/test/minitest/stats_plugin.rb +0 -30

data/test/integration/generated_gimarshallingtests_test.rb DELETED

@@ -1,3109 +0,0 @@
-# frozen_string_literal: true
-require "gir_ffi_test_helper"
-require "gir_ffi"
-GirFFI.setup :GIMarshallingTests
-# Tests generated methods and functions in the GIMarshallingTests namespace.
-describe GIMarshallingTests do
-  let(:derived_klass) do
-    Object.const_set("DerivedClass#{Sequence.next}",
-                     Class.new(GIMarshallingTests::Object))
-  end
-  def make_derived_instance
-    GirFFI.define_type derived_klass do |info|
-      yield info if block_given?
-    end
-    derived_klass.new
-  end
-  describe "GIMarshallingTests::BoxedStruct" do
-    let(:instance) { GIMarshallingTests::BoxedStruct.new }
-    it "has a writable field long_" do
-      instance.long_ = 42
-      assert_equal 42, instance.long_
-      instance.long_ = 43
-      assert_equal 43, instance.long_
-    end
-    it "has a writable field string_" do
-      instance.string_ = "foobar"
-      _(instance.string_).must_equal "foobar"
-    end
-    it "has a writable field g_strv" do
-      _(instance.g_strv).must_be :==, []
-      instance.g_strv = %w(foo bar)
-      _(instance.g_strv).must_be :==, %w(foo bar)
-    end
-    it "creates an instance using #new" do
-      bx = GIMarshallingTests::BoxedStruct.new
-      assert_instance_of GIMarshallingTests::BoxedStruct, bx
-      _(bx.struct).must_be :owned?
-    end
-    it "has a working method #inv" do
-      instance.long_ = 42
-      instance.inv
-      pass
-    end
-    it "has a working function #inout" do
-      bx = GIMarshallingTests::BoxedStruct.new
-      bx.long_ = 42
-      _(bx.struct).must_be :owned?
-      res = GIMarshallingTests::BoxedStruct.inout bx
-      _(bx.struct).must_be :owned?
-      _(res.struct).must_be :owned?
-      assert_equal 0, res.long_
-    end
-    it "has a working function #out" do
-      res = GIMarshallingTests::BoxedStruct.out
-      _(res.struct).must_be :owned?
-      assert_equal 42, res.long_
-    end
-    it "has a working function #returnv" do
-      res = GIMarshallingTests::BoxedStruct.returnv
-      _(res.struct).must_be :owned?
-      assert_equal 42, res.long_
-      _(res.g_strv).must_be :==, %w(0 1 2)
-    end
-  end
-  it "has the constant CONSTANT_GERROR_CODE" do
-    assert_equal 5, GIMarshallingTests::CONSTANT_GERROR_CODE
-  end
-  it "has the constant CONSTANT_GERROR_DEBUG_MESSAGE" do
-    _(GIMarshallingTests::CONSTANT_GERROR_DEBUG_MESSAGE).must_equal(
-      "we got an error, life is shit")
-  end
-  it "has the constant CONSTANT_GERROR_DOMAIN" do
-    assert_equal "gi-marshalling-tests-gerror-domain",
-                 GIMarshallingTests::CONSTANT_GERROR_DOMAIN
-  end
-  it "has the constant CONSTANT_GERROR_MESSAGE" do
-    assert_equal "gi-marshalling-tests-gerror-message",
-                 GIMarshallingTests::CONSTANT_GERROR_MESSAGE
-  end
-  it "has the constant CONSTANT_NUMBER" do
-    assert_equal 42, GIMarshallingTests::CONSTANT_NUMBER
-  end
-  it "has the constant CONSTANT_UTF8" do
-    assert_equal "const ♥ utf8", GIMarshallingTests::CONSTANT_UTF8
-  end
-  describe "GIMarshallingTests::Enum" do
-    it "has the member :value1" do
-      assert_equal 0, GIMarshallingTests::Enum[:value1]
-    end
-    it "has the member :value2" do
-      assert_equal 1, GIMarshallingTests::Enum[:value2]
-    end
-    it "has the member :value3" do
-      assert_equal 42, GIMarshallingTests::Enum[:value3]
-    end
-  end
-  describe "GIMarshallingTests::Flags" do
-    it "has the member :value1" do
-      assert_equal 1, GIMarshallingTests::Flags[:value1]
-    end
-    it "has the member :value2" do
-      assert_equal 2, GIMarshallingTests::Flags[:value2]
-    end
-    it "has the member :value3" do
-      assert_equal 4, GIMarshallingTests::Flags[:value3]
-    end
-    it "has the member :mask" do
-      assert_equal 3, GIMarshallingTests::Flags[:mask]
-    end
-    it "has the member :mask2" do
-      assert_equal 3, GIMarshallingTests::Flags[:mask2]
-    end
-    it "has a working function #in" do
-      GIMarshallingTests::Flags.in value2: true
-    end
-    it "has a working function #in_zero" do
-      GIMarshallingTests::Flags.in_zero 0
-    end
-    it "has a working function #inout" do
-      result = GIMarshallingTests::Flags.inout value2: true
-      _(result).must_equal(value1: true)
-    end
-    it "has a working function #out" do
-      result = GIMarshallingTests::Flags.out
-      _(result).must_equal(value2: true)
-    end
-    it "has a working function #returnv" do
-      result = GIMarshallingTests::Flags.returnv
-      _(result).must_equal(value2: true)
-    end
-  end
-  describe "GIMarshallingTests::GEnum" do
-    it "has the member :value1" do
-      assert_equal 0, GIMarshallingTests::GEnum[:value1]
-    end
-    it "has the member :value2" do
-      assert_equal 1, GIMarshallingTests::GEnum[:value2]
-    end
-    it "has the member :value3" do
-      assert_equal 42, GIMarshallingTests::GEnum[:value3]
-    end
-    it "has a working function #in" do
-      GIMarshallingTests::GEnum.in :value3
-    end
-    it "has a working function #inout" do
-      result = GIMarshallingTests::GEnum.inout :value3
-      _(result).must_equal :value1
-    end
-    it "has a working function #out" do
-      result = GIMarshallingTests::GEnum.out
-      _(result).must_equal :value3
-    end
-    it "has a working function #returnv" do
-      result = GIMarshallingTests::GEnum.returnv
-      _(result).must_equal :value3
-    end
-  end
-  describe "GIMarshallingTests::Interface" do
-    it "has a working method #test_int8_in" do
-      derived_klass.class_eval { include GIMarshallingTests::Interface }
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :test_int8_in, proc { |obj, in_| obj.int = in_ }
-      end
-      derived_instance.test_int8_in 8
-      _(derived_instance.int).must_equal 8
-    end
-  end
-  describe "GIMarshallingTests::Interface2" do
-    it "must be tested for clashes with Interface" do
-      skip "Needs more work to determine desired behavior"
-    end
-  end
-  describe "GIMarshallingTests::Interface3" do
-    it "has a working method #test_variant_array_in" do
-      derived_klass.class_eval { include GIMarshallingTests::Interface3 }
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :test_variant_array_in, proc { |obj, in_|
-          obj.int = in_.to_a.first.get_byte
-        }
-      end
-      derived_instance.test_variant_array_in [GLib::Variant.new_byte(42)]
-      _(derived_instance.int).must_equal 42
-    end
-  end
-  describe "GIMarshallingTests::InterfaceImpl" do
-    it "has a working method #get_as_interface" do
-      obj = GIMarshallingTests::InterfaceImpl.new []
-      result = obj.get_as_interface
-      _(result).must_be_kind_of GIMarshallingTests::Interface
-    end
-  end
-  describe "GIMarshallingTests::NestedStruct" do
-    let(:instance) { GIMarshallingTests::NestedStruct.new }
-    it "has a writable field simple_struct" do
-      assert_instance_of GIMarshallingTests::SimpleStruct,
-                         instance.simple_struct
-      new_struct = GIMarshallingTests::SimpleStruct.new
-      new_struct.int8 = 42
-      instance.simple_struct = new_struct
-      _(instance.simple_struct.int8).must_equal 42
-    end
-  end
-  describe "GIMarshallingTests::NoTypeFlags" do
-    it "has the member :value1" do
-      assert_equal 1, GIMarshallingTests::NoTypeFlags[:value1]
-    end
-    it "has the member :value2" do
-      assert_equal 2, GIMarshallingTests::NoTypeFlags[:value2]
-    end
-    it "has the member :value3" do
-      assert_equal 4, GIMarshallingTests::NoTypeFlags[:value3]
-    end
-    it "has the member :mask" do
-      assert_equal 3, GIMarshallingTests::NoTypeFlags[:mask]
-    end
-    it "has the member :mask2" do
-      assert_equal 3, GIMarshallingTests::NoTypeFlags[:mask2]
-    end
-  end
-  describe "GIMarshallingTests::NotSimpleStruct" do
-    let(:instance) { GIMarshallingTests::NotSimpleStruct.new }
-    it "has a writable field pointer" do
-      _(instance.pointer).must_be_nil
-      nested = GIMarshallingTests::NestedStruct.new
-      nested.simple_struct.int8 = 23
-      instance.pointer = nested
-      _(instance.pointer.simple_struct.int8).must_equal 23
-    end
-  end
-  it "has the constant OVERRIDES_CONSTANT" do
-    assert_equal 42, GIMarshallingTests::OVERRIDES_CONSTANT
-  end
-  describe "GIMarshallingTests::Object" do
-    it "creates an instance using #new" do
-      ob = GIMarshallingTests::Object.new 42
-      assert_instance_of GIMarshallingTests::Object, ob
-      assert_equal 42, ob.int
-    end
-    it "fails to create an instance using #new_fail" do
-      _(proc { GIMarshallingTests::Object.new_fail 42 }).must_raise GirFFI::GLibError
-    end
-    it "has a working function #full_inout" do
-      ob = GIMarshallingTests::Object.new 42
-      _(object_ref_count(ob)).must_equal 1
-      res = GIMarshallingTests::Object.full_inout ob
-      _(object_ref_count(ob)).must_equal 1
-      _(object_ref_count(res)).must_equal 1
-      _(res).must_be_instance_of GIMarshallingTests::Object
-      _(res.int).must_equal 0
-    end
-    it "has a working function #full_out" do
-      res = GIMarshallingTests::Object.full_out
-      _(res).must_be_instance_of GIMarshallingTests::Object
-      _(object_ref_count(res)).must_equal 1
-    end
-    it "has a working function #full_return" do
-      res = GIMarshallingTests::Object.full_return
-      _(res).must_be_instance_of GIMarshallingTests::Object
-      _(object_ref_count(res)).must_equal 1
-    end
-    it "has a working function #none_inout" do
-      ob = GIMarshallingTests::Object.new 42
-      _(object_ref_count(ob)).must_equal 1
-      res = GIMarshallingTests::Object.none_inout ob
-      _(object_ref_count(ob)).must_equal 1
-      _(object_ref_count(res)).must_equal 2
-      _(res).must_be_instance_of GIMarshallingTests::Object
-      _(ob.int).must_equal 42
-      _(res.int).must_equal 0
-    end
-    it "has a working function #none_out" do
-      res = GIMarshallingTests::Object.none_out
-      _(res).must_be_instance_of GIMarshallingTests::Object
-      _(object_ref_count(res)).must_equal 2
-    end
-    it "has a working function #none_return" do
-      res = GIMarshallingTests::Object.none_return
-      _(res).must_be_instance_of GIMarshallingTests::Object
-      _(object_ref_count(res)).must_equal 2
-    end
-    it "has a working function #static_method" do
-      GIMarshallingTests::Object.static_method
-      pass
-    end
-    let(:instance) { GIMarshallingTests::Object.new 42 }
-    it "has a working method #call_vfunc_with_callback" do
-      cb = nil
-      user_data = nil
-      result = nil
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation(
-          :vfunc_with_callback,
-          proc { |_obj, callback, callback_data|
-            cb = callback
-            user_data = callback_data.address
-            result = callback.call(42, callback_data)
-          })
-      end
-      derived_instance.call_vfunc_with_callback
-      _(user_data).must_equal 0xdeadbeef
-      # TODO: Change implementation of CallbackBase so that this becomes an
-      # instance of GIMarshallingTests::CallbackIntInt
-      _(cb).must_be_instance_of FFI::Function
-      _(result).must_equal 42
-    end
-    it "has a working method #full_in" do
-      skip "This function is defined in the header but not implemented"
-    end
-    it "has a working method #get_ref_info_for_vfunc_in_object_transfer_full" do
-      obj = nil
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation(
-          :vfunc_in_object_transfer_full,
-          proc { |_this, object|
-            obj = object
-          })
-      end
-      result = derived_instance
-        .get_ref_info_for_vfunc_in_object_transfer_full GIMarshallingTests::Object.gtype
-      _(result).must_equal [1, false]
-      _(obj).must_be_instance_of GIMarshallingTests::Object
-    end
-    it "has a working method #get_ref_info_for_vfunc_in_object_transfer_none" do
-      obj = nil
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation(
-          :vfunc_in_object_transfer_none,
-          proc { |_this, object|
-            obj = object
-          })
-      end
-      result = derived_instance
-        .get_ref_info_for_vfunc_in_object_transfer_none GIMarshallingTests::Object.gtype
-      _(object_ref_count(obj)).must_be :>, 0
-      _(result).must_equal [2, false]
-      _(obj).must_be_instance_of GIMarshallingTests::Object
-    end
-    it "has a working method #get_ref_info_for_vfunc_out_object_transfer_full" do
-      obj = nil
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :vfunc_out_object_transfer_full, proc { |_obj|
-          obj = GIMarshallingTests::Object.new(42)
-        }
-      end
-      result = derived_instance.get_ref_info_for_vfunc_out_object_transfer_full
-      _(object_ref_count(obj)).must_be :>, 0
-      # TODO: Check desired result
-      _(result).must_equal [2, false]
-    end
-    it "has a working method #get_ref_info_for_vfunc_out_object_transfer_none" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :vfunc_out_object_transfer_none, proc { |_obj|
-          GIMarshallingTests::Object.new 42
-        }
-      end
-      result = derived_instance.get_ref_info_for_vfunc_out_object_transfer_none
-      _(result).must_equal [1, false]
-    end
-    it "has a working method #get_ref_info_for_vfunc_return_object_transfer_full" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :vfunc_return_object_transfer_full, proc { |_obj|
-          GIMarshallingTests::Object.new 42
-        }
-      end
-      result = derived_instance.get_ref_info_for_vfunc_return_object_transfer_full
-      _(result).must_equal [2, false]
-    end
-    it "has a working method #get_ref_info_for_vfunc_return_object_transfer_none" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :vfunc_return_object_transfer_none, proc { |_obj|
-          GIMarshallingTests::Object.new 42
-        }
-      end
-      result = derived_instance.get_ref_info_for_vfunc_return_object_transfer_none
-      _(result).must_equal [1, false]
-    end
-    it "has a working method #int8_in" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :method_int8_in, proc { |obj, in_| obj.int = in_ }
-      end
-      derived_instance.int8_in 23
-      _(derived_instance.int).must_equal 23
-    end
-    it "has a working method #int8_out" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :method_int8_out, proc { |_obj| 42 }
-      end
-      _(derived_instance.int8_out).must_equal 42
-    end
-    it "has a working method #method" do
-      instance.method
-      pass
-    end
-    it "has a working method #method_array_in" do
-      instance.method_array_in [-1, 0, 1, 2]
-      pass
-    end
-    it "has a working method #method_array_inout" do
-      res = instance.method_array_inout [-1, 0, 1, 2]
-      _(res).must_be :==, [-2, -1, 0, 1, 2]
-    end
-    it "has a working method #method_array_out" do
-      res = instance.method_array_out
-      _(res).must_be :==, [-1, 0, 1, 2]
-    end
-    it "has a working method #method_array_return" do
-      res = instance.method_array_return
-      _(res).must_be :==, [-1, 0, 1, 2]
-    end
-    it "has a working method #method_int8_arg_and_out_callee" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation(
-          :method_int8_arg_and_out_callee,
-          proc { |_obj, arg|
-            2 * arg
-          })
-      end
-      result = derived_instance.method_int8_arg_and_out_callee 32
-      _(result).must_equal 64
-    end
-    it "has a working method #method_int8_arg_and_out_caller" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation(
-          :method_int8_arg_and_out_caller,
-          proc { |_obj, arg|
-            2 * arg
-          })
-      end
-      result = derived_instance.method_int8_arg_and_out_caller 32
-      _(result).must_equal 64
-    end
-    it "has a working method #method_int8_in" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :method_int8_in, proc { |obj, in_| obj.int = in_ }
-      end
-      derived_instance.method_int8_in 108
-      _(derived_instance.int).must_equal 108
-    end
-    it "has a working method #method_int8_out" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :method_int8_out, proc { |_obj| 42 }
-      end
-      _(derived_instance.method_int8_out).must_equal 42
-    end
-    it "has a working method #method_str_arg_out_ret" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation(:method_str_arg_out_ret,
-                                          proc { |_obj, arg| [arg, 42] })
-      end
-      _(derived_instance.method_str_arg_out_ret("foo")).must_equal ["foo", 42]
-    end
-    it "has a working method #method_variant_array_in" do
-      skip "This function is defined in the header but not implemented"
-    end
-    it "has a working method #method_with_default_implementation" do
-      instance.method_with_default_implementation 104
-      assert_equal 104, instance.int
-    end
-    it "has a working method #none_in" do
-      instance.none_in
-      pass
-    end
-    it "has a working method #overridden_method" do
-      instance.set_property("int", 0)
-      instance.overridden_method
-      pass
-    end
-    it "has a working method #vfunc_array_out_parameter" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :vfunc_array_out_parameter, proc { |_obj|
-          [1.1, 2.2, 3.3]
-        }
-      end
-      result = derived_instance.vfunc_array_out_parameter
-      arr = result.to_a
-      _(arr.length).must_equal 3
-      _(arr[0]).must_be_close_to 1.1
-      _(arr[1]).must_be_close_to 2.2
-      _(arr[2]).must_be_close_to 3.3
-    end
-    it "has a working method #vfunc_caller_allocated_out_parameter" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation(
-          :vfunc_caller_allocated_out_parameter,
-          proc { |_obj|
-            "Hello!"
-          })
-      end
-      result = derived_instance.vfunc_caller_allocated_out_parameter
-      _(result).must_equal "Hello!"
-    end
-    it "has a working method #vfunc_meth_with_error" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :vfunc_meth_with_err, proc { |_object, x|
-          raise "This is not the answer!" unless x == 42
-          true
-        }
-      end
-      result = derived_instance.vfunc_meth_with_error 42
-      _(result).must_equal true
-      err = _(proc { derived_instance.vfunc_meth_with_error(21) })
-        .must_raise GirFFI::GLibError
-      _(err.message).must_equal "This is not the answer!"
-      _(err.domain).must_equal "gir_ffi"
-      _(err.code).must_equal 0
-    end
-    it "has a working method #vfunc_multiple_out_parameters" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation(
-          :vfunc_multiple_out_parameters,
-          proc { |*_args| [42.1, -142.3] })
-      end
-      result = derived_instance.vfunc_multiple_out_parameters
-      _(result[0]).must_be_close_to 42.1
-      _(result[1]).must_be_close_to(-142.3)
-    end
-    it "has a working method #vfunc_one_out_parameter" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation(
-          :vfunc_one_out_parameter,
-          proc { |*_args| 23.4 })
-      end
-      _(derived_instance.vfunc_one_out_parameter)
-        .must_be_within_epsilon 23.4
-    end
-    it "has a working method #vfunc_out_enum" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :vfunc_out_enum, proc { |_obj| :value2 }
-      end
-      _(derived_instance.vfunc_out_enum).must_equal :value2
-    end
-    it "has a working method #vfunc_return_enum" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation :vfunc_return_enum, proc { |_obj| :value2 }
-      end
-      _(derived_instance.vfunc_return_enum).must_equal :value2
-    end
-    it "has a working method #vfunc_return_value_and_multiple_out_parameters" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation(
-          :vfunc_return_value_and_multiple_out_parameters,
-          proc { |*_args| [42, -142, 3] })
-      end
-      _(derived_instance.vfunc_return_value_and_multiple_out_parameters)
-        .must_equal [42, -142, 3]
-    end
-    it "has a working method #vfunc_return_value_and_one_out_parameter" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation(
-          :vfunc_return_value_and_one_out_parameter,
-          proc { |*_args| [42, -142] })
-      end
-      _(derived_instance.vfunc_return_value_and_one_out_parameter)
-        .must_equal [42, -142]
-    end
-    it "has a working method #vfunc_return_value_only" do
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation(:vfunc_return_value_only,
-                                          proc { |_obj| 0x1234_5678 })
-      end
-      result = derived_instance.vfunc_return_value_only
-      _(result).must_equal 0x1234_5678
-    end
-    it "has a working method #vfunc_with_callback" do
-      result = 1
-      derived_instance = make_derived_instance do |info|
-        info.install_vfunc_implementation(
-          :vfunc_with_callback,
-          proc { |_obj, callback, callback_data|
-            callback.call(42, callback_data)
-          })
-      end
-      derived_instance.vfunc_with_callback { |val, user_data| result = val + user_data }
-      # The current implementation of the vfunc_with_callback method currently
-      # doesn't actually call the virtual function vfunc_with_callback.
-      _(result).must_equal 1
-      _(result).wont_equal 42 + 23
-    end
-    describe "its 'int' property" do
-      it "can be retrieved with #get_property" do
-        assert_equal 42, instance.get_property("int")
-      end
-      it "can be retrieved with #int" do
-        assert_equal 42, instance.int
-      end
-      it "can be set with #set_property" do
-        instance.set_property("int", 13)
-        assert_equal 13, instance.get_property("int")
-      end
-      it "can be set with #int=" do
-        instance.int = 1
-        assert_equal 1, instance.int
-      end
-    end
-  end
-  describe "GIMarshallingTests::OverridesObject" do
-    it "creates an instance using #new" do
-      ob = GIMarshallingTests::OverridesObject.new
-      assert_instance_of GIMarshallingTests::OverridesObject, ob
-    end
-    it "has a working function #returnv" do
-      ob = GIMarshallingTests::OverridesObject.returnv
-      assert_instance_of GIMarshallingTests::OverridesObject, ob
-    end
-    let(:instance) { GIMarshallingTests::OverridesObject.new }
-    it "has a working method #method" do
-      result = instance.method
-      _(result).must_equal 42
-    end
-    it "does not have accessors for its parent instance" do
-      _(instance).wont_respond_to :parent_instance
-      _(instance).wont_respond_to :parent_instance=
-    end
-  end
-  describe "GIMarshallingTests::OverridesStruct" do
-    let(:instance) { GIMarshallingTests::OverridesStruct.new }
-    it "has a writable field long_" do
-      instance.long_ = 43
-      _(instance.long_).must_equal 43
-    end
-    it "creates an instance using #new" do
-      ob = GIMarshallingTests::OverridesStruct.new
-      assert_instance_of GIMarshallingTests::OverridesStruct, ob
-    end
-    it "has a working method #method" do
-      _(instance.method).must_equal 42
-    end
-    it "has a working function #returnv" do
-      ob = GIMarshallingTests::OverridesStruct.returnv
-      assert_instance_of GIMarshallingTests::OverridesStruct, ob
-    end
-  end
-  describe "GIMarshallingTests::PointerStruct" do
-    it "creates an instance using #new" do
-      ps = GIMarshallingTests::PointerStruct.new
-      assert_instance_of GIMarshallingTests::PointerStruct, ps
-    end
-    let(:instance) { GIMarshallingTests::PointerStruct.new }
-    it "has a writable field long_" do
-      assert_equal 0, instance.long_
-      instance.long_ = 1056
-      assert_equal 1056, instance.long_
-    end
-    it "has a working method #inv" do
-      instance.long_ = 42
-      instance.inv
-      pass
-    end
-    it "has a working function #returnv" do
-      ob = GIMarshallingTests::PointerStruct.returnv
-      assert_instance_of GIMarshallingTests::PointerStruct, ob
-    end
-  end
-  describe "GIMarshallingTests::PropertiesObject" do
-    it "creates an instance using #new" do
-      ob = GIMarshallingTests::PropertiesObject.new
-      assert_instance_of GIMarshallingTests::PropertiesObject, ob
-    end
-    let(:instance) { GIMarshallingTests::PropertiesObject.new }
-    describe "its 'some-boolean' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-boolean")).must_equal false
-      end
-      it "can be retrieved with #some_boolean" do
-        _(instance.some_boolean).must_equal false
-      end
-      it "can be set with #set_property" do
-        instance.set_property("some-boolean", true)
-        _(instance.get_property("some-boolean")).must_equal true
-      end
-      it "can be set with #some_boolean=" do
-        instance.some_boolean = true
-        _(instance.get_property("some-boolean")).must_equal true
-      end
-    end
-    describe "its 'some-boxed-glist' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-boxed-glist")).must_be_nil
-      end
-      it "can be retrieved with #some_boxed_glist" do
-        _(instance.some_boxed_glist).must_be_nil
-      end
-      it "can be set with #set_property" do
-        instance.set_property("some-boxed-glist", [1, 2, 3])
-        _(instance.some_boxed_glist.to_a).must_equal [1, 2, 3]
-      end
-      it "can be set with #some_boxed_glist=" do
-        instance.some_boxed_glist = [1, 2, 3]
-        _(instance.some_boxed_glist.to_a).must_equal [1, 2, 3]
-        _(instance.get_property("some-boxed-glist").to_a).must_equal [1, 2, 3]
-      end
-    end
-    describe "its 'some-boxed-struct' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-boxed-struct")).must_be_nil
-      end
-      it "can be retrieved with #some_boxed_struct" do
-        _(instance.some_boxed_struct).must_be_nil
-      end
-      it "can be set with #set_property" do
-        boxed = GIMarshallingTests::BoxedStruct.new
-        boxed.long_ = 42
-        instance.set_property("some-boxed-struct", boxed)
-        _(instance.get_property("some-boxed-struct").long_).must_equal 42
-      end
-      it "can be set with #some_boxed_struct=" do
-        boxed = GIMarshallingTests::BoxedStruct.new
-        boxed.long_ = 43
-        instance.some_boxed_struct = boxed
-        _(instance.some_boxed_struct.long_).must_equal 43
-      end
-    end
-    describe "its 'some-byte-array' property" do
-      before { skip_below("1.57.2") }
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-byte-array")).must_be_nil
-      end
-      it "can be retrieved with #some_byte_array" do
-        _(instance.some_byte_array).must_be_nil
-      end
-      it "can be set with #set_property" do
-        instance.set_property "some-byte-array", "some bytes"
-        _(instance.get_property("some-byte-array").to_string).must_equal "some bytes"
-      end
-      it "can be set with #some_byte_array=" do
-        instance.some_byte_array = "some bytes"
-        _(instance.some_byte_array.to_string).must_equal "some bytes"
-      end
-    end
-    describe "its 'some-char' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-char")).must_equal 0
-      end
-      it "can be retrieved with #some_char" do
-        _(instance.some_char).must_equal 0
-      end
-      it "can be set with #set_property" do
-        instance.set_property "some-char", 42
-        _(instance.get_property("some-char")).must_equal 42
-      end
-      it "can be set with #some_char=" do
-        instance.some_char = 43
-        _(instance.some_char).must_equal 43
-      end
-    end
-    describe "its 'some-double' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-double")).must_equal 0.0
-      end
-      it "can be retrieved with #some_double" do
-        _(instance.some_double).must_equal 0.0
-      end
-      it "can be set with #set_property" do
-        instance.set_property("some-double", 3.14)
-        _(instance.get_property("some-double")).must_equal 3.14
-      end
-      it "can be set with #some_double=" do
-        instance.some_double = 3.14
-        _(instance.some_double).must_equal 3.14
-      end
-    end
-    describe "its 'some-enum' property" do
-      before { skip_below("1.52.1") }
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-enum")).must_equal :value1
-      end
-      it "can be retrieved with #some_enum" do
-        _(instance.some_enum).must_equal :value1
-      end
-      it "can be set with #set_property" do
-        instance.set_property("some-enum", :value3)
-        _(instance.get_property("some-enum")).must_equal :value3
-      end
-      it "can be set with #some_enum=" do
-        instance.some_enum = :value3
-        _(instance.some_enum).must_equal :value3
-        _(instance.get_property("some-enum")).must_equal :value3
-      end
-    end
-    describe "its 'some-flags' property" do
-      before { skip_below("1.52.1") }
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-flags")).must_equal value1: true
-      end
-      it "can be retrieved with #some_flags" do
-        _(instance.some_flags).must_equal value1: true
-      end
-      it "can be set with #set_property" do
-        instance.set_property("some-flags", value3: true)
-        _(instance.get_property("some-flags")).must_equal value3: true
-      end
-      it "can be set with #some_flags=" do
-        instance.some_flags = :value3
-        _(instance.some_flags).must_equal(value3: true)
-        _(instance.get_property("some-flags")).must_equal(value3: true)
-      end
-    end
-    describe "its 'some-float' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-float")).must_equal 0.0
-      end
-      it "can be retrieved with #some_float" do
-        _(instance.some_float).must_equal 0.0
-      end
-      it "can be set with #set_property" do
-        instance.set_property("some-float", 3.14)
-        _(instance.get_property("some-float")).must_be_close_to 3.14
-      end
-      it "can be set with #some_float=" do
-        instance.some_float = 3.14
-        _(instance.some_float).must_be_close_to 3.14
-      end
-    end
-    describe "its 'some-gvalue' property" do
-      before { skip_below "1.52.1" }
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-gvalue")).must_be_nil
-      end
-      it "can be retrieved with #some_gvalue" do
-        _(instance.some_gvalue).must_be_nil
-      end
-      it "can be set with #set_property" do
-        value = GObject::Value.from 42
-        instance.set_property("some-gvalue", value)
-        _(instance.get_property("some-gvalue").get_value).must_equal 42
-      end
-      it "can be set with #some_gvalue=" do
-        value = GObject::Value.from 42
-        instance.some_gvalue = value
-        _(instance.some_gvalue.get_value).must_equal 42
-        _(instance.get_property("some-gvalue").get_value).must_equal 42
-      end
-    end
-    describe "its 'some-int' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-int")).must_equal 0
-      end
-      it "can be retrieved with #some_int" do
-        _(instance.some_int).must_equal 0
-      end
-      it "can be set with #set_property" do
-        instance.set_property "some-int", 4242
-        _(instance.get_property("some-int")).must_equal 4242
-      end
-      it "can be set with #some_int=" do
-        instance.some_int = 4243
-        _(instance.some_int).must_equal 4243
-      end
-    end
-    describe "its 'some-int64' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-int64")).must_equal 0
-      end
-      it "can be retrieved with #some_int64" do
-        _(instance.some_int64).must_equal 0
-      end
-      it "can be set with #set_property" do
-        instance.set_property "some-int64", 42_000_000_000_000
-        _(instance.get_property("some-int64")).must_equal 42_000_000_000_000
-      end
-      it "can be set with #some_int64=" do
-        instance.some_int64 = 43_000_000_000_000
-        _(instance.some_int64).must_equal 43_000_000_000_000
-      end
-    end
-    describe "its 'some-long' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-long")).must_equal 0
-      end
-      it "can be retrieved with #some_long" do
-        _(instance.some_long).must_equal 0
-      end
-      it "can be set with #set_property" do
-        instance.set_property "some-long", 4242
-        _(instance.get_property("some-long")).must_equal 4242
-      end
-      it "can be set with #some_long=" do
-        instance.some_long = 4243
-        _(instance.some_long).must_equal 4243
-      end
-    end
-    describe "its 'some-object' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-object")).must_be_nil
-      end
-      it "can be retrieved with #some_object" do
-        _(instance.some_object).must_be_nil
-      end
-      it "can be set with #set_property" do
-        ob = GIMarshallingTests::Object.new 42
-        instance.set_property "some-object", ob
-        _(instance.get_property("some-object")).must_equal ob
-      end
-      it "can be set with #some_object=" do
-        ob = GIMarshallingTests::Object.new 42
-        instance.some_object = ob
-        _(instance.some_object).must_equal ob
-      end
-    end
-    describe "its 'some-readonly' property" do
-      before { skip_below("1.57.2") }
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-readonly")).must_equal 42
-      end
-      it "can be retrieved with #some_readonly" do
-        _(instance.some_readonly).must_equal 42
-      end
-    end
-    describe "its 'some-strv' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-strv")).must_be :==, []
-      end
-      it "can be retrieved with #some_strv" do
-        _(instance.some_strv).must_be :==, []
-      end
-      it "can be set with #set_property" do
-        instance.set_property("some-strv", %w(foo bar))
-        _(instance.get_property("some-strv")).must_be :==, %w(foo bar)
-      end
-      it "can be set with #some_strv=" do
-        instance.some_strv = %w(foo bar)
-        _(instance.some_strv).must_be :==, %w(foo bar)
-      end
-    end
-    describe "its 'some-uchar' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-uchar")).must_equal 0
-      end
-      it "can be retrieved with #some_uchar" do
-        _(instance.some_uchar).must_equal 0
-      end
-      it "can be set with #set_property" do
-        instance.set_property "some-uchar", 42
-        _(instance.get_property("some-uchar")).must_equal 42
-      end
-      it "can be set with #some_uchar=" do
-        instance.some_uchar = 43
-        _(instance.some_uchar).must_equal 43
-      end
-    end
-    describe "its 'some-uint' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-uint")).must_equal 0
-      end
-      it "can be retrieved with #some_uint" do
-        _(instance.some_uint).must_equal 0
-      end
-      it "can be set with #set_property" do
-        instance.set_property "some-uint", 4242
-        _(instance.get_property("some-uint")).must_equal 4242
-      end
-      it "can be set with #some_uint=" do
-        instance.some_uint = 4243
-        _(instance.some_uint).must_equal 4243
-      end
-    end
-    describe "its 'some-uint64' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-uint64")).must_equal 0
-      end
-      it "can be retrieved with #some_uint64" do
-        _(instance.some_uint64).must_equal 0
-      end
-      it "can be set with #set_property" do
-        instance.set_property "some-uint64", 42_000_000_000_000
-        _(instance.get_property("some-uint64")).must_equal 42_000_000_000_000
-      end
-      it "can be set with #some_uint64=" do
-        instance.some_uint64 = 43_000_000_000_000
-        _(instance.some_uint64).must_equal 43_000_000_000_000
-      end
-    end
-    describe "its 'some-ulong' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-ulong")).must_equal 0
-      end
-      it "can be retrieved with #some_ulong" do
-        _(instance.some_ulong).must_equal 0
-      end
-      it "can be set with #set_property" do
-        instance.set_property "some-ulong", 4242
-        _(instance.get_property("some-ulong")).must_equal 4242
-      end
-      it "can be set with #some_ulong=" do
-        instance.some_ulong = 4243
-        _(instance.some_ulong).must_equal 4243
-      end
-    end
-    describe "its 'some-variant' property" do
-      it "can be retrieved with #get_property" do
-        _(instance.get_property("some-variant")).must_be_nil
-      end
-      it "can be retrieved with #some_variant" do
-        _(instance.some_variant).must_be_nil
-      end
-      it "can be set with #set_property" do
-        value = GLib::Variant.new_string("Foo")
-        instance.set_property "some-variant", value
-        _(instance.get_property("some-variant")).must_equal value
-      end
-      it "can be set with #some_variant=" do
-        value = GLib::Variant.new_string("Foo")
-        instance.some_variant = value
-        _(instance.some_variant).must_equal value
-      end
-    end
-  end
-  describe "GIMarshallingTests::SecondEnum" do
-    it "has the member :secondvalue1" do
-      assert_equal 0, GIMarshallingTests::SecondEnum[:secondvalue1]
-    end
-    it "has the member :secondvalue2" do
-      assert_equal 1, GIMarshallingTests::SecondEnum[:secondvalue2]
-    end
-  end
-  describe "GIMarshallingTests::SimpleStruct" do
-    it "creates an instance using #new" do
-      ss = GIMarshallingTests::SimpleStruct.new
-      assert_instance_of GIMarshallingTests::SimpleStruct, ss
-    end
-    let(:instance) { GIMarshallingTests::SimpleStruct.new }
-    it "has a writable field long_" do
-      _(instance.long_).must_equal 0
-      instance.long_ = 1056
-      _(instance.long_).must_equal 1056
-    end
-    it "has a writable field int8" do
-      _(instance.int8).must_equal 0
-      instance.int8 = -43
-      _(instance.int8).must_equal(-43)
-    end
-    it "has a working method #inv" do
-      instance.long_ = 6
-      instance.int8 = 7
-      instance.inv
-      pass
-    end
-    it "has a working method #method" do
-      instance.long_ = 6
-      instance.int8 = 7
-      instance.method
-      pass
-    end
-    it "has a working function #returnv" do
-      ss = GIMarshallingTests::SimpleStruct.returnv
-      assert_instance_of GIMarshallingTests::SimpleStruct, ss
-    end
-  end
-  describe "GIMarshallingTests::SubObject" do
-    it "creates an instance using #new" do
-      so = GIMarshallingTests::SubObject.new
-      _(so).must_be_instance_of GIMarshallingTests::SubObject
-      _(GObject.type_name_from_instance(so))
-        .must_equal "GIMarshallingTestsSubObject"
-    end
-    let(:instance) { GIMarshallingTests::SubObject.new }
-    it "has a working method #overwritten_method" do
-      instance.overwritten_method
-      pass
-    end
-    it "has a working method #sub_method" do
-      instance.sub_method
-      pass
-    end
-    it "does not have accessors for its parent instance" do
-      _(instance).wont_respond_to :parent_instance
-      _(instance).wont_respond_to :parent_instance=
-    end
-  end
-  describe "GIMarshallingTests::SubSubObject" do
-    it "creates an instance using #new" do
-      so = GIMarshallingTests::SubSubObject.new
-      assert_instance_of GIMarshallingTests::SubSubObject, so
-      _(GObject.type_name_from_instance(so))
-        .must_equal "GIMarshallingTestsSubSubObject"
-    end
-    let(:instance) { GIMarshallingTests::SubSubObject.new }
-    it "does not have accessors for its parent instance" do
-      _(instance).wont_respond_to :parent_instance
-      _(instance).wont_respond_to :parent_instance=
-    end
-  end
-  describe "GIMarshallingTests::Union" do
-    it "creates an instance with #new" do
-      u = GIMarshallingTests::Union.new
-      assert_instance_of GIMarshallingTests::Union, u
-    end
-    let(:instance) { GIMarshallingTests::Union.new }
-    it "has a writable field long_" do
-      assert_equal 0, instance.long_
-      instance.long_ = 1056
-      assert_equal 1056, instance.long_
-    end
-    it "has a working method #inv" do
-      instance.long_ = 42
-      instance.inv
-      pass
-    end
-    it "has a working method #method" do
-      instance.long_ = 42
-      instance.method
-      pass
-    end
-    it "has a working function #inout" do
-      skip "This function is defined in the header but not implemented"
-    end
-    it "has a working function #out" do
-      skip "This function is defined in the header but not implemented"
-    end
-    it "has a working function #returnv" do
-      u = GIMarshallingTests::Union.returnv
-      assert_instance_of GIMarshallingTests::Union, u
-    end
-  end
-  it "has a working function #array_bool_in" do
-    skip_below "1.51.1"
-    GIMarshallingTests.array_bool_in [true, false, true, true]
-  end
-  it "has a working function #array_bool_out" do
-    skip_below "1.51.1"
-    result = GIMarshallingTests.array_bool_out
-    _(result.to_a).must_equal [true, false, true, true]
-  end
-  it "has a working function #array_enum_in" do
-    GIMarshallingTests.array_enum_in [:value1, :value2, :value3]
-  end
-  it "has a working function #array_fixed_inout" do
-    res = GIMarshallingTests.array_fixed_inout [-1, 0, 1, 2]
-    _(res).must_be :==, [2, 1, 0, -1]
-  end
-  it "has a working function #array_fixed_int_in" do
-    GIMarshallingTests.array_fixed_int_in [-1, 0, 1, 2]
-    pass
-  end
-  it "has a working function #array_fixed_int_return" do
-    res = GIMarshallingTests.array_fixed_int_return
-    _(res).must_be :==, [-1, 0, 1, 2]
-  end
-  it "has a working function #array_fixed_out" do
-    res = GIMarshallingTests.array_fixed_out
-    _(res).must_be :==, [-1, 0, 1, 2]
-  end
-  it "has a working function #array_fixed_out_struct" do
-    res = GIMarshallingTests.array_fixed_out_struct
-    assert_equal [[7, 6], [6, 7]], res.map { |s| [s.long_, s.int8] }
-  end
-  it "has a working function #array_fixed_short_in" do
-    GIMarshallingTests.array_fixed_short_in [-1, 0, 1, 2]
-    pass
-  end
-  it "has a working function #array_fixed_short_return" do
-    res = GIMarshallingTests.array_fixed_short_return
-    _(res).must_be :==, [-1, 0, 1, 2]
-  end
-  it "has a working function #array_gvariant_container_in" do
-    v1 = GLib::Variant.new_int32(27)
-    v2 = GLib::Variant.new_string("Hello")
-    result = GIMarshallingTests.array_gvariant_container_in [v1, v2]
-    arr = result.to_a
-    _(arr.size).must_equal 2
-    _(arr[0].get_int32).must_equal 27
-    _(arr[1].get_string).must_equal "Hello"
-  end
-  it "has a working function #array_gvariant_full_in" do
-    v1 = GLib::Variant.new_int32(27)
-    v2 = GLib::Variant.new_string("Hello")
-    result = GIMarshallingTests.array_gvariant_full_in [v1, v2]
-    arr = result.to_a
-    _(arr.size).must_equal 2
-    _(arr[0].get_int32).must_equal 27
-    _(arr[1].get_string).must_equal "Hello"
-  end
-  it "has a working function #array_gvariant_none_in" do
-    v1 = GLib::Variant.new_int32(27)
-    v2 = GLib::Variant.new_string("Hello")
-    result = GIMarshallingTests.array_gvariant_none_in [v1, v2]
-    arr = result.to_a
-    _(arr.size).must_equal 2
-    _(arr[0].get_int32).must_equal 27
-    _(arr[1].get_string).must_equal "Hello"
-  end
-  it "has a working function #array_in" do
-    GIMarshallingTests.array_in [-1, 0, 1, 2]
-    pass
-  end
-  it "has a working function #array_in_guint64_len" do
-    GIMarshallingTests.array_in_guint64_len [-1, 0, 1, 2]
-    pass
-  end
-  it "has a working function #array_in_guint8_len" do
-    GIMarshallingTests.array_in_guint8_len [-1, 0, 1, 2]
-    pass
-  end
-  it "has a working function #array_in_len_before" do
-    GIMarshallingTests.array_in_len_before [-1, 0, 1, 2]
-    pass
-  end
-  it "has a working function #array_in_len_zero_terminated" do
-    GIMarshallingTests.array_in_len_zero_terminated [-1, 0, 1, 2]
-    pass
-  end
-  it "has a working function #array_in_nonzero_nonlen" do
-    GIMarshallingTests.array_in_nonzero_nonlen 1, "abcd".bytes.to_a
-    pass
-  end
-  it "has a working function #array_in_utf8_two_in" do
-    GIMarshallingTests.array_in_utf8_two_in [-1, 0, 1, 2], "1", "2"
-    pass
-  end
-  it "has a working function #array_in_utf8_two_in_out_of_order" do
-    GIMarshallingTests.array_in_utf8_two_in_out_of_order "1", [-1, 0, 1, 2], "2"
-    pass
-  end
-  it "has a working function #array_inout" do
-    res = GIMarshallingTests.array_inout [-1, 0, 1, 2]
-    _(res).must_be :==, [-2, -1, 0, 1, 2]
-  end
-  it "has a working function #array_inout_etc" do
-    arr, sum = GIMarshallingTests.array_inout_etc 42, [-1, 0, 1, 2], 24
-    _(arr).must_be :==, [42, -1, 0, 1, 24]
-    _(sum).must_equal 42 + 24
-  end
-  it "has a working function #array_int64_in" do
-    skip_below "1.51.1"
-    GIMarshallingTests.array_int64_in [-1, 0, 1, 2]
-  end
-  it "has a working function #array_out" do
-    res = GIMarshallingTests.array_out
-    _(res).must_be :==, [-1, 0, 1, 2]
-  end
-  it "has a working function #array_out_etc" do
-    arr, sum = GIMarshallingTests.array_out_etc 42, 24
-    _(arr).must_be :==, [42, 0, 1, 24]
-    _(sum).must_equal 42 + 24
-  end
-  it "has a working function #array_return" do
-    res = GIMarshallingTests.array_return
-    _(res).must_be :==, [-1, 0, 1, 2]
-  end
-  it "has a working function #array_return_etc" do
-    arr, sum = GIMarshallingTests.array_return_etc 42, 24
-    _(arr).must_be :==, [42, 0, 1, 24]
-    _(sum).must_equal 42 + 24
-  end
-  it "has a working function #array_simple_struct_in" do
-    arr = [1, 2, 3].map do |val|
-      GIMarshallingTests::SimpleStruct.new.tap { |struct| struct.long_ = val }
-    end
-    GIMarshallingTests.array_simple_struct_in arr
-  end
-  it "has a working function #array_string_in" do
-    GIMarshallingTests.array_string_in %w(foo bar)
-    pass
-  end
-  it "has a working function #array_struct_in" do
-    arr = [1, 2, 3].map do |val|
-      GIMarshallingTests::BoxedStruct.new.tap { |struct| struct.long_ = val }
-    end
-    GIMarshallingTests.array_struct_in arr
-  end
-  it "has a working function #array_struct_take_in" do
-    arr = [1, 2, 3].map do |val|
-      GIMarshallingTests::BoxedStruct.new.tap { |struct| struct.long_ = val }
-    end
-    # NOTE: This copies values so arr's elements stay valid
-    GIMarshallingTests.array_struct_take_in arr
-    _(arr.map(&:long_)).must_equal [1, 2, 3]
-  end
-  it "has a working function #array_struct_value_in" do
-    arr = [1, 2, 3].map do |val|
-      GIMarshallingTests::BoxedStruct.new.tap { |struct| struct.long_ = val }
-    end
-    GIMarshallingTests.array_struct_value_in arr
-  end
-  it "has a working function #array_uint64_in" do
-    skip_below "1.51.1"
-    GIMarshallingTests.array_uint64_in [-1, 0, 1, 2]
-  end
-  it "has a working function #array_uint8_in" do
-    arr = "abcd".bytes.to_a
-    GIMarshallingTests.array_uint8_in arr
-    pass
-  end
-  it "has a working function #array_unichar_in" do
-    skip_below "1.51.1"
-    arr = [0x63, 0x6f, 0x6e, 0x73, 0x74,
-           0x20, 0x2665, 0x20, 0x75, 0x74,
-           0x66, 0x38]
-    GIMarshallingTests.array_unichar_in arr
-  end
-  it "has a working function #array_unichar_out" do
-    skip_below "1.51.1"
-    result = GIMarshallingTests.array_unichar_out
-    _(result.to_a).must_equal [0x63, 0x6f, 0x6e, 0x73, 0x74,
-                               0x20, 0x2665, 0x20, 0x75, 0x74,
-                               0x66, 0x38]
-  end
-  it "has a working function #array_zero_terminated_in" do
-    GIMarshallingTests.array_zero_terminated_in %w(0 1 2)
-    pass
-  end
-  it "has a working function #array_zero_terminated_inout" do
-    res = GIMarshallingTests.array_zero_terminated_inout %w(0 1 2)
-    _(res).must_be :==, ["-1", "0", "1", "2"]
-  end
-  it "has a working function #array_zero_terminated_out" do
-    res = GIMarshallingTests.array_zero_terminated_out
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #array_zero_terminated_return" do
-    res = GIMarshallingTests.array_zero_terminated_return
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #array_zero_terminated_return_null" do
-    res = GIMarshallingTests.array_zero_terminated_return_null
-    _(res).must_be :==, []
-  end
-  it "has a working function #array_zero_terminated_return_struct" do
-    res = GIMarshallingTests.array_zero_terminated_return_struct
-    _(res.to_a.map(&:long_)).must_equal [42, 43, 44]
-  end
-  it "has a working function #array_zero_terminated_return_unichar" do
-    skip_below "1.51.1"
-    res = GIMarshallingTests.array_zero_terminated_return_unichar
-    _(res.to_a).must_equal [0x63, 0x6f, 0x6e, 0x73, 0x74,
-                            0x20, 0x2665, 0x20, 0x75, 0x74,
-                            0x66, 0x38]
-  end
-  it "has a working function #boolean_in_false" do
-    GIMarshallingTests.boolean_in_false false
-    pass
-  end
-  it "has a working function #boolean_in_true" do
-    GIMarshallingTests.boolean_in_true true
-    pass
-  end
-  it "has a working function #boolean_inout_false_true" do
-    res = GIMarshallingTests.boolean_inout_false_true false
-    _(res).must_equal true
-  end
-  it "has a working function #boolean_inout_true_false" do
-    res = GIMarshallingTests.boolean_inout_true_false true
-    _(res).must_equal false
-  end
-  it "has a working function #boolean_out_false" do
-    res = GIMarshallingTests.boolean_out_false
-    _(res).must_equal false
-  end
-  it "has a working function #boolean_out_true" do
-    res = GIMarshallingTests.boolean_out_true
-    _(res).must_equal true
-  end
-  it "has a working function #boolean_return_false" do
-    res = GIMarshallingTests.boolean_return_false
-    _(res).must_equal false
-  end
-  it "has a working function #boolean_return_true" do
-    res = GIMarshallingTests.boolean_return_true
-    _(res).must_equal true
-  end
-  it "has a working function #boxed_struct_inout" do
-    bx = GIMarshallingTests::BoxedStruct.new
-    bx.long_ = 42
-    res = GIMarshallingTests.boxed_struct_inout bx
-    _(res.long_).must_equal 0
-  end
-  it "has a working function #boxed_struct_out" do
-    res = GIMarshallingTests.boxed_struct_out
-    _(res.long_).must_equal 42
-  end
-  it "has a working function #boxed_struct_returnv" do
-    res = GIMarshallingTests.boxed_struct_returnv
-    _(res.long_).must_equal 42
-    _(res.g_strv).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #bytearray_full_return" do
-    ret = GIMarshallingTests.bytearray_full_return
-    assert_instance_of GLib::ByteArray, ret
-    assert_includes(
-      ["0123".bytes.to_a, "\x001\xFF3".bytes.to_a],
-      ret.to_string.bytes.to_a)
-  end
-  it "has a working function #bytearray_none_in" do
-    val = GIMarshallingTests.bytearray_full_return.to_string
-    ba = GLib::ByteArray.new
-    ba = ba.append val
-    GIMarshallingTests.bytearray_none_in ba
-    pass
-  end
-  it "has a working function #callback_multiple_out_parameters" do
-    result = GIMarshallingTests.callback_multiple_out_parameters do |*_args|
-      [12.0, 13.0]
-    end
-    _(result).must_equal [12.0, 13.0]
-  end
-  it "has a working function #callback_one_out_parameter" do
-    result = GIMarshallingTests.callback_one_out_parameter { 42.0 }
-    _(result).must_equal 42.0
-  end
-  it "has a working function #callback_owned_boxed" do
-    a = nil
-    callback = proc { |box, _callback_data| a = box.long_ * 2 }
-    result = GIMarshallingTests.callback_owned_boxed(&callback)
-    _(result).must_equal 1
-    _(a).must_equal 2
-    result = GIMarshallingTests.callback_owned_boxed(&callback)
-    _(result).must_equal 2
-    _(a).must_equal 4
-  end
-  it "has a working function #callback_return_value_and_multiple_out_parameters" do
-    result =
-      GIMarshallingTests.callback_return_value_and_multiple_out_parameters do |*_args|
-        [42, -142, 3]
-      end
-    _(result).must_equal [42, -142, 3]
-  end
-  it "has a working function #callback_return_value_and_one_out_parameter" do
-    result = GIMarshallingTests.callback_return_value_and_one_out_parameter do |*_args|
-      [42, -142]
-    end
-    _(result).must_equal [42, -142]
-  end
-  it "has a working function #callback_return_value_only" do
-    result = GIMarshallingTests.callback_return_value_only { 42 }
-    _(result).must_equal 42
-  end
-  it "has a working function #double_in" do
-    GIMarshallingTests.double_in Float::MAX
-    pass
-  end
-  it "has a working function #double_inout" do
-    ret = GIMarshallingTests.double_inout Float::MAX
-    assert_in_epsilon 2.225e-308, ret
-  end
-  it "has a working function #double_out" do
-    ret = GIMarshallingTests.double_out
-    _(ret).must_equal Float::MAX
-  end
-  it "has a working function #double_return" do
-    ret = GIMarshallingTests.double_return
-    _(ret).must_equal Float::MAX
-  end
-  it "has a working function #enum_in" do
-    GIMarshallingTests.enum_in :value3
-    pass
-  end
-  it "has a working function #enum_inout" do
-    e = GIMarshallingTests.enum_inout :value3
-    _(e).must_equal :value1
-  end
-  it "has a working function #enum_out" do
-    e = GIMarshallingTests.enum_out
-    _(e).must_equal :value3
-  end
-  it "has a working function #enum_returnv" do
-    e = GIMarshallingTests.enum_returnv
-    _(e).must_equal :value3
-  end
-  it "has a working function #filename_list_return" do
-    fl = GIMarshallingTests.filename_list_return
-    _(fl).must_be_nil
-  end
-  it "has a working function #flags_in" do
-    GIMarshallingTests.flags_in value2: true
-    pass
-  end
-  it "has a working function #flags_in_zero" do
-    GIMarshallingTests.flags_in_zero 0
-    pass
-  end
-  it "has a working function #flags_inout" do
-    res = GIMarshallingTests.flags_inout value2: true
-    _(res).must_equal(value1: true)
-  end
-  it "has a working function #flags_out" do
-    res = GIMarshallingTests.flags_out
-    _(res).must_equal(value2: true)
-  end
-  it "has a working function #flags_returnv" do
-    res = GIMarshallingTests.flags_returnv
-    _(res).must_equal(value2: true)
-  end
-  it "has a working function #float_in" do
-    # float_return returns MAX_FLT
-    flt = GIMarshallingTests.float_return
-    GIMarshallingTests.float_in flt
-    pass
-  end
-  it "has a working function #float_inout" do
-    # float_return returns MAX_FLT
-    flt = GIMarshallingTests.float_return
-    res = GIMarshallingTests.float_inout flt
-    assert_in_epsilon 1.175e-38, res
-  end
-  it "has a working function #float_out" do
-    flt = GIMarshallingTests.float_out
-    assert_in_epsilon 3.402e+38, flt
-  end
-  it "has a working function #float_return" do
-    flt = GIMarshallingTests.float_return
-    assert_in_epsilon 3.402e+38, flt
-  end
-  it "has a working function #garray_bool_none_in" do
-    skip_below "1.51.1"
-    GIMarshallingTests.garray_bool_none_in [true, false, true, true]
-  end
-  it "has a working function #garray_boxed_struct_full_return" do
-    skip_below "1.61.1"
-    result = GIMarshallingTests.garray_boxed_struct_full_return
-    _(result.map(&:long_)).must_equal [42, 43, 44]
-  end
-  it "has a working function #garray_int_none_in" do
-    arr = [-1, 0, 1, 2]
-    GIMarshallingTests.garray_int_none_in arr
-    pass
-  end
-  it "has a working function #garray_int_none_return" do
-    arr = GIMarshallingTests.garray_int_none_return
-    _(arr).must_be :==, [-1, 0, 1, 2]
-  end
-  it "has a working function #garray_uint64_none_in" do
-    GIMarshallingTests.garray_uint64_none_in [0, 0xffff_ffff_ffff_ffff]
-    pass
-  end
-  it "has a working function #garray_uint64_none_return" do
-    res = GIMarshallingTests.garray_uint64_none_return
-    _(res).must_be :==, [0, 0xffff_ffff_ffff_ffff]
-  end
-  it "has a working function #garray_unichar_none_in" do
-    skip_below "1.51.1"
-    arr = [0x63, 0x6f, 0x6e, 0x73, 0x74,
-           0x20, 0x2665, 0x20, 0x75, 0x74,
-           0x66, 0x38]
-    GIMarshallingTests.garray_unichar_none_in arr
-  end
-  it "has a working function #garray_utf8_container_inout" do
-    res = GIMarshallingTests.garray_utf8_container_inout %w(0 1 2)
-    _(res).must_be :==, ["-2", "-1", "0", "1"]
-  end
-  it "has a working function #garray_utf8_container_out" do
-    res = GIMarshallingTests.garray_utf8_container_out
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #garray_utf8_container_return" do
-    res = GIMarshallingTests.garray_utf8_container_return
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #garray_utf8_full_inout" do
-    arr = %w(0 1 2)
-    res = GIMarshallingTests.garray_utf8_full_inout arr
-    _(res).must_be :==, ["-2", "-1", "0", "1"]
-  end
-  it "has a working function #garray_utf8_full_out" do
-    res = GIMarshallingTests.garray_utf8_full_out
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #garray_utf8_full_out_caller_allocated" do
-    res = GIMarshallingTests.garray_utf8_full_out_caller_allocated
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #garray_utf8_full_return" do
-    res = GIMarshallingTests.garray_utf8_full_return
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #garray_utf8_none_in" do
-    arr = %w(0 1 2)
-    GIMarshallingTests.garray_utf8_none_in arr
-    pass
-  end
-  it "has a working function #garray_utf8_none_inout" do
-    arr = %w(0 1 2)
-    res = GIMarshallingTests.garray_utf8_none_inout arr
-    _(res).must_be :==, ["-2", "-1", "0", "1"]
-  end
-  it "has a working function #garray_utf8_none_out" do
-    res = GIMarshallingTests.garray_utf8_none_out
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #garray_utf8_none_return" do
-    res = GIMarshallingTests.garray_utf8_none_return
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gbytes_full_return" do
-    res = GIMarshallingTests.gbytes_full_return
-    _(res.to_a).must_equal [0, 49, 0xFF, 51]
-  end
-  it "has a working function #gbytes_none_in" do
-    GIMarshallingTests.gbytes_none_in [0, 49, 0xFF, 51]
-    pass
-  end
-  it "has a working function #gclosure_in" do
-    cl = GObject::RubyClosure.new { 42 }
-    GIMarshallingTests.gclosure_in cl
-    pass
-  end
-  it "has a working function #gclosure_return" do
-    cl = GIMarshallingTests.gclosure_return
-    gv = GObject::Value.wrap_ruby_value 0
-    result = cl.invoke gv, []
-    _(gv.get_value).must_equal 42
-    _(result).must_equal 42
-  end
-  it "has a working function #genum_in" do
-    GIMarshallingTests.genum_in :value3
-    pass
-  end
-  it "has a working function #genum_inout" do
-    res = GIMarshallingTests.genum_inout :value3
-    _(res).must_equal :value1
-  end
-  it "has a working function #genum_out" do
-    res = GIMarshallingTests.genum_out
-    _(res).must_equal :value3
-  end
-  it "has a working function #genum_returnv" do
-    res = GIMarshallingTests.genum_returnv
-    _(res).must_equal :value3
-  end
-  it "has a working function #gerror" do
-    GIMarshallingTests.gerror
-    flunk "Error should have been raised"
-  rescue GirFFI::GLibError => e
-    _(e.message).must_equal GIMarshallingTests::CONSTANT_GERROR_MESSAGE
-    _(e.domain).must_equal GIMarshallingTests::CONSTANT_GERROR_DOMAIN
-    _(e.code).must_equal GIMarshallingTests::CONSTANT_GERROR_CODE
-  end
-  it "has a working function #gerror_array_in" do
-    GIMarshallingTests.gerror_array_in [1, 2, 3]
-    flunk "Error should have been raised"
-  rescue GirFFI::GLibError => e
-    _(e.message).must_equal GIMarshallingTests::CONSTANT_GERROR_MESSAGE
-    _(e.domain).must_equal GIMarshallingTests::CONSTANT_GERROR_DOMAIN
-    _(e.code).must_equal GIMarshallingTests::CONSTANT_GERROR_CODE
-  end
-  it "has a working function #gerror_out" do
-    error, debug = GIMarshallingTests.gerror_out
-    _(debug).must_equal GIMarshallingTests::CONSTANT_GERROR_DEBUG_MESSAGE
-    _(error.message).must_equal GIMarshallingTests::CONSTANT_GERROR_MESSAGE
-  end
-  it "has a working function #gerror_out_transfer_none" do
-    error, debug = GIMarshallingTests.gerror_out_transfer_none
-    _(debug).must_equal GIMarshallingTests::CONSTANT_GERROR_DEBUG_MESSAGE
-    _(error.message).must_equal GIMarshallingTests::CONSTANT_GERROR_MESSAGE
-  end
-  it "has a working function #gerror_return" do
-    error = GIMarshallingTests.gerror_return
-    _(error.message).must_equal GIMarshallingTests::CONSTANT_GERROR_MESSAGE
-  end
-  it "has a working function #ghashtable_double_in" do
-    skip_below "1.51.2"
-    GIMarshallingTests.ghashtable_double_in(
-      "-1" => -0.1, "0" => 0.0, "1" => 0.1, "2" => 0.2)
-  end
-  it "has a working function #ghashtable_float_in" do
-    skip_below "1.51.2"
-    GIMarshallingTests.ghashtable_float_in(
-      "-1" => -0.1, "0" => 0.0, "1" => 0.1, "2" => 0.2)
-  end
-  it "has a working function #ghashtable_int64_in" do
-    skip_below "1.51.2"
-    GIMarshallingTests.ghashtable_int64_in(
-      "-1" => -1, "0" => 0, "1" => 1, "2" => 0x100000000)
-  end
-  it "has a working function #ghashtable_int_none_in" do
-    GIMarshallingTests.ghashtable_int_none_in(
-      -1 => 1, 0 => 0, 1 => -1, 2 => -2)
-  end
-  it "has a working function #ghashtable_int_none_return" do
-    gh = GIMarshallingTests.ghashtable_int_none_return
-    assert_equal({ -1 => 1, 0 => 0, 1 => -1, 2 => -2 }, gh.to_hash)
-  end
-  it "has a working function #ghashtable_uint64_in" do
-    skip_below "1.51.2"
-    GIMarshallingTests.ghashtable_uint64_in(
-      "-1" => 0x100000000, "0" => 0, "1" => 1, "2" => 2)
-  end
-  it "has a working function #ghashtable_utf8_container_in" do
-    skip "This function is defined in the header but not implemented"
-  end
-  it "has a working function #ghashtable_utf8_container_inout" do
-    hsh = { "-1" => "1", "0" => "0", "1" => "-1", "2" => "-2" }
-    res = GIMarshallingTests.ghashtable_utf8_container_inout hsh
-    assert_equal({ "-1" => "1", "0" => "0", "1" => "1" }, res.to_hash)
-  end
-  it "has a working function #ghashtable_utf8_container_out" do
-    res = GIMarshallingTests.ghashtable_utf8_container_out
-    assert_equal({ "-1" => "1", "0" => "0", "1" => "-1", "2" => "-2" },
-                 res.to_hash)
-  end
-  it "has a working function #ghashtable_utf8_container_return" do
-    res = GIMarshallingTests.ghashtable_utf8_container_return
-    assert_equal({ "-1" => "1", "0" => "0", "1" => "-1", "2" => "-2" },
-                 res.to_hash)
-  end
-  it "has a working function #ghashtable_utf8_full_in" do
-    skip "This function is defined in the header but not implemented"
-  end
-  it "has a working function #ghashtable_utf8_full_inout" do
-    hsh = { "-1" => "1", "0" => "0", "1" => "-1", "2" => "-2" }
-    res = GIMarshallingTests.ghashtable_utf8_full_inout hsh
-    assert_equal({ "-1" => "1", "0" => "0", "1" => "1" }, res.to_hash)
-  end
-  it "has a working function #ghashtable_utf8_full_out" do
-    res = GIMarshallingTests.ghashtable_utf8_full_out
-    assert_equal({ "-1" => "1", "0" => "0", "1" => "-1", "2" => "-2" },
-                 res.to_hash)
-  end
-  it "has a working function #ghashtable_utf8_full_return" do
-    res = GIMarshallingTests.ghashtable_utf8_full_return
-    assert_equal({ "-1" => "1", "0" => "0", "1" => "-1", "2" => "-2" },
-                 res.to_hash)
-  end
-  it "has a working function #ghashtable_utf8_none_in" do
-    hsh = { "-1" => "1", "0" => "0", "1" => "-1", "2" => "-2" }
-    GIMarshallingTests.ghashtable_utf8_none_in hsh
-    pass
-  end
-  it "has a working function #ghashtable_utf8_none_inout" do
-    hsh = { "-1" => "1", "0" => "0", "1" => "-1", "2" => "-2" }
-    res = GIMarshallingTests.ghashtable_utf8_none_inout hsh
-    assert_equal({ "-1" => "1", "0" => "0", "1" => "1" }, res.to_hash)
-  end
-  it "has a working function #ghashtable_utf8_none_out" do
-    res = GIMarshallingTests.ghashtable_utf8_none_out
-    assert_equal({ "-1" => "1", "0" => "0", "1" => "-1", "2" => "-2" },
-                 res.to_hash)
-  end
-  it "has a working function #ghashtable_utf8_none_return" do
-    res = GIMarshallingTests.ghashtable_utf8_none_return
-    assert_equal({ "-1" => "1", "0" => "0", "1" => "-1", "2" => "-2" },
-                 res.to_hash)
-  end
-  it "has a working function #glist_int_none_in" do
-    GIMarshallingTests.glist_int_none_in [-1, 0, 1, 2]
-    pass
-  end
-  it "has a working function #glist_int_none_return" do
-    res = GIMarshallingTests.glist_int_none_return
-    _(res).must_be :==, [-1, 0, 1, 2]
-  end
-  it "has a working function #glist_uint32_none_in" do
-    GIMarshallingTests.glist_uint32_none_in [0, 0xffff_ffff]
-    pass
-  end
-  it "has a working function #glist_uint32_none_return" do
-    res = GIMarshallingTests.glist_uint32_none_return
-    _(res).must_be :==, [0, 0xffff_ffff]
-  end
-  it "has a working function #glist_utf8_container_inout" do
-    res = GIMarshallingTests.glist_utf8_container_inout %w(0 1 2)
-    _(res).must_be :==, ["-2", "-1", "0", "1"]
-  end
-  it "has a working function #glist_utf8_container_out" do
-    res = GIMarshallingTests.glist_utf8_container_out
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #glist_utf8_container_return" do
-    res = GIMarshallingTests.glist_utf8_container_return
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #glist_utf8_full_inout" do
-    res = GIMarshallingTests.glist_utf8_full_inout %w(0 1 2)
-    _(res).must_be :==, ["-2", "-1", "0", "1"]
-  end
-  it "has a working function #glist_utf8_full_out" do
-    res = GIMarshallingTests.glist_utf8_full_out
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #glist_utf8_full_return" do
-    res = GIMarshallingTests.glist_utf8_full_return
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #glist_utf8_none_in" do
-    GIMarshallingTests.glist_utf8_none_in %w(0 1 2)
-  end
-  it "has a working function #glist_utf8_none_inout" do
-    res = GIMarshallingTests.glist_utf8_none_inout %w(0 1 2)
-    _(res).must_be :==, ["-2", "-1", "0", "1"]
-  end
-  it "has a working function #glist_utf8_none_out" do
-    res = GIMarshallingTests.glist_utf8_none_out
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #glist_utf8_none_return" do
-    res = GIMarshallingTests.glist_utf8_none_return
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gptrarray_boxed_struct_full_return" do
-    skip_below "1.61.1"
-    result = GIMarshallingTests.gptrarray_boxed_struct_full_return
-    _(result.map(&:long_)).must_equal [42, 43, 44]
-  end
-  it "has a working function #gptrarray_utf8_container_inout" do
-    res = GIMarshallingTests.gptrarray_utf8_container_inout %w(0 1 2)
-    _(res).must_be :==, ["-2", "-1", "0", "1"]
-  end
-  it "has a working function #gptrarray_utf8_container_out" do
-    res = GIMarshallingTests.gptrarray_utf8_container_out
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gptrarray_utf8_container_return" do
-    res = GIMarshallingTests.gptrarray_utf8_container_return
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gptrarray_utf8_full_inout" do
-    res = GIMarshallingTests.gptrarray_utf8_full_inout %w(0 1 2)
-    _(res).must_be :==, ["-2", "-1", "0", "1"]
-  end
-  it "has a working function #gptrarray_utf8_full_out" do
-    res = GIMarshallingTests.gptrarray_utf8_full_out
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gptrarray_utf8_full_return" do
-    res = GIMarshallingTests.gptrarray_utf8_full_return
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gptrarray_utf8_none_in" do
-    GIMarshallingTests.gptrarray_utf8_none_in %w(0 1 2)
-  end
-  it "has a working function #gptrarray_utf8_none_inout" do
-    res = GIMarshallingTests.gptrarray_utf8_none_inout %w(0 1 2)
-    _(res).must_be :==, ["-2", "-1", "0", "1"]
-  end
-  it "has a working function #gptrarray_utf8_none_out" do
-    res = GIMarshallingTests.gptrarray_utf8_none_out
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gptrarray_utf8_none_return" do
-    res = GIMarshallingTests.gptrarray_utf8_none_return
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gslist_int_none_in" do
-    GIMarshallingTests.gslist_int_none_in [-1, 0, 1, 2]
-    pass
-  end
-  it "has a working function #gslist_int_none_return" do
-    res = GIMarshallingTests.gslist_int_none_return
-    _(res).must_be :==, [-1, 0, 1, 2]
-  end
-  it "has a working function #gslist_utf8_container_inout" do
-    res = GIMarshallingTests.gslist_utf8_container_inout %w(0 1 2)
-    _(res).must_be :==, ["-2", "-1", "0", "1"]
-  end
-  it "has a working function #gslist_utf8_container_out" do
-    res = GIMarshallingTests.gslist_utf8_container_out
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gslist_utf8_container_return" do
-    res = GIMarshallingTests.gslist_utf8_container_return
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gslist_utf8_full_inout" do
-    res = GIMarshallingTests.gslist_utf8_full_inout %w(0 1 2)
-    _(res).must_be :==, ["-2", "-1", "0", "1"]
-  end
-  it "has a working function #gslist_utf8_full_out" do
-    res = GIMarshallingTests.gslist_utf8_full_out
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gslist_utf8_full_return" do
-    res = GIMarshallingTests.gslist_utf8_full_return
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gslist_utf8_none_in" do
-    GIMarshallingTests.gslist_utf8_none_in %w(0 1 2)
-    pass
-  end
-  it "has a working function #gslist_utf8_none_inout" do
-    res = GIMarshallingTests.gslist_utf8_none_inout %w(0 1 2)
-    _(res).must_be :==, ["-2", "-1", "0", "1"]
-  end
-  it "has a working function #gslist_utf8_none_out" do
-    res = GIMarshallingTests.gslist_utf8_none_out
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gslist_utf8_none_return" do
-    res = GIMarshallingTests.gslist_utf8_none_return
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gstrv_in" do
-    GIMarshallingTests.gstrv_in %w(0 1 2)
-    pass
-  end
-  it "has a working function #gstrv_inout" do
-    res = GIMarshallingTests.gstrv_inout %w(0 1 2)
-    _(res).must_be :==, ["-1", "0", "1", "2"]
-  end
-  it "has a working function #gstrv_out" do
-    res = GIMarshallingTests.gstrv_out
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gstrv_return" do
-    res = GIMarshallingTests.gstrv_return
-    _(res).must_be :==, %w(0 1 2)
-  end
-  it "has a working function #gtype_in" do
-    GIMarshallingTests.gtype_in GObject::TYPE_NONE
-    pass
-  end
-  it "has a working function #gtype_inout" do
-    res = GIMarshallingTests.gtype_inout GObject::TYPE_NONE
-    _(res).must_equal GObject::TYPE_INT
-  end
-  it "has a working function #gtype_out" do
-    res = GIMarshallingTests.gtype_out
-    _(res).must_equal GObject::TYPE_NONE
-  end
-  it "has a working function #gtype_return" do
-    res = GIMarshallingTests.gtype_return
-    _(res).must_equal GObject::TYPE_NONE
-  end
-  it "has a working function #gtype_string_in" do
-    GIMarshallingTests.gtype_string_in GObject::TYPE_STRING
-    pass
-  end
-  it "has a working function #gtype_string_out" do
-    res = GIMarshallingTests.gtype_string_out
-    _(res).must_equal GObject::TYPE_STRING
-  end
-  it "has a working function #gtype_string_return" do
-    res = GIMarshallingTests.gtype_string_return
-    _(res).must_equal GObject::TYPE_STRING
-  end
-  it "has a working function #gvalue_flat_array" do
-    GIMarshallingTests.gvalue_flat_array [42, "42", true]
-    pass
-  end
-  it "has a working function #gvalue_flat_array_round_trip" do
-    result = GIMarshallingTests.gvalue_flat_array_round_trip 42, "42", true
-    arr = result.to_a
-    _(arr[0].get_value).must_equal 42
-    _(arr[1].get_value).must_equal "42"
-    _(arr[2].get_value).must_equal true
-  end
-  it "has a working function #gvalue_in" do
-    GIMarshallingTests.gvalue_in GObject::Value.wrap_ruby_value(42)
-    GIMarshallingTests.gvalue_in 42
-    pass
-  end
-  it "has a working function #gvalue_in_enum" do
-    gv = GObject::Value.new
-    gv.init GIMarshallingTests::GEnum.gtype
-    gv.set_enum GIMarshallingTests::GEnum[:value3]
-    GIMarshallingTests.gvalue_in_enum gv
-    pass
-  end
-  it "has a working function #gvalue_in_with_modification" do
-    gv = GObject::Value.wrap_ruby_value(42)
-    GIMarshallingTests.gvalue_in_with_modification gv
-    _(gv.get_value).must_equal 24
-  end
-  it "has a working function #gvalue_in_with_type" do
-    gv = GObject::Value.new
-    gv.init GIMarshallingTests::SubSubObject.gtype
-    GIMarshallingTests.gvalue_in_with_type gv, GIMarshallingTests::Object.gtype
-  end
-  it "has a working function #gvalue_inout" do
-    res = GIMarshallingTests.gvalue_inout GObject::Value.wrap_ruby_value(42)
-    _(res).must_equal "42"
-    res = GIMarshallingTests.gvalue_inout 42
-    _(res).must_equal "42"
-  end
-  it "has a working function #gvalue_int64_in" do
-    gv = GObject::Value.new
-    gv.init GObject::TYPE_INT64
-    gv.set_value 0x7fff_ffff_ffff_ffff
-    GIMarshallingTests.gvalue_int64_in gv
-    pass
-  end
-  it "has a working function #gvalue_int64_out" do
-    gv = GIMarshallingTests.gvalue_int64_out
-    _(gv).must_equal 0x7fff_ffff_ffff_ffff
-  end
-  it "has a working function #gvalue_out" do
-    res = GIMarshallingTests.gvalue_out
-    _(res).must_equal 42
-  end
-  it "has a working function #gvalue_out_caller_allocates" do
-    res = GIMarshallingTests.gvalue_out_caller_allocates
-    _(res).must_equal 42
-  end
-  it "has a working function #gvalue_return" do
-    res = GIMarshallingTests.gvalue_return
-    _(res).must_equal 42
-  end
-  it "has a working function #init_function" do
-    res, arr = GIMarshallingTests.init_function %w(foo bar baz)
-    _(res).must_equal true
-    _(arr).must_be :==, %w(foo bar)
-  end
-  it "has a working function #int16_in_max" do
-    GIMarshallingTests.int16_in_max 0x7fff
-    pass
-  end
-  it "has a working function #int16_in_min" do
-    GIMarshallingTests.int16_in_min(-0x8000)
-    pass
-  end
-  it "has a working function #int16_inout_max_min" do
-    res = GIMarshallingTests.int16_inout_max_min 0x7fff
-    assert_equal res, -0x8000
-  end
-  it "has a working function #int16_inout_min_max" do
-    res = GIMarshallingTests.int16_inout_min_max(-0x8000)
-    assert_equal 0x7fff, res
-  end
-  it "has a working function #int16_out_max" do
-    res = GIMarshallingTests.int16_out_max
-    assert_equal 0x7fff, res
-  end
-  it "has a working function #int16_out_min" do
-    res = GIMarshallingTests.int16_out_min
-    assert_equal(-0x8000, res)
-  end
-  it "has a working function #int16_return_max" do
-    res = GIMarshallingTests.int16_return_max
-    assert_equal 0x7fff, res
-  end
-  it "has a working function #int16_return_min" do
-    res = GIMarshallingTests.int16_return_min
-    assert_equal(-0x8000, res)
-  end
-  it "has a working function #int32_in_max" do
-    GIMarshallingTests.int32_in_max 0x7fffffff
-    pass
-  end
-  it "has a working function #int32_in_min" do
-    GIMarshallingTests.int32_in_min(-0x80000000)
-    pass
-  end
-  it "has a working function #int32_inout_max_min" do
-    res = GIMarshallingTests.int32_inout_max_min 0x7fffffff
-    assert_equal(-0x80000000, res)
-  end
-  it "has a working function #int32_inout_min_max" do
-    res = GIMarshallingTests.int32_inout_min_max(-0x80000000)
-    assert_equal 0x7fffffff, res
-  end
-  it "has a working function #int32_out_max" do
-    res = GIMarshallingTests.int32_out_max
-    assert_equal 0x7fffffff, res
-  end
-  it "has a working function #int32_out_min" do
-    res = GIMarshallingTests.int32_out_min
-    assert_equal(-0x80000000, res)
-  end
-  it "has a working function #int32_return_max" do
-    res = GIMarshallingTests.int32_return_max
-    assert_equal 0x7fffffff, res
-  end
-  it "has a working function #int32_return_min" do
-    res = GIMarshallingTests.int32_return_min
-    assert_equal(-0x80000000, res)
-  end
-  it "has a working function #int64_in_max" do
-    GIMarshallingTests.int64_in_max 0x7fffffffffffffff
-    pass
-  end
-  it "has a working function #int64_in_min" do
-    GIMarshallingTests.int64_in_min(-0x8000000000000000)
-    pass
-  end
-  it "has a working function #int64_inout_max_min" do
-    res = GIMarshallingTests.int64_inout_max_min 0x7fffffffffffffff
-    assert_equal(-0x8000000000000000, res)
-  end
-  it "has a working function #int64_inout_min_max" do
-    res = GIMarshallingTests.int64_inout_min_max(-0x8000000000000000)
-    assert_equal 0x7fffffffffffffff, res
-  end
-  it "has a working function #int64_out_max" do
-    res = GIMarshallingTests.int64_out_max
-    assert_equal 0x7fffffffffffffff, res
-  end
-  it "has a working function #int64_out_min" do
-    res = GIMarshallingTests.int64_out_min
-    assert_equal(-0x8000000000000000, res)
-  end
-  it "has a working function #int64_return_max" do
-    res = GIMarshallingTests.int64_return_max
-    assert_equal 0x7fffffffffffffff, res
-  end
-  it "has a working function #int64_return_min" do
-    res = GIMarshallingTests.int64_return_min
-    assert_equal(-0x8000000000000000, res)
-  end
-  it "has a working function #int8_in_max" do
-    GIMarshallingTests.int8_in_max 0x7f
-    pass
-  end
-  it "has a working function #int8_in_min" do
-    GIMarshallingTests.int8_in_min(-0x80)
-    pass
-  end
-  it "has a working function #int8_inout_max_min" do
-    res = GIMarshallingTests.int8_inout_max_min 0x7f
-    assert_equal(-0x80, res)
-  end
-  it "has a working function #int8_inout_min_max" do
-    res = GIMarshallingTests.int8_inout_min_max(-0x80)
-    assert_equal 0x7f, res
-  end
-  it "has a working function #int8_out_max" do
-    res = GIMarshallingTests.int8_out_max
-    assert_equal 0x7f, res
-  end
-  it "has a working function #int8_out_min" do
-    res = GIMarshallingTests.int8_out_min
-    assert_equal(-0x80, res)
-  end
-  it "has a working function #int8_return_max" do
-    res = GIMarshallingTests.int8_return_max
-    assert_equal 0x7f, res
-  end
-  it "has a working function #int8_return_min" do
-    res = GIMarshallingTests.int8_return_min
-    assert_equal(-0x80, res)
-  end
-  it "has a working function #int_in_max" do
-    GIMarshallingTests.int_in_max 0x7fffffff
-    pass
-  end
-  it "has a working function #int_in_min" do
-    GIMarshallingTests.int_in_min(-0x80000000)
-    pass
-  end
-  it "has a working function #int_inout_max_min" do
-    res = GIMarshallingTests.int_inout_max_min 0x7fffffff
-    assert_equal(-0x80000000, res)
-  end
-  it "has a working function #int_inout_min_max" do
-    res = GIMarshallingTests.int_inout_min_max(-0x80000000)
-    assert_equal 0x7fffffff, res
-  end
-  it "has a working function #int_one_in_utf8_two_in_one_allows_none" do
-    GIMarshallingTests.int_one_in_utf8_two_in_one_allows_none 1, "2", "3"
-    GIMarshallingTests.int_one_in_utf8_two_in_one_allows_none 1, nil, "3"
-    pass
-  end
-  it "has a working function #int_out_max" do
-    res = GIMarshallingTests.int_out_max
-    assert_equal 0x7fffffff, res
-  end
-  it "has a working function #int_out_min" do
-    res = GIMarshallingTests.int_out_min
-    assert_equal(-0x80000000, res)
-  end
-  it "has a working function #int_out_out" do
-    res = GIMarshallingTests.int_out_out
-    assert_equal [6, 7], res
-  end
-  it "has a working function #int_return_max" do
-    res = GIMarshallingTests.int_return_max
-    assert_equal 0x7fffffff, res
-  end
-  it "has a working function #int_return_min" do
-    res = GIMarshallingTests.int_return_min
-    assert_equal(-0x80000000, res)
-  end
-  it "has a working function #int_return_out" do
-    res = GIMarshallingTests.int_return_out
-    assert_equal [6, 7], res
-  end
-  it "has a working function #int_three_in_three_out" do
-    res = GIMarshallingTests.int_three_in_three_out 4, 5, 6
-    assert_equal [4, 5, 6], res
-  end
-  it "has a working function #int_two_in_utf8_two_in_with_allow_none" do
-    GIMarshallingTests.int_two_in_utf8_two_in_with_allow_none 1, 2, "3", "4"
-    GIMarshallingTests.int_two_in_utf8_two_in_with_allow_none 1, 2, nil, nil
-    pass
-  end
-  it "has a working function #long_in_max" do
-    GIMarshallingTests.long_in_max max_long
-    pass
-  end
-  it "has a working function #long_in_min" do
-    GIMarshallingTests.long_in_min min_long
-    pass
-  end
-  it "has a working function #long_inout_max_min" do
-    res = GIMarshallingTests.long_inout_max_min max_long
-    assert_equal min_long, res
-  end
-  it "has a working function #long_inout_min_max" do
-    res = GIMarshallingTests.long_inout_min_max min_long
-    assert_equal max_long, res
-  end
-  it "has a working function #long_out_max" do
-    res = GIMarshallingTests.long_out_max
-    assert_equal max_long, res
-  end
-  it "has a working function #long_out_min" do
-    res = GIMarshallingTests.long_out_min
-    assert_equal min_long, res
-  end
-  it "has a working function #long_return_max" do
-    res = GIMarshallingTests.long_return_max
-    assert_equal max_long, res
-  end
-  it "has a working function #long_return_min" do
-    res = GIMarshallingTests.long_return_min
-    assert_equal min_long, res
-  end
-  it "has a working function #multi_array_key_value_in" do
-    keys = %w(one two three)
-    values = [1, 2, 3].map { |val| GObject::Value.wrap_ruby_value val }
-    GIMarshallingTests.multi_array_key_value_in keys, values
-  end
-  it "has a working function #no_type_flags_in" do
-    GIMarshallingTests.no_type_flags_in value2: true
-    pass
-  end
-  it "has a working function #no_type_flags_in_zero" do
-    GIMarshallingTests.no_type_flags_in_zero 0
-    pass
-  end
-  it "has a working function #no_type_flags_inout" do
-    res = GIMarshallingTests.no_type_flags_inout value2: true
-    _(res).must_equal(value1: true)
-  end
-  it "has a working function #no_type_flags_out" do
-    res = GIMarshallingTests.no_type_flags_out
-    _(res).must_equal(value2: true)
-  end
-  it "has a working function #no_type_flags_returnv" do
-    res = GIMarshallingTests.no_type_flags_returnv
-    _(res).must_equal(value2: true)
-  end
-  it "has a working function #overrides_struct_returnv" do
-    res = GIMarshallingTests.overrides_struct_returnv
-    _(res).must_be_instance_of GIMarshallingTests::OverridesStruct
-  end
-  it "has a working function #param_spec_in_bool" do
-    ps = GObject.param_spec_boolean "mybool", "nick", "blurb", true, :readable
-    GIMarshallingTests.param_spec_in_bool ps
-    pass
-  end
-  it "has a working function #param_spec_out" do
-    res = GIMarshallingTests.param_spec_out
-    _(res.value_type).must_equal GObject::TYPE_STRING
-    _(res.get_name).must_equal "test-param"
-  end
-  it "has a working function #param_spec_return" do
-    res = GIMarshallingTests.param_spec_return
-    _(res.value_type).must_equal GObject::TYPE_STRING
-    _(res.get_name).must_equal "test-param"
-  end
-  it "has a working function #pointer_in_return" do
-    ptr = FFI::MemoryPointer.new 1
-    res = GIMarshallingTests.pointer_in_return ptr
-    assert_equal ptr.address, res.address
-  end
-  it "has a working function #pointer_struct_get_type" do
-    res = GIMarshallingTests.pointer_struct_get_type
-    gtype = GObject.type_from_name "GIMarshallingTestsPointerStruct"
-    assert_equal gtype, res
-  end
-  it "has a working function #pointer_struct_returnv" do
-    res = GIMarshallingTests.pointer_struct_returnv
-    assert_instance_of GIMarshallingTests::PointerStruct, res
-    assert_equal 42, res.long_
-  end
-  it "has a working function #return_gvalue_flat_array" do
-    result = GIMarshallingTests.return_gvalue_flat_array
-    arr = result.to_a
-    _(arr[0].get_value).must_equal 42
-    _(arr[1].get_value).must_equal "42"
-    _(arr[2].get_value).must_equal true
-  end
-  it "has a working function #short_in_max" do
-    GIMarshallingTests.short_in_max 0x7fff
-    pass
-  end
-  it "has a working function #short_in_min" do
-    GIMarshallingTests.short_in_min(-0x8000)
-    pass
-  end
-  it "has a working function #short_inout_max_min" do
-    res = GIMarshallingTests.short_inout_max_min 0x7fff
-    assert_equal(-0x8000, res)
-  end
-  it "has a working function #short_inout_min_max" do
-    res = GIMarshallingTests.short_inout_min_max(-0x8000)
-    assert_equal 0x7fff, res
-  end
-  it "has a working function #short_out_max" do
-    res = GIMarshallingTests.short_out_max
-    assert_equal 0x7fff, res
-  end
-  it "has a working function #short_out_min" do
-    res = GIMarshallingTests.short_out_min
-    assert_equal(-0x8000, res)
-  end
-  it "has a working function #short_return_max" do
-    res = GIMarshallingTests.short_return_max
-    assert_equal 0x7fff, res
-  end
-  it "has a working function #short_return_min" do
-    res = GIMarshallingTests.short_return_min
-    assert_equal(-0x8000, res)
-  end
-  it "has a working function #simple_struct_returnv" do
-    res = GIMarshallingTests.simple_struct_returnv
-    assert_instance_of GIMarshallingTests::SimpleStruct, res
-    assert_equal 6, res.long_
-    assert_equal 7, res.int8
-  end
-  it "has a working function #size_in" do
-    GIMarshallingTests.size_in max_size_t
-  end
-  it "has a working function #size_inout" do
-    res = GIMarshallingTests.size_inout max_size_t
-    assert_equal 0, res
-  end
-  it "has a working function #size_out" do
-    res = GIMarshallingTests.size_out
-    assert_equal max_size_t, res
-  end
-  it "has a working function #size_return" do
-    res = GIMarshallingTests.size_return
-    assert_equal max_size_t, res
-  end
-  it "has a working function #ssize_in_max" do
-    GIMarshallingTests.ssize_in_max max_ssize_t
-    pass
-  end
-  it "has a working function #ssize_in_min" do
-    GIMarshallingTests.ssize_in_min min_ssize_t
-    pass
-  end
-  it "has a working function #ssize_inout_max_min" do
-    res = GIMarshallingTests.ssize_inout_max_min max_ssize_t
-    assert_equal min_ssize_t, res
-  end
-  it "has a working function #ssize_inout_min_max" do
-    res = GIMarshallingTests.ssize_inout_min_max min_ssize_t
-    assert_equal max_ssize_t, res
-  end
-  it "has a working function #ssize_out_max" do
-    res = GIMarshallingTests.ssize_out_max
-    assert_equal max_ssize_t, res
-  end
-  it "has a working function #ssize_out_min" do
-    res = GIMarshallingTests.ssize_out_min
-    assert_equal min_ssize_t, res
-  end
-  it "has a working function #ssize_return_max" do
-    res = GIMarshallingTests.ssize_return_max
-    assert_equal max_ssize_t, res
-  end
-  it "has a working function #ssize_return_min" do
-    res = GIMarshallingTests.ssize_return_min
-    assert_equal min_ssize_t, res
-  end
-  it "has a working function #test_interface_test_int8_in" do
-    derived_klass.class_eval { include GIMarshallingTests::Interface }
-    instance = make_derived_instance do |info|
-      info.install_vfunc_implementation :test_int8_in, proc { |obj, in_| obj.int = in_ }
-    end
-    _(instance.int).must_equal 0
-    GIMarshallingTests.test_interface_test_int8_in instance, 8
-    _(instance.int).must_equal 8
-  end
-  it "has a working function #time_t_in" do
-    GIMarshallingTests.time_t_in 1_234_567_890
-    pass
-  end
-  it "has a working function #time_t_inout" do
-    res = GIMarshallingTests.time_t_inout 1_234_567_890
-    assert_equal 0, res
-  end
-  it "has a working function #time_t_out" do
-    res = GIMarshallingTests.time_t_out
-    assert_equal 1_234_567_890, res
-  end
-  it "has a working function #time_t_return" do
-    res = GIMarshallingTests.time_t_return
-    assert_equal 1_234_567_890, res
-  end
-  it "has a working function #uint16_in" do
-    GIMarshallingTests.uint16_in 0xffff
-    pass
-  end
-  it "has a working function #uint16_inout" do
-    res = GIMarshallingTests.uint16_inout 0xffff
-    assert_equal 0, res
-  end
-  it "has a working function #uint16_out" do
-    res = GIMarshallingTests.uint16_out
-    assert_equal 0xffff, res
-  end
-  it "has a working function #uint16_return" do
-    res = GIMarshallingTests.uint16_return
-    assert_equal 0xffff, res
-  end
-  it "has a working function #uint32_in" do
-    GIMarshallingTests.uint32_in 0xffffffff
-  end
-  it "has a working function #uint32_inout" do
-    res = GIMarshallingTests.uint32_inout 0xffffffff
-    assert_equal 0, res
-  end
-  it "has a working function #uint32_out" do
-    res = GIMarshallingTests.uint32_out
-    assert_equal 0xffffffff, res
-  end
-  it "has a working function #uint32_return" do
-    res = GIMarshallingTests.uint32_return
-    assert_equal 0xffffffff, res
-  end
-  it "has a working function #uint64_in" do
-    GIMarshallingTests.uint64_in 0xffff_ffff_ffff_ffff
-    pass
-  end
-  it "has a working function #uint64_inout" do
-    res = GIMarshallingTests.uint64_inout 0xffff_ffff_ffff_ffff
-    assert_equal 0, res
-  end
-  it "has a working function #uint64_out" do
-    res = GIMarshallingTests.uint64_out
-    assert_equal 0xffff_ffff_ffff_ffff, res
-  end
-  it "has a working function #uint64_return" do
-    res = GIMarshallingTests.uint64_return
-    assert_equal 0xffff_ffff_ffff_ffff, res
-  end
-  it "has a working function #uint8_in" do
-    GIMarshallingTests.uint8_in 0xff
-  end
-  it "has a working function #uint8_inout" do
-    res = GIMarshallingTests.uint8_inout 0xff
-    assert_equal 0, res
-  end
-  it "has a working function #uint8_out" do
-    res = GIMarshallingTests.uint8_out
-    assert_equal 0xff, res
-  end
-  it "has a working function #uint8_return" do
-    res = GIMarshallingTests.uint8_return
-    assert_equal 0xff, res
-  end
-  it "has a working function #uint_in" do
-    GIMarshallingTests.uint_in max_uint
-    pass
-  end
-  it "has a working function #uint_inout" do
-    res = GIMarshallingTests.uint_inout max_uint
-    assert_equal 0, res
-  end
-  it "has a working function #uint_out" do
-    res = GIMarshallingTests.uint_out
-    assert_equal max_uint, res
-  end
-  it "has a working function #uint_return" do
-    res = GIMarshallingTests.uint_return
-    assert_equal max_uint, res
-  end
-  it "has a working function #ulong_in" do
-    GIMarshallingTests.ulong_in max_ulong
-  end
-  it "has a working function #ulong_inout" do
-    res = GIMarshallingTests.ulong_inout max_ulong
-    assert_equal 0, res
-  end
-  it "has a working function #ulong_out" do
-    res = GIMarshallingTests.ulong_out
-    assert_equal max_ulong, res
-  end
-  it "has a working function #ulong_return" do
-    res = GIMarshallingTests.ulong_return
-    assert_equal max_ulong, res
-  end
-  it "has a working function #union_inout" do
-    skip "This function is defined in the header but not implemented"
-  end
-  it "has a working function #union_out" do
-    skip "This function is defined in the header but not implemented"
-  end
-  it "has a working function #union_returnv" do
-    res = GIMarshallingTests.union_returnv
-    assert_instance_of GIMarshallingTests::Union, res
-    assert_equal 42, res.long_
-  end
-  it "has a working function #ushort_in" do
-    GIMarshallingTests.ushort_in max_ushort
-    pass
-  end
-  it "has a working function #ushort_inout" do
-    res = GIMarshallingTests.ushort_inout max_ushort
-    assert_equal 0, res
-  end
-  it "has a working function #ushort_out" do
-    res = GIMarshallingTests.ushort_out
-    assert_equal max_ushort, res
-  end
-  it "has a working function #ushort_return" do
-    res = GIMarshallingTests.ushort_return
-    assert_equal max_ushort, res
-  end
-  it "has a working function #utf8_as_uint8array_in" do
-    GIMarshallingTests.utf8_as_uint8array_in GIMarshallingTests::CONSTANT_UTF8.bytes.to_a
-    pass
-  end
-  it "has a working function #utf8_dangling_out" do
-    res = GIMarshallingTests.utf8_dangling_out
-    assert_nil res
-  end
-  it "has a working function #utf8_full_in" do
-    skip "This function is defined in the header but not implemented"
-  end
-  it "has a working function #utf8_full_inout" do
-    res = GIMarshallingTests.utf8_full_inout "const ♥ utf8"
-    assert_equal "", res
-  end
-  it "has a working function #utf8_full_out" do
-    res = GIMarshallingTests.utf8_full_out
-    assert_equal "const ♥ utf8", res
-  end
-  it "has a working function #utf8_full_return" do
-    res = GIMarshallingTests.utf8_full_return
-    assert_equal "const ♥ utf8", res
-  end
-  it "has a working function #utf8_none_in" do
-    GIMarshallingTests.utf8_none_in "const ♥ utf8"
-    pass
-  end
-  it "has a working function #utf8_none_inout" do
-    res = GIMarshallingTests.utf8_none_inout "const ♥ utf8"
-    assert_equal "", res
-  end
-  it "has a working function #utf8_none_out" do
-    res = GIMarshallingTests.utf8_none_out
-    assert_equal "const ♥ utf8", res
-  end
-  it "has a working function #utf8_none_return" do
-    res = GIMarshallingTests.utf8_none_return
-    assert_equal "const ♥ utf8", res
-  end
-end