gir_ffi 0.5.2 → 0.6.0

data/test/gir_ffi/argument_builder_test.rb

@@ -21,9 +21,7 @@ describe GirFFI::ArgumentBuilder do
         stub(interface_type_info = Object.new).namespace { "Bar" }
         stub(interface_type_info).name { "Foo" }
 
-        stub(type_info).tag { :interface }
         stub(type_info).flattened_tag { :callback }
-        stub(type_info).type_specification { ":callback" }
         stub(type_info).interface { interface_type_info }
       end
 
@@ -38,7 +36,6 @@ describe GirFFI::ArgumentBuilder do
 
     describe "for :zero_terminated" do
       before do
-        stub(type_info).tag { :array }
         stub(type_info).flattened_tag { :zero_terminated }
         stub(type_info).element_type { :foo }
       end
@@ -58,9 +55,7 @@ describe GirFFI::ArgumentBuilder do
 
     describe "for :enum" do
       before do
-        stub(type_info).tag { :interface }
         stub(type_info).flattened_tag { :enum }
-        stub(type_info).type_specification { ":enum" }
       end
 
       it "has the correct value for #pre" do
@@ -74,9 +69,7 @@ describe GirFFI::ArgumentBuilder do
 
     describe "for :flags" do
       before do
-        stub(type_info).tag { :interface }
         stub(type_info).flattened_tag { :flags }
-        stub(type_info).type_specification { ":flags" }
       end
 
       it "has the correct value for #pre" do
@@ -90,9 +83,7 @@ describe GirFFI::ArgumentBuilder do
 
     describe "for :object" do
       before do
-        stub(type_info).tag { :interface }
         stub(type_info).flattened_tag { :object }
-        stub(type_info).type_specification { ":object" }
       end
 
       describe "when not allocated by the caller" do
@@ -115,7 +106,7 @@ describe GirFFI::ArgumentBuilder do
         end
 
         it "has the correct value for #pre" do
-          builder.pre.must_equal [ "_v1 = Bar::Foo.allocate" ]
+          builder.pre.must_equal [ "_v1 = Bar::Foo._allocate" ]
         end
 
         it "has the correct value for #post" do
@@ -126,9 +117,7 @@ describe GirFFI::ArgumentBuilder do
 
     describe "for :struct" do
       before do
-        stub(type_info).tag { :interface }
         stub(type_info).flattened_tag { :struct }
-        stub(type_info).type_specification { ":struct" }
       end
 
       describe "when not allocated by the caller" do
@@ -151,7 +140,7 @@ describe GirFFI::ArgumentBuilder do
         end
 
         it "has the correct value for #pre" do
-          builder.pre.must_equal [ "_v1 = Bar::Foo.allocate" ]
+          builder.pre.must_equal [ "_v1 = Bar::Foo._allocate" ]
         end
 
         it "has the correct value for #post" do
@@ -162,13 +151,11 @@ describe GirFFI::ArgumentBuilder do
 
     describe "for :strv" do
       before do
-        stub(type_info).tag { :array }
         stub(type_info).flattened_tag { :strv }
-        stub(type_info).type_specification { "[:strv, :utf8]" }
       end
 
       it "has the correct value for #pre" do
-        builder.pre.must_equal [ "_v1 = GirFFI::InOutPointer.for [:strv, :utf8]" ]
+        builder.pre.must_equal [ "_v1 = GirFFI::InOutPointer.for :strv" ]
       end
 
       it "has the correct value for #post" do
@@ -178,10 +165,8 @@ describe GirFFI::ArgumentBuilder do
 
     describe "for :array" do
       before do
-        stub(type_info).tag { :array }
         stub(type_info).flattened_tag { :array }
         stub(type_info).element_type { :foo }
-        stub(type_info).type_specification { ":array" }
       end
 
       it "has the correct value for #pre" do
@@ -194,50 +179,47 @@ describe GirFFI::ArgumentBuilder do
     end
 
     describe "for :c" do
+      before do
+        stub(type_info).flattened_tag { :c }
+        stub(type_info).subtype_tag_or_class_name { ":foo" }
+      end
+
       describe "with fixed size" do
         before do
-          stub(type_info).tag { :array }
-          stub(type_info).flattened_tag { :c }
-          stub(type_info).type_specification { "[:c, :foo]" }
           stub(type_info).array_fixed_size { 3 }
         end
 
         it "has the correct value for #pre" do
-          builder.pre.must_equal [ "_v1 = GirFFI::InOutPointer.for [:c, :foo]" ]
+          builder.pre.must_equal [ "_v1 = GirFFI::InOutPointer.for :c" ]
         end
 
         it "has the correct value for #post" do
-          builder.post.must_equal [ "_v2 = _v1.to_sized_array_value 3" ]
+          builder.post.must_equal [ "_v2 = GLib::SizedArray.wrap(:foo, 3, _v1.to_value)" ]
         end
       end
 
       describe "with separate size parameter" do
         let(:length_argument) { Object.new }
         before do
-          stub(type_info).tag { :array }
-          stub(type_info).flattened_tag { :c }
-          stub(type_info).type_specification { "[:c, :foo]" }
           stub(type_info).array_fixed_size { -1 }
           stub(length_argument).retname { "bar" }
           builder.length_arg = length_argument
         end
 
         it "has the correct value for #pre" do
-          builder.pre.must_equal [ "_v1 = GirFFI::InOutPointer.for [:c, :foo]" ]
+          builder.pre.must_equal [ "_v1 = GirFFI::InOutPointer.for :c" ]
         end
 
         it "has the correct value for #post" do
-          builder.post.must_equal [ "_v2 = _v1.to_sized_array_value bar" ]
+          builder.post.must_equal [ "_v2 = GLib::SizedArray.wrap(:foo, bar, _v1.to_value)" ]
         end
       end
     end
 
     describe "for :glist" do
       before do
-        stub(type_info).tag { :glist }
         stub(type_info).flattened_tag { :glist }
         stub(type_info).element_type { :foo }
-        stub(type_info).type_specification { ":glist" }
       end
 
       it "has the correct value for #pre" do
@@ -251,10 +233,8 @@ describe GirFFI::ArgumentBuilder do
 
     describe "for :gslist" do
       before do
-        stub(type_info).tag { :gslist }
         stub(type_info).flattened_tag { :gslist }
         stub(type_info).element_type { :foo }
-        stub(type_info).type_specification { ":gslist" }
       end
 
       it "has the correct value for #pre" do
@@ -268,10 +248,8 @@ describe GirFFI::ArgumentBuilder do
 
     describe "for :ghash" do
       before do
-        stub(type_info).tag { :ghash }
         stub(type_info).flattened_tag { :ghash }
         stub(type_info).element_type { [:foo, :bar] }
-        stub(type_info).type_specification { ":ghash" }
       end
 
       it "has the correct value for #pre" do
@@ -289,7 +267,6 @@ describe GirFFI::ArgumentBuilder do
 
     describe "for :enum" do
       before do
-        stub(type_info).tag { :interface }
         stub(type_info).flattened_tag { :enum }
       end
 
@@ -304,7 +281,6 @@ describe GirFFI::ArgumentBuilder do
 
     describe "for :flags" do
       before do
-        stub(type_info).tag { :interface }
         stub(type_info).flattened_tag { :flags }
       end
 
@@ -319,7 +295,6 @@ describe GirFFI::ArgumentBuilder do
 
     describe "for :gint32" do
       before do
-        stub(type_info).tag { :gint32 }
         stub(type_info).flattened_tag { :gint32 }
       end
 
@@ -335,7 +310,6 @@ describe GirFFI::ArgumentBuilder do
     describe "for an array length" do
       let(:array_argument) { Object.new }
       before do
-        stub(type_info).tag { :gint32 }
         stub(type_info).flattened_tag { :gint32 }
         stub(array_argument).name { "foo_array" }
         builder.array_arg = array_argument
@@ -353,13 +327,11 @@ describe GirFFI::ArgumentBuilder do
 
     describe "for :strv" do
       before do
-        stub(type_info).tag { :array }
         stub(type_info).flattened_tag { :strv }
-        stub(type_info).type_specification { "[:strv, :utf8]" }
       end
 
       it "has the correct value for #pre" do
-        builder.pre.must_equal [ "_v1 = GirFFI::InOutPointer.from [:strv, :utf8], GLib::Strv.from(foo)" ]
+        builder.pre.must_equal [ "_v1 = GirFFI::InOutPointer.from :pointer, GLib::Strv.from(foo)" ]
       end
 
       it "has the correct value for #post" do
@@ -369,47 +341,44 @@ describe GirFFI::ArgumentBuilder do
 
     describe "for :utf8" do
       before do
-        stub(type_info).tag { :utf8 }
         stub(type_info).flattened_tag { :utf8 }
-        stub(type_info).type_specification { ":utf8" }
       end
 
       it "has the correct value for #pre" do
-        builder.pre.must_equal [ "_v1 = GirFFI::InOutPointer.from :utf8, foo" ]
+        builder.pre.must_equal [ "_v1 = GirFFI::InOutPointer.from :pointer, GirFFI::InPointer.from(:utf8, foo)" ]
       end
 
       it "has the correct value for #post" do
-        builder.post.must_equal [ "_v2 = _v1.to_value" ]
+        builder.post.must_equal [ "_v2 = ArgHelper.ptr_to_utf8 _v1.to_value" ]
       end
     end
 
     describe "for :c" do
+      before do
+        stub(type_info).flattened_tag { :c }
+        stub(type_info).subtype_tag_or_class_name { ":bar" }
+      end
+
       describe "with fixed size" do
         before do
-          stub(type_info).tag { :array }
-          stub(type_info).flattened_tag { :c }
-          stub(type_info).type_specification { "[:c, :bar]" }
           stub(type_info).array_fixed_size { 3 }
         end
 
         it "has the correct value for #pre" do
           builder.pre.must_equal [
             "GirFFI::ArgHelper.check_fixed_array_size 3, foo, \"foo\"",
-            "_v1 = GirFFI::InOutPointer.from [:c, :bar], foo"
+            "_v1 = GirFFI::InOutPointer.from :pointer, GLib::SizedArray.from(:bar, 3, foo)"
           ]
         end
 
         it "has the correct value for #post" do
-          builder.post.must_equal [ "_v2 = _v1.to_sized_array_value 3" ]
+          builder.post.must_equal [ "_v2 = GLib::SizedArray.wrap(:bar, 3, _v1.to_value)" ]
         end
       end
 
       describe "with separate size parameter" do
         let(:length_argument) { Object.new }
         before do
-          stub(type_info).tag { :array }
-          stub(type_info).flattened_tag { :c }
-          stub(type_info).type_specification { "[:c, :bar]" }
           stub(type_info).array_fixed_size { -1 }
           stub(length_argument).retname { "baz" }
           builder.length_arg = length_argument
@@ -417,11 +386,13 @@ describe GirFFI::ArgumentBuilder do
 
         it "has the correct value for #pre" do
           # TODO: Perhaps this should include a length check as well.
-          builder.pre.must_equal [ "_v1 = GirFFI::InOutPointer.from [:c, :bar], foo" ]
+          builder.pre.must_equal [
+            "_v1 = GirFFI::InOutPointer.from :pointer, GLib::SizedArray.from(:bar, -1, foo)"
+          ]
         end
 
         it "has the correct value for #post" do
-          builder.post.must_equal [ "_v2 = _v1.to_sized_array_value baz" ]
+          builder.post.must_equal [ "_v2 = GLib::SizedArray.wrap(:bar, baz, _v1.to_value)" ]
         end
       end
     end

data/test/gir_ffi/builder/type/unintrospectable_test.rb

@@ -12,7 +12,8 @@ describe GirFFI::Builder::Type::Unintrospectable do
       Gio::Lib.g_file_new_for_path(ptr)
 
       @gtype = GObject.type_from_name 'GLocalFile'
-      @bldr = GirFFI::Builder::Type::Unintrospectable.new(@gtype)
+      @info = GirFFI::UnintrospectableTypeInfo.new(@gtype)
+      @bldr = GirFFI::Builder::Type::Unintrospectable.new(@info)
       @klass = @bldr.build_class
     end
 
@@ -29,7 +30,7 @@ describe GirFFI::Builder::Type::Unintrospectable do
     end
 
     it "returns the same class when built again" do
-      other_bldr = GirFFI::Builder::Type::Unintrospectable.new(@gtype)
+      other_bldr = GirFFI::Builder::Type::Unintrospectable.new(@info)
       other_klass = other_bldr.build_class
 
       assert_equal @klass, other_klass
@@ -47,21 +48,4 @@ describe GirFFI::Builder::Type::Unintrospectable do
       end
     end
   end
-
-  # FIXME: Testing a private method, and with rather a lot of
-  # mocking, too.
-  describe "#interfaces" do
-    it "skips interfaces that have no introspection data" do
-      bldr = GirFFI::Builder::Type::Unintrospectable.new(:some_type)
-
-      mock(bldr).interface_gtypes { [:foo, :bar ] }
-      mock(gir = Object.new).find_by_gtype(:foo) { :foo_info }
-      mock(gir).find_by_gtype(:bar) { nil }
-      bldr.instance_eval { @gir = gir }
-      mock(GirFFI::Builder).build_class(:foo_info) { :foo_module }
-
-      result = bldr.send :interfaces
-      result.must_equal [:foo_module]
-    end
-  end
 end

data/test/gir_ffi/builder/type/user_defined_test.rb

@@ -3,41 +3,36 @@ require 'gir_ffi_test_helper'
 GirFFI.setup :GIMarshallingTests
 
 describe GirFFI::Builder::Type::UserDefined do
-  describe "with a block with a call to #install_property" do
+  describe "with type info containing one property" do
     before do
       @klass = Class.new GIMarshallingTests::OverridesObject
       Object.const_set "DerivedC#{Sequence.next}", @klass
-      @builder = GirFFI::Builder::Type::UserDefined.new @klass do
+
+      @info = GirFFI::UserDefinedTypeInfo.new @klass do
         install_property GObject.param_spec_int("foo", "foo bar",
                                                 "The Foo Bar Property",
                                                 10, 20, 15,
                                                 3)
       end
+
+      @builder = GirFFI::Builder::Type::UserDefined.new @info
       @builder.build_class
     end
 
-    it "has one property of type GirFFI::UserDefined::IPropertyInfo" do
-      props = @builder.send(:properties)
-      props.length.must_equal 1
-      props[0].must_be_instance_of GirFFI::UserDefined::IPropertyInfo
+    it "registers a type that is bigger than the parent" do
+      gtype = @klass.get_gtype
+      q = GObject.type_query gtype
+      q.instance_size.must_be :>, GIMarshallingTests::OverridesObject::Struct.size
     end
 
-    describe "the info attribute" do
-      before do
-        @info = @builder.info
-      end
-
-      it "is an object of type GirFFI::UserDefined::IObjectInfo" do
-        @info.must_be_instance_of GirFFI::UserDefined::IObjectInfo
-      end
+    it "gives the types Struct the fields :parent and :foo" do
+      @klass::Struct.members.must_equal [:parent, :foo]
+    end
 
-      it "knows about the single property :foo" do
-        props = @info.properties
-        props.length.must_equal 1
-        foo_property = props[0]
-        foo_property.must_be_instance_of GirFFI::UserDefined::IPropertyInfo
-        foo_property.name.must_equal "foo"
-      end
+    it "creates accessor functions for the property" do
+      obj = @klass.new
+      obj.foo = 13
+      obj.foo.must_equal 13
     end
   end
 end

data/test/gir_ffi/builder_test.rb

@@ -5,33 +5,6 @@ describe GirFFI::Builder do
     @gir = GObjectIntrospection::IRepository.default
   end
 
-  describe "::itypeinfo_to_callback_ffitype" do
-    describe "for an :interface argument" do
-      before do
-        @iface = Object.new
-        stub(@info = Object.new).interface { @iface }
-        stub(@info).tag { :interface }
-        stub(@info).pointer? { false }
-      end
-
-      it "correctly maps a :union argument to :pointer" do
-        stub(@iface).info_type { :union }
-
-        result = GirFFI::Builder.itypeinfo_to_callback_ffitype @info
-
-        assert_equal :pointer, result
-      end
-
-      it "correctly maps a :flags argument to :int32" do
-        stub(@iface).info_type { :flags }
-
-        result = GirFFI::Builder.itypeinfo_to_callback_ffitype @info
-
-        assert_equal :int32, result
-      end
-    end
-  end
-
   describe "building GObject::Object" do
     before do
       save_module :GObject
@@ -63,12 +36,6 @@ describe GirFFI::Builder do
       @go = get_introspection_data 'Regress', 'test_callback_destroy_notify'
     end
 
-    should "have the correct types of the arguments for the attached function" do
-      argtypes = GirFFI::Builder.send(:ffi_function_argument_types, @go)
-      assert_equal [Regress::TestCallbackUserData, :pointer, GLib::DestroyNotify],
-        argtypes
-    end
-
     should "define ffi callback types :Callback and :ClosureNotify" do
       Regress.setup_method 'test_callback_destroy_notify'
       tcud = Regress::Lib.find_type :TestCallbackUserData
@@ -80,6 +47,13 @@ describe GirFFI::Builder do
       assert_equal [FFI.find_type(:pointer)], dn.param_types
     end
 
+    it "calls attach_function with the correct types" do
+      argtypes = [ Regress::TestCallbackUserData, :pointer, GLib::DestroyNotify ]
+      mock(Regress::Lib).attach_function("regress_test_callback_destroy_notify",
+                                         argtypes, :int32) { true }
+      GirFFI::Builder.attach_ffi_function(Regress::Lib, @go)
+    end
+
     after do
       restore_module :Regress
       restore_module :GObject
@@ -210,11 +184,26 @@ describe GirFFI::Builder do
     end
 
     describe "its #torture_signature_0 method" do
-      should "have the correct types of the arguments for the attached function" do
+      it "is attached with the correct ffi types" do
         info = get_method_introspection_data 'Regress', 'TestObj',
           'torture_signature_0'
-        assert_equal [:pointer, :int32, :pointer, :pointer, :pointer, :pointer, :uint32],
-          GirFFI::Builder.send(:ffi_function_argument_types, info)
+
+        argtypes = [:pointer, :int32, :pointer, :pointer, :pointer, :pointer, :uint32]
+        mock(Regress::Lib).attach_function("regress_test_obj_torture_signature_0",
+                                           argtypes, :void) { true }
+        GirFFI::Builder.attach_ffi_function(Regress::Lib, info)
+      end
+    end
+
+    describe "its #instance_method method" do
+      setup do
+      end
+
+      it "is attached with the correct ffi types" do
+        info = get_method_introspection_data 'Regress', 'TestObj', 'instance_method'
+        mock(Regress::Lib).attach_function("regress_test_obj_instance_method",
+                                           [:pointer], :int32) { true }
+        GirFFI::Builder.attach_ffi_function(Regress::Lib, info)
       end
     end
 
@@ -356,30 +345,19 @@ describe GirFFI::Builder do
     end
 
     it "attaches function to Regress::Lib" do
-      GirFFI::Builder.send :attach_ffi_function, Regress::Lib, @go
+      GirFFI::Builder.attach_ffi_function Regress::Lib, @go
       assert_defines_singleton_method Regress::Lib, :regress_test_array_gint32_in
     end
 
-    it "has :pointer, :pointer as types of the arguments for the attached function" do
-      assert_equal [:int32, :pointer], GirFFI::Builder.send(:ffi_function_argument_types, @go)
-    end
-
-    it "has :void as return type for the attached function" do
-      assert_equal :int32, GirFFI::Builder.send(:ffi_function_return_type, @go)
+    it "calls attach_function with the correct types" do
+      argtypes = [:int32, :pointer]
+      mock(Regress::Lib).attach_function("regress_test_array_gint32_in",
+                                         argtypes, :int32) { true }
+      GirFFI::Builder.attach_ffi_function(Regress::Lib, @go)
     end
 
     after do
       restore_module :Regress
     end
   end
-
-  describe "looking at Regress::TestObj#instance_method" do
-    setup do
-      @go = get_method_introspection_data 'Regress', 'TestObj', 'instance_method'
-    end
-
-    it "has :pointer as types of the arguments for the attached function" do
-      assert_equal [:pointer], GirFFI::Builder.send(:ffi_function_argument_types, @go)
-    end
-  end
 end

data/test/gir_ffi/callback_helper_test.rb

@@ -1,53 +1,6 @@
 require 'gir_ffi_test_helper'
-require "gir_ffi/callback_helper"
 
 describe GirFFI::CallbackHelper do
-  describe "::map_single_callback_arg" do
-    it "maps a :struct type by building the type and wrapping the argument in it" do
-      cinfo = get_introspection_data 'GObject', 'ClosureMarshal'
-      ainfo = cinfo.args[0]
-      ifinfo = ainfo.argument_type.interface
-
-      assert_equal :struct, ifinfo.info_type
-
-      struct_class = Class.new
-      mock(GirFFI::Builder).build_class(ifinfo) { struct_class }
-      mock(struct_class).wrap("dummy") { "good-result" }
-
-      r = GirFFI::CallbackHelper.map_single_callback_arg "dummy", ainfo.argument_type
-
-      assert_equal "good-result", r
-    end
-
-    it "maps an :interface type by calling #to_object on the argument" do
-      cinfo = get_introspection_data 'Gtk', 'CellLayoutDataFunc'
-      ainfo = cinfo.args[0]
-      ifinfo = ainfo.argument_type.interface
-
-      assert_equal :interface, ifinfo.info_type
-
-      mock(ptr = Object.new).to_object { "good-result" }
-
-      r = GirFFI::CallbackHelper.map_single_callback_arg ptr, ainfo.argument_type
-
-      assert_equal "good-result", r
-    end
-
-    it "maps an :object type by calling #to_object on the argument" do
-      cinfo = get_introspection_data 'Gtk', 'CellLayoutDataFunc'
-      ainfo = cinfo.args[1]
-      ifinfo = ainfo.argument_type.interface
-
-      assert_equal :object, ifinfo.info_type
-
-      mock(ptr = Object.new).to_object { "good-result" }
-
-      r = GirFFI::CallbackHelper.map_single_callback_arg ptr, ainfo.argument_type
-
-      assert_equal "good-result", r
-    end
-  end
-
   describe ".store_callback" do
     it "stores the passed in proc in GirFFI::CallbackHelper::CALLBACKS" do
       GirFFI::CallbackHelper.store_callback "some-callback"

data/test/gir_ffi/callback_test.rb

@@ -0,0 +1,49 @@
+require 'gir_ffi_test_helper'
+
+describe GirFFI::Callback do
+  describe "::map_single_callback_arg" do
+    it "maps a :struct type by building the type and wrapping the argument in it" do
+      cinfo = get_introspection_data 'GObject', 'ClosureMarshal'
+      ainfo = cinfo.args[0]
+      ifinfo = ainfo.argument_type.interface
+
+      assert_equal :struct, ifinfo.info_type
+
+      struct_class = Class.new
+      mock(GirFFI::Builder).build_class(ifinfo) { struct_class }
+      mock(struct_class).wrap("dummy") { "good-result" }
+
+      r = GirFFI::Callback.map_single_callback_arg "dummy", ainfo.argument_type
+
+      assert_equal "good-result", r
+    end
+
+    it "maps an :interface type by calling #to_object on the argument" do
+      cinfo = get_introspection_data 'Gtk', 'CellLayoutDataFunc'
+      ainfo = cinfo.args[0]
+      ifinfo = ainfo.argument_type.interface
+
+      assert_equal :interface, ifinfo.info_type
+
+      mock(ptr = Object.new).to_object { "good-result" }
+
+      r = GirFFI::Callback.map_single_callback_arg ptr, ainfo.argument_type
+
+      assert_equal "good-result", r
+    end
+
+    it "maps an :object type by calling #to_object on the argument" do
+      cinfo = get_introspection_data 'Gtk', 'CellLayoutDataFunc'
+      ainfo = cinfo.args[1]
+      ifinfo = ainfo.argument_type.interface
+
+      assert_equal :object, ifinfo.info_type
+
+      mock(ptr = Object.new).to_object { "good-result" }
+
+      r = GirFFI::Callback.map_single_callback_arg ptr, ainfo.argument_type
+
+      assert_equal "good-result", r
+    end
+  end
+end

data/test/gir_ffi/function_builder_test.rb

@@ -9,9 +9,9 @@ describe GirFFI::FunctionBuilder do
 
     expected = <<-CODE
       def self.test_array_fixed_out_objects 
-        _v1 = GirFFI::InOutPointer.for [:c, [:pointer, ::Regress::TestObj]]
+        _v1 = GirFFI::InOutPointer.for :c
         DummyLib.regress_test_array_fixed_out_objects _v1
-        _v2 = _v1.to_sized_array_value 2
+        _v2 = GLib::SizedArray.wrap([:pointer, ::Regress::TestObj], 2, _v1.to_value)
         return _v2
       end
     CODE
@@ -28,7 +28,7 @@ describe GirFFI::FunctionBuilder do
       def self.test_array_gint16_in ints
         n_ints = ints.nil? ? 0 : ints.length
         _v1 = n_ints
-        _v2 = GirFFI::InPointer.from([:c, :gint16], ints)
+        _v2 = GLib::SizedArray.from(:gint16, -1, ints)
         _v3 = DummyLib.regress_test_array_gint16_in _v1, _v2
         return _v3
       end
@@ -97,7 +97,7 @@ describe GirFFI::FunctionBuilder do
 
     expected = <<-CODE
       def self.test_array_int_null_in arr
-        _v1 = GirFFI::InPointer.from([:c, :gint32], arr)
+        _v1 = GLib::SizedArray.from(:gint32, -1, arr)
         len = arr.nil? ? 0 : arr.length
         _v2 = len
         DummyLib.regress_test_array_int_null_in _v1, _v2
@@ -115,11 +115,11 @@ describe GirFFI::FunctionBuilder do
 
     expected = <<-CODE
       def self.test_array_int_null_out 
-        _v1 = GirFFI::InOutPointer.for [:c, :gint32]
+        _v1 = GirFFI::InOutPointer.for :c
         _v2 = GirFFI::InOutPointer.for :gint32
         DummyLib.regress_test_array_int_null_out _v1, _v2
         _v3 = _v2.to_value
-        _v4 = _v1.to_sized_array_value _v3
+        _v4 = GLib::SizedArray.wrap(:gint32, _v3, _v1.to_value)
         return _v4
       end
     CODE
@@ -134,12 +134,12 @@ describe GirFFI::FunctionBuilder do
 
     expected = <<-CODE
       def method_array_inout ints
-        _v1 = GirFFI::InOutPointer.from [:c, :gint32], ints
+        _v1 = GirFFI::InOutPointer.from :pointer, GLib::SizedArray.from(:gint32, -1, ints)
         length = ints.nil? ? 0 : ints.length
         _v2 = GirFFI::InOutPointer.from :gint32, length
         DummyLib.gi_marshalling_tests_object_method_array_inout self, _v1, _v2
         _v3 = _v2.to_value
-        _v4 = _v1.to_sized_array_value _v3
+        _v4 = GLib::SizedArray.wrap(:gint32, _v3, _v1.to_value)
         return _v4
       end
     CODE