gir_ffi 0.15.3 → 0.15.4

data/test/gir_ffi/boxed_base_test.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :GIMarshallingTests
-
-describe GirFFI::BoxedBase do
-  describe "initialize" do
-    it "sets up the held struct pointer" do
-      # NOTE: GObject::Value uses the generic constructor, unlike
-      # GIMarshallingTests::BoxedStruct, which has its own constructor.
-      value = GObject::Value.new
-      _(value.to_ptr).wont_be_nil
-    end
-  end
-
-  describe "copy_from" do
-    it "returns a copy with owned false" do
-      original = GIMarshallingTests::BoxedStruct.new
-      copy = GIMarshallingTests::BoxedStruct.copy_from(original)
-      ptr = copy.to_ptr
-      _(ptr).wont_be :==, original.to_ptr
-      _(ptr).wont_be :autorelease? if ptr.respond_to? :autorelease?
-      _(copy.struct).wont_be :owned?
-    end
-  end
-
-  describe "wrap_own" do
-    it "wraps and owns the supplied pointer" do
-      original = GIMarshallingTests::BoxedStruct.new
-      copy = GIMarshallingTests::BoxedStruct.wrap_own(original.to_ptr)
-      ptr = copy.to_ptr
-      _(ptr).must_equal original.to_ptr
-      _(ptr).wont_be :autorelease? if ptr.respond_to? :autorelease?
-      _(copy.struct).must_be :owned?
-    end
-  end
-
-  describe "upon garbage collection" do
-    it "frees and disowns the underlying struct if it is owned" do
-      skip "cannot be reliably tested on JRuby" if jruby?
-
-      allow(GObject).to receive(:boxed_free)
-      gtype = GIMarshallingTests::BoxedStruct.gtype
-
-      owned_struct = GIMarshallingTests::BoxedStruct.new.struct
-      owned_ptr = owned_struct.to_ptr
-
-      unowned_struct = GIMarshallingTests::BoxedStruct.new.struct
-      unowned_struct.owned = false
-      unowned_ptr = unowned_struct.to_ptr
-
-      GC.start
-      # Creating a new object is sometimes needed to trigger enough garbage collection.
-      GIMarshallingTests::BoxedStruct.new
-      sleep 1
-      GC.start
-      GC.start
-
-      expect(GObject).to have_received(:boxed_free).with(gtype, owned_ptr)
-      expect(GObject).not_to have_received(:boxed_free).with(gtype, unowned_ptr)
-      _(owned_struct).wont_be :owned?
-    end
-  end
-end

data/test/gir_ffi/builder_test.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-GirFFI.setup :Regress
-GirFFI.setup :GIMarshallingTests
-
-describe GirFFI::Builder do
-  let(:gir) { GObjectIntrospection::IRepository.default }
-
-  describe ".build_class" do
-    it "does not replace existing classes" do
-      oldclass = GObject::Object
-      GirFFI::Builder.build_class get_introspection_data("GObject", "Object")
-      _(GObject::Object).must_equal oldclass
-    end
-  end
-
-  describe ".build_module" do
-    it "refuses to build existing modules defined elsewhere" do
-      result = _(-> { GirFFI::Builder.build_module("Array") }).must_raise RuntimeError
-      _(result.message).must_equal "The module Array was already defined elsewhere"
-    end
-
-    describe "building a module for the first time" do
-      before do
-        save_module :Regress
-        GirFFI::Builder.build_module "Regress"
-      end
-
-      it "creates a Lib module ready to attach functions from the shared library" do
-        gir = GObjectIntrospection::IRepository.default
-        expected = [gir.shared_library("Regress")]
-        assert_equal expected, Regress::Lib.ffi_libraries.map(&:name)
-      end
-
-      after do
-        restore_module :Regress
-      end
-    end
-
-    describe "building a module that already exists" do
-      it "does not replace the existing module" do
-        oldmodule = Regress
-        GirFFI::Builder.build_module "Regress"
-        assert_equal oldmodule, Regress
-      end
-
-      it "does not replace the existing Lib module" do
-        oldmodule = Regress::Lib
-        GirFFI::Builder.build_module "Regress"
-        assert_equal oldmodule, Regress::Lib
-      end
-    end
-
-    it "passes the version on to ModuleBuilder" do
-      builder = double(generate: nil)
-      expect(GirFFI::Builders::ModuleBuilder).to receive(:new)
-        .with("Foo", namespace: "Foo", version: "1.0")
-        .and_return builder
-
-      GirFFI::Builder.build_module "Foo", "1.0"
-    end
-  end
-
-  describe ".build_by_gtype" do
-    it "returns the class types known to the GIR" do
-      result = GirFFI::Builder.build_by_gtype GObject::Object.gtype
-      _(result).must_equal GObject::Object
-    end
-
-    it "returns the class for user-defined types" do
-      klass = Class.new GIMarshallingTests::OverridesObject
-      Object.const_set "Derived#{Sequence.next}", klass
-      gtype = GirFFI.define_type klass
-
-      found_klass = GirFFI::Builder.build_by_gtype gtype
-      _(found_klass).must_equal klass
-    end
-
-    it "returns the class for user-defined types not derived from GObject" do
-      klass = Class.new Regress::TestFundamentalObject
-      Object.const_set "Derived#{Sequence.next}", klass
-      gtype = GirFFI.define_type klass
-
-      found_klass = GirFFI::Builder.build_by_gtype gtype
-      _(found_klass).must_equal klass
-    end
-
-    it "returns a valid class for boxed classes unknown to GIR" do
-      object_class = GIMarshallingTests::PropertiesObject.object_class
-      property = object_class.find_property "some-boxed-glist"
-      gtype = property.value_type
-
-      _(gtype).wont_equal GObject::TYPE_NONE
-
-      found_klass = GirFFI::Builder.build_by_gtype gtype
-      _(found_klass.name).must_be_nil
-      _(found_klass.superclass).must_equal GirFFI::BoxedBase
-    end
-
-    it "refuse to build classes for base types" do
-      _(-> { GirFFI::Builder.build_by_gtype GObject::TYPE_INT })
-        .must_raise RuntimeError, "Unable to handle type gint"
-    end
-  end
-
-  describe ".attach_ffi_function" do
-    let(:lib) { Module.new }
-
-    it "attaches regress_test_callback_destroy_notify with the correct types" do
-      function_info = get_introspection_data "Regress", "test_callback_destroy_notify"
-
-      expect(lib)
-        .to receive(:attach_function)
-        .with("regress_test_callback_destroy_notify",
-              [Regress::TestCallbackUserData, :pointer, GLib::DestroyNotify],
-              :int32)
-        .and_return true
-
-      GirFFI::Builder.attach_ffi_function(lib, function_info)
-    end
-
-    it "attaches regress_test_obj_torture_signature_0 with the correct types" do
-      info = get_method_introspection_data "Regress", "TestObj", "torture_signature_0"
-
-      expect(lib)
-        .to receive(:attach_function)
-        .with("regress_test_obj_torture_signature_0",
-              [:pointer, :int32, :pointer, :pointer, :pointer, :pointer, :uint32],
-              :void)
-        .and_return true
-
-      GirFFI::Builder.attach_ffi_function(lib, info)
-    end
-
-    it "attaches regress_test_obj_instance_method with the correct types" do
-      info = get_method_introspection_data "Regress", "TestObj", "instance_method"
-      expect(lib).to receive(:attach_function)
-        .with("regress_test_obj_instance_method", [:pointer], :int32)
-        .and_return true
-      GirFFI::Builder.attach_ffi_function(lib, info)
-    end
-
-    it "calls attach_function with the correct types for Regress.test_array_gint32_in" do
-      info = get_introspection_data "Regress", "test_array_gint32_in"
-      expect(lib).to receive(:attach_function)
-        .with("regress_test_array_gint32_in", [:int32, :pointer], :int32)
-        .and_return true
-      GirFFI::Builder.attach_ffi_function(lib, info)
-    end
-
-    it "calls attach_function with the correct types for Regress.test_enum_param" do
-      info = get_introspection_data "Regress", "test_enum_param"
-      expect(lib).to receive(:attach_function)
-        .with("regress_test_enum_param", [Regress::TestEnum], :pointer)
-        .and_return true
-      GirFFI::Builder.attach_ffi_function(lib, info)
-    end
-
-    it "does not attach the function if it is already defined" do
-      info = get_introspection_data "Regress", "test_array_gint32_in"
-      allow(lib).to receive(:method_defined?).and_return true
-      expect(lib).not_to receive(:attach_function)
-      GirFFI::Builder.attach_ffi_function(lib, info)
-    end
-  end
-end

data/test/gir_ffi/builders/argument_builder_test.rb

@@ -1,691 +0,0 @@
-# frozen_string_literal: true
-
-require "gir_ffi_test_helper"
-
-describe GirFFI::Builders::ArgumentBuilder do
-  let(:var_gen) { GirFFI::VariableNameGenerator.new }
-  let(:builder) { GirFFI::Builders::ArgumentBuilder.new(var_gen, arg_info) }
-
-  describe "for an argument with direction :in" do
-    describe "for :c" do
-      describe "with full ownership transfer" do
-        let(:arg_info) do
-          get_introspection_data("GIMarshallingTests", "array_struct_take_in").args[0]
-        end
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion)
-            .must_equal [
-              "_v1 = GirFFI::SizedArray.copy_from(" \
-              "[:pointer, GIMarshallingTests::BoxedStruct], -1, structs)"
-            ]
-        end
-
-        it "has the correct value for #post_conversion" do
-          _(builder.post_conversion).must_equal []
-        end
-      end
-    end
-
-    describe "for :callback" do
-      let(:arg_info) do
-        get_introspection_data("Regress", "test_callback_destroy_notify").args[0]
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion)
-          .must_equal ["_v1 = Regress::TestCallbackUserData.from(callback)"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion).must_equal []
-      end
-    end
-
-    describe "for :zero_terminated" do
-      let(:arg_info) do
-        get_introspection_data("GIMarshallingTests",
-                               "array_in_len_zero_terminated").args[0]
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion)
-          .must_equal ["_v1 = GirFFI::ZeroTerminated.from(:gint32, ints)"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion).must_equal []
-      end
-    end
-
-    describe "for :void" do
-      let(:arg_info) do
-        get_introspection_data("Regress", "test_callback_user_data").args[1]
-      end
-
-      describe "when it is a regular argument" do
-        it "has the correct value for method_argument_name" do
-          _(builder.method_argument_name).must_equal arg_info.name
-        end
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion).must_equal ["_v1 = user_data"]
-        end
-
-        it "has the correct value for #post_conversion" do
-          _(builder.post_conversion).must_equal []
-        end
-      end
-
-      describe "when it is a closure" do
-        before do
-          callback = Object.new
-          allow(callback).to receive(:call_argument_name).and_return "foo"
-          builder.mark_as_user_data callback
-        end
-
-        it "has the correct value for method_argument_name" do
-          _(builder.method_argument_name).must_be_nil
-        end
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion).must_equal ["_v1 = GirFFI::ArgHelper.store(foo)"]
-        end
-
-        it "has the correct value for #post_conversion" do
-          _(builder.post_conversion).must_equal []
-        end
-      end
-    end
-  end
-
-  describe "for an argument with direction :out" do
-    describe "for :enum" do
-      let(:arg_info) { get_introspection_data("GIMarshallingTests", "genum_out").args[0] }
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion)
-          .must_equal ["_v1 = FFI::MemoryPointer.new GIMarshallingTests::GEnum"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion)
-          .must_equal ["_v2 = GIMarshallingTests::GEnum.get_value_from_pointer(_v1, 0)"]
-      end
-    end
-
-    describe "for :flags" do
-      let(:arg_info) do
-        get_introspection_data("GIMarshallingTests", "flags_out").args[0]
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion)
-          .must_equal ["_v1 = FFI::MemoryPointer.new GIMarshallingTests::Flags"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion)
-          .must_equal ["_v2 = GIMarshallingTests::Flags.get_value_from_pointer(_v1, 0)"]
-      end
-    end
-
-    describe "for :object" do
-      describe "with full ownership transfer" do
-        let(:arg_info) do
-          get_method_introspection_data("Regress", "TestObj", "null_out").args[0]
-        end
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :pointer"]
-        end
-
-        it "has the correct value for #post_conversion" do
-          _(builder.post_conversion)
-            .must_equal ["_v2 = Regress::TestObj.wrap(_v1.get_pointer(0))"]
-        end
-      end
-
-      describe "with no ownership transfer" do
-        let(:arg_info) do
-          get_method_introspection_data("GIMarshallingTests", "Object", "none_out").args[0]
-        end
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :pointer"]
-        end
-
-        it "has the correct value for #post_conversion" do
-          _(builder.post_conversion)
-            .must_equal [
-              "_v2 = GIMarshallingTests::Object.wrap(_v1.get_pointer(0)).tap" \
-              " { |it| it && it.ref }"
-            ]
-        end
-      end
-    end
-
-    describe "for :struct" do
-      describe "when not allocated by the caller" do
-        let(:arg_info) do
-          get_introspection_data("GIMarshallingTests", "boxed_struct_out").args[0]
-        end
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion).must_equal [
-            "_v1 = FFI::MemoryPointer.new :pointer"
-          ]
-        end
-
-        it "has the correct value for #post_conversion" do
-          _(builder.post_conversion)
-            .must_equal ["_v2 = GIMarshallingTests::BoxedStruct.wrap_copy("\
-                         "_v1.get_pointer(0))"]
-        end
-      end
-
-      describe "when allocated by the caller" do
-        let(:arg_info) do
-          get_method_introspection_data("Regress", "TestStructA", "clone").args[0]
-        end
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion).must_equal ["_v1 = Regress::TestStructA.new"]
-        end
-
-        it "has empty #post_conversion" do
-          _(builder.post_conversion).must_equal []
-        end
-      end
-    end
-
-    describe "for :strv" do
-      let(:arg_info) do
-        get_introspection_data("GIMarshallingTests", "gstrv_out").args[0]
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :pointer"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion).must_equal ["_v2 = GLib::Strv.wrap(_v1.get_pointer(0))"]
-      end
-    end
-
-    describe "for :array" do
-      describe "when allocated by the callee" do
-        let(:arg_info) do
-          get_introspection_data("GIMarshallingTests", "garray_utf8_none_out").args[0]
-        end
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :pointer"]
-        end
-
-        it "has the correct value for #post_conversion" do
-          _(builder.post_conversion)
-            .must_equal ["_v2 = GLib::Array.wrap(:utf8, _v1.get_pointer(0))"]
-        end
-      end
-
-      describe "when allocated by the caller" do
-        let(:function_info) do
-          get_introspection_data("GIMarshallingTests",
-                                 "garray_utf8_full_out_caller_allocated")
-        end
-
-        let(:arg_info) { function_info.args[0] }
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion).must_equal ["_v1 = GLib::Array.new :utf8"]
-        end
-
-        it "has empty #post_conversion" do
-          _(builder.post_conversion).must_equal []
-        end
-      end
-    end
-
-    describe "for :ptr_array" do
-      let(:arg_info) do
-        get_introspection_data("GIMarshallingTests", "gptrarray_utf8_none_out").args[0]
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :pointer"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion)
-          .must_equal ["_v2 = GLib::PtrArray.wrap(:utf8, _v1.get_pointer(0))"]
-      end
-    end
-
-    describe "for :error" do
-      let(:arg_info) do
-        get_introspection_data("GIMarshallingTests", "gerror_out").args[0]
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :pointer"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion).must_equal ["_v2 = GLib::Error.wrap(_v1.get_pointer(0))"]
-      end
-    end
-
-    describe "for :c" do
-      describe "with fixed size" do
-        let(:arg_info) do
-          get_introspection_data("GIMarshallingTests", "array_fixed_out").args[0]
-        end
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :pointer"]
-        end
-
-        it "has the correct value for #post_conversion" do
-          _(builder.post_conversion)
-            .must_equal ["_v2 = GirFFI::SizedArray.wrap(:gint32, 4, _v1.get_pointer(0))"]
-        end
-      end
-
-      describe "with separate size parameter" do
-        let(:arg_info) do
-          get_introspection_data("GIMarshallingTests", "array_out").args[0]
-        end
-
-        let(:length_argument) { Object.new }
-        before do
-          allow(length_argument).to receive(:post_converted_name).and_return "bar"
-          builder.length_arg = length_argument
-        end
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :pointer"]
-        end
-
-        it "has the correct value for #post_conversion" do
-          _(builder.post_conversion)
-            .must_equal ["_v2 = GirFFI::SizedArray.wrap(:gint32, bar, _v1.get_pointer(0))"]
-        end
-      end
-    end
-
-    describe "for :glist" do
-      let(:arg_info) do
-        get_introspection_data("GIMarshallingTests", "glist_utf8_none_out").args[0]
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :pointer"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion)
-          .must_equal ["_v2 = GLib::List.wrap(:utf8, _v1.get_pointer(0))"]
-      end
-    end
-
-    describe "for :gslist" do
-      let(:arg_info) do
-        get_introspection_data("GIMarshallingTests", "gslist_utf8_none_out").args[0]
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :pointer"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion)
-          .must_equal ["_v2 = GLib::SList.wrap(:utf8, _v1.get_pointer(0))"]
-      end
-    end
-
-    describe "for :ghash" do
-      let(:arg_info) do
-        get_introspection_data("GIMarshallingTests", "ghashtable_utf8_none_out").args[0]
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :pointer"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion)
-          .must_equal ["_v2 = GLib::HashTable.wrap([:utf8, :utf8], _v1.get_pointer(0))"]
-      end
-    end
-
-    describe "for :utf8" do
-      describe "with full ownership transfer" do
-        let(:arg_info) do
-          get_introspection_data("GIMarshallingTests", "utf8_full_out").args[0]
-        end
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :pointer"]
-        end
-
-        it "has the correct value for #post_conversion" do
-          _(builder.post_conversion).must_equal [
-            "_v2 = GirFFI::AllocationHelper.free_after _v1.get_pointer(0), &:to_utf8"
-          ]
-        end
-
-        it "has the correct value for #return_value_name" do
-          builder.post_conversion
-          _(builder.return_value_name).must_equal "_v2"
-        end
-      end
-
-      describe "with no ownership transfer" do
-        let(:arg_info) do
-          get_introspection_data("GIMarshallingTests", "utf8_none_out").args[0]
-        end
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :pointer"]
-        end
-
-        it "has the correct value for #post_conversion" do
-          _(builder.post_conversion).must_equal ["_v2 = _v1.get_pointer(0).to_utf8"]
-        end
-      end
-    end
-
-    describe "for :void" do
-      let(:function_info) do
-        get_introspection_data("Everything", "one_outparam_gpointer")
-      end
-      let(:arg_info) { function_info.args[0] }
-
-      before { skip_below "1.47.1" }
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :pointer"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion).must_equal ["_v2 = _v1.get_pointer(0)"]
-      end
-    end
-  end
-
-  describe "for an argument with direction :inout" do
-    describe "for :enum" do
-      let(:arg_info) do
-        get_introspection_data("GIMarshallingTests", "enum_inout").args[0]
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion)
-          .must_equal [
-            "_v1 = FFI::MemoryPointer.new GIMarshallingTests::Enum",
-            "GIMarshallingTests::Enum.copy_value_to_pointer(#{arg_info.name}, _v1)"
-          ]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion)
-          .must_equal ["_v2 = GIMarshallingTests::Enum.get_value_from_pointer(_v1, 0)"]
-      end
-    end
-
-    describe "for :flags" do
-      let(:arg_info) do
-        get_introspection_data("GIMarshallingTests", "no_type_flags_inout").args[0]
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion)
-          .must_equal [
-            "_v1 = FFI::MemoryPointer.new GIMarshallingTests::NoTypeFlags",
-            "GIMarshallingTests::NoTypeFlags.copy_value_to_pointer(#{arg_info.name}, _v1)"
-          ]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion)
-          .must_equal [
-            "_v2 = GIMarshallingTests::NoTypeFlags.get_value_from_pointer(_v1, 0)"
-          ]
-      end
-    end
-
-    describe "for :gint32" do
-      let(:arg_info) do
-        get_introspection_data("GIMarshallingTests", "int32_inout_min_max").args[0]
-      end
-
-      it "has the correct value for method_argument_name" do
-        _(builder.method_argument_name).must_equal arg_info.name
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :int32",
-                                              "_v1.put_int32 0, #{arg_info.name}"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion).must_equal ["_v2 = _v1.get_int32(0)"]
-      end
-    end
-
-    describe "for an array length" do
-      let(:function_info) do
-        get_introspection_data("Regress", "test_array_int_inout")
-      end
-      let(:arg_info) { function_info.args[0] }
-      let(:array_arg_info) { function_info.args[1] }
-      let(:array_arg_builder) do
-        GirFFI::Builders::ArgumentBuilder.new(var_gen, array_arg_info)
-      end
-
-      before do
-        builder.array_arg = array_arg_builder
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion).must_equal ["n_ints = ints.nil? ? 0 : ints.length",
-                                              "_v1 = FFI::MemoryPointer.new :int32",
-                                              "_v1.put_int32 0, n_ints"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion).must_equal ["_v2 = _v1.get_int32(0)"]
-      end
-    end
-
-    describe "for :strv" do
-      let(:arg_info) do
-        get_introspection_data("GIMarshallingTests", "gstrv_inout").args[0]
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :pointer",
-                                              "_v1.put_pointer 0, GLib::Strv.from(g_strv)"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion).must_equal ["_v2 = GLib::Strv.wrap(_v1.get_pointer(0))"]
-      end
-    end
-
-    describe "for :ptr_array" do
-      let(:arg_info) do
-        get_introspection_data("GIMarshallingTests", "gptrarray_utf8_none_inout").args[0]
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion)
-          .must_equal ["_v1 = FFI::MemoryPointer.new :pointer",
-                       "_v1.put_pointer 0, GLib::PtrArray.from(:utf8, parray_)"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion)
-          .must_equal ["_v2 = GLib::PtrArray.wrap(:utf8, _v1.get_pointer(0))"]
-      end
-    end
-
-    describe "for :utf8" do
-      let(:arg_info) do
-        get_introspection_data("GIMarshallingTests", "utf8_none_inout").args[0]
-      end
-
-      it "has the correct value for #pre_conversion" do
-        _(builder.pre_conversion)
-          .must_equal ["_v1 = FFI::MemoryPointer.new :pointer",
-                       "_v1.put_pointer 0, GirFFI::InPointer.from_utf8(utf8)"]
-      end
-
-      it "has the correct value for #post_conversion" do
-        _(builder.post_conversion).must_equal ["_v2 = _v1.get_pointer(0).to_utf8"]
-      end
-    end
-
-    describe "for :struct" do
-      describe "with full ownership transfer" do
-        let(:arg_info) do
-          get_introspection_data("GIMarshallingTests", "boxed_struct_inout").args[0]
-        end
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion).must_equal [
-            "_v1 = FFI::MemoryPointer.new :pointer",
-            "_v1.put_pointer 0, GIMarshallingTests::BoxedStruct.copy_from(struct_)"
-          ]
-        end
-
-        it "has the correct value for #post_conversion" do
-          _(builder.post_conversion)
-            .must_equal [
-              "_v2 = GIMarshallingTests::BoxedStruct.wrap_own(_v1.get_pointer(0))"
-            ]
-        end
-      end
-    end
-
-    describe "for :c" do
-      describe "with fixed size" do
-        let(:arg_info) do
-          get_introspection_data("GIMarshallingTests", "array_fixed_inout").args[0]
-        end
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion).must_equal [
-            'GirFFI::ArgHelper.check_fixed_array_size 4, ints, "ints"',
-            "_v1 = FFI::MemoryPointer.new :pointer",
-            "_v1.put_pointer 0, GirFFI::SizedArray.from(:gint32, 4, ints)"
-          ]
-        end
-
-        it "has the correct value for #post_conversion" do
-          _(builder.post_conversion)
-            .must_equal ["_v2 = GirFFI::SizedArray.wrap(:gint32, 4, _v1.get_pointer(0))"]
-        end
-      end
-
-      describe "with separate size parameter" do
-        let(:function_info) do
-          get_introspection_data("Regress", "test_array_int_inout")
-        end
-        let(:length_arg_info) { function_info.args[0] }
-        let(:arg_info) { function_info.args[1] }
-        let(:length_arg_builder) do
-          GirFFI::Builders::ArgumentBuilder.new(var_gen, length_arg_info)
-        end
-
-        before do
-          builder.length_arg = length_arg_builder
-        end
-
-        it "has the correct value for #pre_conversion" do
-          _(builder.pre_conversion).must_equal [
-            "_v1 = FFI::MemoryPointer.new :pointer",
-            "_v1.put_pointer 0, GirFFI::SizedArray.copy_from(:gint32, -1, ints)"
-          ]
-        end
-
-        it "has the correct value for #post_conversion" do
-          _(builder.post_conversion)
-            .must_equal ["_v3 = GirFFI::SizedArray.wrap(:gint32, _v2, _v1.get_pointer(0))"]
-        end
-      end
-    end
-  end
-
-  describe "for a skipped argument with direction :in" do
-    let(:arg_info) do
-      get_method_introspection_data("Regress", "TestObj", "skip_param").args[2]
-    end
-
-    it "has the correct value for method_argument_name" do
-      _(builder.method_argument_name).must_be_nil
-    end
-
-    it "has the correct value for #pre_conversion" do
-      _(builder.pre_conversion).must_equal ["_v1 = 0"]
-    end
-
-    it "has the correct value for #post_conversion" do
-      _(builder.post_conversion).must_equal []
-    end
-  end
-
-  describe "for a skipped argument with direction :inout" do
-    let(:arg_info) do
-      get_method_introspection_data("Regress", "TestObj", "skip_inout_param").args[3]
-    end
-
-    it "has the correct value for method_argument_name" do
-      _(builder.method_argument_name).must_be_nil
-    end
-
-    it "has the correct value for #pre_conversion" do
-      _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :int32",
-                                            "_v1.put_int32 0, 0"]
-    end
-
-    it "has the correct value for #post_conversion" do
-      _(builder.post_conversion).must_equal []
-    end
-  end
-
-  describe "for a skipped argument with direction :out" do
-    let(:arg_info) do
-      get_method_introspection_data("Regress", "TestObj", "skip_out_param").args[1]
-    end
-
-    it "has the correct value for method_argument_name" do
-      _(builder.method_argument_name).must_be_nil
-    end
-
-    it "has the correct value for #pre_conversion" do
-      _(builder.pre_conversion).must_equal ["_v1 = FFI::MemoryPointer.new :int32"]
-    end
-
-    it "has the correct value for #post_conversion" do
-      _(builder.post_conversion).must_equal []
-    end
-  end
-
-  describe "for an argument with direction :error" do
-    let(:arg_info) { GirFFI::ErrorArgumentInfo.new }
-
-    it "has the correct value for #pre_conversion" do
-      _(builder.pre_conversion).must_equal [
-        "_v1 = FFI::MemoryPointer.new(:pointer).write_pointer nil"
-      ]
-    end
-
-    it "has the correct value for #post_conversion" do
-      _(builder.post_conversion).must_equal [
-        "GirFFI::ArgHelper.check_error(_v1)"
-      ]
-    end
-  end
-end